Daily bump.
[gcc.git] / gcc / tree.c
1 /* Language-independent node constructors for parse phase of GNU compiler.
2 Copyright (C) 1987-2017 Free Software Foundation, Inc.
3
4 This file is part of GCC.
5
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.
10
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.
15
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/>. */
19
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.
26
27 It is intended to be language-independent but can occasionally
28 calls language-dependent routines. */
29
30 #include "config.h"
31 #include "system.h"
32 #include "coretypes.h"
33 #include "backend.h"
34 #include "target.h"
35 #include "tree.h"
36 #include "gimple.h"
37 #include "tree-pass.h"
38 #include "ssa.h"
39 #include "cgraph.h"
40 #include "diagnostic.h"
41 #include "flags.h"
42 #include "alias.h"
43 #include "fold-const.h"
44 #include "stor-layout.h"
45 #include "calls.h"
46 #include "attribs.h"
47 #include "toplev.h" /* get_random_seed */
48 #include "output.h"
49 #include "common/common-target.h"
50 #include "langhooks.h"
51 #include "tree-inline.h"
52 #include "tree-iterator.h"
53 #include "internal-fn.h"
54 #include "gimple-iterator.h"
55 #include "gimplify.h"
56 #include "tree-dfa.h"
57 #include "params.h"
58 #include "langhooks-def.h"
59 #include "tree-diagnostic.h"
60 #include "except.h"
61 #include "builtins.h"
62 #include "print-tree.h"
63 #include "ipa-utils.h"
64 #include "selftest.h"
65
66 /* Tree code classes. */
67
68 #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) TYPE,
69 #define END_OF_BASE_TREE_CODES tcc_exceptional,
70
71 const enum tree_code_class tree_code_type[] = {
72 #include "all-tree.def"
73 };
74
75 #undef DEFTREECODE
76 #undef END_OF_BASE_TREE_CODES
77
78 /* Table indexed by tree code giving number of expression
79 operands beyond the fixed part of the node structure.
80 Not used for types or decls. */
81
82 #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) LENGTH,
83 #define END_OF_BASE_TREE_CODES 0,
84
85 const unsigned char tree_code_length[] = {
86 #include "all-tree.def"
87 };
88
89 #undef DEFTREECODE
90 #undef END_OF_BASE_TREE_CODES
91
92 /* Names of tree components.
93 Used for printing out the tree and error messages. */
94 #define DEFTREECODE(SYM, NAME, TYPE, LEN) NAME,
95 #define END_OF_BASE_TREE_CODES "@dummy",
96
97 static const char *const tree_code_name[] = {
98 #include "all-tree.def"
99 };
100
101 #undef DEFTREECODE
102 #undef END_OF_BASE_TREE_CODES
103
104 /* Each tree code class has an associated string representation.
105 These must correspond to the tree_code_class entries. */
106
107 const char *const tree_code_class_strings[] =
108 {
109 "exceptional",
110 "constant",
111 "type",
112 "declaration",
113 "reference",
114 "comparison",
115 "unary",
116 "binary",
117 "statement",
118 "vl_exp",
119 "expression"
120 };
121
122 /* obstack.[ch] explicitly declined to prototype this. */
123 extern int _obstack_allocated_p (struct obstack *h, void *obj);
124
125 /* Statistics-gathering stuff. */
126
127 static int tree_code_counts[MAX_TREE_CODES];
128 int tree_node_counts[(int) all_kinds];
129 int tree_node_sizes[(int) all_kinds];
130
131 /* Keep in sync with tree.h:enum tree_node_kind. */
132 static const char * const tree_node_kind_names[] = {
133 "decls",
134 "types",
135 "blocks",
136 "stmts",
137 "refs",
138 "exprs",
139 "constants",
140 "identifiers",
141 "vecs",
142 "binfos",
143 "ssa names",
144 "constructors",
145 "random kinds",
146 "lang_decl kinds",
147 "lang_type kinds",
148 "omp clauses",
149 };
150
151 /* Unique id for next decl created. */
152 static GTY(()) int next_decl_uid;
153 /* Unique id for next type created. */
154 static GTY(()) unsigned next_type_uid = 1;
155 /* Unique id for next debug decl created. Use negative numbers,
156 to catch erroneous uses. */
157 static GTY(()) int next_debug_decl_uid;
158
159 /* Since we cannot rehash a type after it is in the table, we have to
160 keep the hash code. */
161
162 struct GTY((for_user)) type_hash {
163 unsigned long hash;
164 tree type;
165 };
166
167 /* Initial size of the hash table (rounded to next prime). */
168 #define TYPE_HASH_INITIAL_SIZE 1000
169
170 struct type_cache_hasher : ggc_cache_ptr_hash<type_hash>
171 {
172 static hashval_t hash (type_hash *t) { return t->hash; }
173 static bool equal (type_hash *a, type_hash *b);
174
175 static int
176 keep_cache_entry (type_hash *&t)
177 {
178 return ggc_marked_p (t->type);
179 }
180 };
181
182 /* Now here is the hash table. When recording a type, it is added to
183 the slot whose index is the hash code. Note that the hash table is
184 used for several kinds of types (function types, array types and
185 array index range types, for now). While all these live in the
186 same table, they are completely independent, and the hash code is
187 computed differently for each of these. */
188
189 static GTY ((cache)) hash_table<type_cache_hasher> *type_hash_table;
190
191 /* Hash table and temporary node for larger integer const values. */
192 static GTY (()) tree int_cst_node;
193
194 struct int_cst_hasher : ggc_cache_ptr_hash<tree_node>
195 {
196 static hashval_t hash (tree t);
197 static bool equal (tree x, tree y);
198 };
199
200 static GTY ((cache)) hash_table<int_cst_hasher> *int_cst_hash_table;
201
202 /* Hash table for optimization flags and target option flags. Use the same
203 hash table for both sets of options. Nodes for building the current
204 optimization and target option nodes. The assumption is most of the time
205 the options created will already be in the hash table, so we avoid
206 allocating and freeing up a node repeatably. */
207 static GTY (()) tree cl_optimization_node;
208 static GTY (()) tree cl_target_option_node;
209
210 struct cl_option_hasher : ggc_cache_ptr_hash<tree_node>
211 {
212 static hashval_t hash (tree t);
213 static bool equal (tree x, tree y);
214 };
215
216 static GTY ((cache)) hash_table<cl_option_hasher> *cl_option_hash_table;
217
218 /* General tree->tree mapping structure for use in hash tables. */
219
220
221 static GTY ((cache))
222 hash_table<tree_decl_map_cache_hasher> *debug_expr_for_decl;
223
224 static GTY ((cache))
225 hash_table<tree_decl_map_cache_hasher> *value_expr_for_decl;
226
227 struct tree_vec_map_cache_hasher : ggc_cache_ptr_hash<tree_vec_map>
228 {
229 static hashval_t hash (tree_vec_map *m) { return DECL_UID (m->base.from); }
230
231 static bool
232 equal (tree_vec_map *a, tree_vec_map *b)
233 {
234 return a->base.from == b->base.from;
235 }
236
237 static int
238 keep_cache_entry (tree_vec_map *&m)
239 {
240 return ggc_marked_p (m->base.from);
241 }
242 };
243
244 static GTY ((cache))
245 hash_table<tree_vec_map_cache_hasher> *debug_args_for_decl;
246
247 static void set_type_quals (tree, int);
248 static void print_type_hash_statistics (void);
249 static void print_debug_expr_statistics (void);
250 static void print_value_expr_statistics (void);
251
252 tree global_trees[TI_MAX];
253 tree integer_types[itk_none];
254
255 bool int_n_enabled_p[NUM_INT_N_ENTS];
256 struct int_n_trees_t int_n_trees [NUM_INT_N_ENTS];
257
258 unsigned char tree_contains_struct[MAX_TREE_CODES][64];
259
260 /* Number of operands for each OpenMP clause. */
261 unsigned const char omp_clause_num_ops[] =
262 {
263 0, /* OMP_CLAUSE_ERROR */
264 1, /* OMP_CLAUSE_PRIVATE */
265 1, /* OMP_CLAUSE_SHARED */
266 1, /* OMP_CLAUSE_FIRSTPRIVATE */
267 2, /* OMP_CLAUSE_LASTPRIVATE */
268 5, /* OMP_CLAUSE_REDUCTION */
269 1, /* OMP_CLAUSE_COPYIN */
270 1, /* OMP_CLAUSE_COPYPRIVATE */
271 3, /* OMP_CLAUSE_LINEAR */
272 2, /* OMP_CLAUSE_ALIGNED */
273 1, /* OMP_CLAUSE_DEPEND */
274 1, /* OMP_CLAUSE_UNIFORM */
275 1, /* OMP_CLAUSE_TO_DECLARE */
276 1, /* OMP_CLAUSE_LINK */
277 2, /* OMP_CLAUSE_FROM */
278 2, /* OMP_CLAUSE_TO */
279 2, /* OMP_CLAUSE_MAP */
280 1, /* OMP_CLAUSE_USE_DEVICE_PTR */
281 1, /* OMP_CLAUSE_IS_DEVICE_PTR */
282 2, /* OMP_CLAUSE__CACHE_ */
283 2, /* OMP_CLAUSE_GANG */
284 1, /* OMP_CLAUSE_ASYNC */
285 1, /* OMP_CLAUSE_WAIT */
286 0, /* OMP_CLAUSE_AUTO */
287 0, /* OMP_CLAUSE_SEQ */
288 1, /* OMP_CLAUSE__LOOPTEMP_ */
289 1, /* OMP_CLAUSE_IF */
290 1, /* OMP_CLAUSE_NUM_THREADS */
291 1, /* OMP_CLAUSE_SCHEDULE */
292 0, /* OMP_CLAUSE_NOWAIT */
293 1, /* OMP_CLAUSE_ORDERED */
294 0, /* OMP_CLAUSE_DEFAULT */
295 3, /* OMP_CLAUSE_COLLAPSE */
296 0, /* OMP_CLAUSE_UNTIED */
297 1, /* OMP_CLAUSE_FINAL */
298 0, /* OMP_CLAUSE_MERGEABLE */
299 1, /* OMP_CLAUSE_DEVICE */
300 1, /* OMP_CLAUSE_DIST_SCHEDULE */
301 0, /* OMP_CLAUSE_INBRANCH */
302 0, /* OMP_CLAUSE_NOTINBRANCH */
303 1, /* OMP_CLAUSE_NUM_TEAMS */
304 1, /* OMP_CLAUSE_THREAD_LIMIT */
305 0, /* OMP_CLAUSE_PROC_BIND */
306 1, /* OMP_CLAUSE_SAFELEN */
307 1, /* OMP_CLAUSE_SIMDLEN */
308 0, /* OMP_CLAUSE_FOR */
309 0, /* OMP_CLAUSE_PARALLEL */
310 0, /* OMP_CLAUSE_SECTIONS */
311 0, /* OMP_CLAUSE_TASKGROUP */
312 1, /* OMP_CLAUSE_PRIORITY */
313 1, /* OMP_CLAUSE_GRAINSIZE */
314 1, /* OMP_CLAUSE_NUM_TASKS */
315 0, /* OMP_CLAUSE_NOGROUP */
316 0, /* OMP_CLAUSE_THREADS */
317 0, /* OMP_CLAUSE_SIMD */
318 1, /* OMP_CLAUSE_HINT */
319 0, /* OMP_CLAUSE_DEFALTMAP */
320 1, /* OMP_CLAUSE__SIMDUID_ */
321 0, /* OMP_CLAUSE__SIMT_ */
322 1, /* OMP_CLAUSE__CILK_FOR_COUNT_ */
323 0, /* OMP_CLAUSE_INDEPENDENT */
324 1, /* OMP_CLAUSE_WORKER */
325 1, /* OMP_CLAUSE_VECTOR */
326 1, /* OMP_CLAUSE_NUM_GANGS */
327 1, /* OMP_CLAUSE_NUM_WORKERS */
328 1, /* OMP_CLAUSE_VECTOR_LENGTH */
329 3, /* OMP_CLAUSE_TILE */
330 2, /* OMP_CLAUSE__GRIDDIM_ */
331 };
332
333 const char * const omp_clause_code_name[] =
334 {
335 "error_clause",
336 "private",
337 "shared",
338 "firstprivate",
339 "lastprivate",
340 "reduction",
341 "copyin",
342 "copyprivate",
343 "linear",
344 "aligned",
345 "depend",
346 "uniform",
347 "to",
348 "link",
349 "from",
350 "to",
351 "map",
352 "use_device_ptr",
353 "is_device_ptr",
354 "_cache_",
355 "gang",
356 "async",
357 "wait",
358 "auto",
359 "seq",
360 "_looptemp_",
361 "if",
362 "num_threads",
363 "schedule",
364 "nowait",
365 "ordered",
366 "default",
367 "collapse",
368 "untied",
369 "final",
370 "mergeable",
371 "device",
372 "dist_schedule",
373 "inbranch",
374 "notinbranch",
375 "num_teams",
376 "thread_limit",
377 "proc_bind",
378 "safelen",
379 "simdlen",
380 "for",
381 "parallel",
382 "sections",
383 "taskgroup",
384 "priority",
385 "grainsize",
386 "num_tasks",
387 "nogroup",
388 "threads",
389 "simd",
390 "hint",
391 "defaultmap",
392 "_simduid_",
393 "_simt_",
394 "_Cilk_for_count_",
395 "independent",
396 "worker",
397 "vector",
398 "num_gangs",
399 "num_workers",
400 "vector_length",
401 "tile",
402 "_griddim_"
403 };
404
405
406 /* Return the tree node structure used by tree code CODE. */
407
408 static inline enum tree_node_structure_enum
409 tree_node_structure_for_code (enum tree_code code)
410 {
411 switch (TREE_CODE_CLASS (code))
412 {
413 case tcc_declaration:
414 {
415 switch (code)
416 {
417 case FIELD_DECL:
418 return TS_FIELD_DECL;
419 case PARM_DECL:
420 return TS_PARM_DECL;
421 case VAR_DECL:
422 return TS_VAR_DECL;
423 case LABEL_DECL:
424 return TS_LABEL_DECL;
425 case RESULT_DECL:
426 return TS_RESULT_DECL;
427 case DEBUG_EXPR_DECL:
428 return TS_DECL_WRTL;
429 case CONST_DECL:
430 return TS_CONST_DECL;
431 case TYPE_DECL:
432 return TS_TYPE_DECL;
433 case FUNCTION_DECL:
434 return TS_FUNCTION_DECL;
435 case TRANSLATION_UNIT_DECL:
436 return TS_TRANSLATION_UNIT_DECL;
437 default:
438 return TS_DECL_NON_COMMON;
439 }
440 }
441 case tcc_type:
442 return TS_TYPE_NON_COMMON;
443 case tcc_reference:
444 case tcc_comparison:
445 case tcc_unary:
446 case tcc_binary:
447 case tcc_expression:
448 case tcc_statement:
449 case tcc_vl_exp:
450 return TS_EXP;
451 default: /* tcc_constant and tcc_exceptional */
452 break;
453 }
454 switch (code)
455 {
456 /* tcc_constant cases. */
457 case VOID_CST: return TS_TYPED;
458 case INTEGER_CST: return TS_INT_CST;
459 case REAL_CST: return TS_REAL_CST;
460 case FIXED_CST: return TS_FIXED_CST;
461 case COMPLEX_CST: return TS_COMPLEX;
462 case VECTOR_CST: return TS_VECTOR;
463 case STRING_CST: return TS_STRING;
464 /* tcc_exceptional cases. */
465 case ERROR_MARK: return TS_COMMON;
466 case IDENTIFIER_NODE: return TS_IDENTIFIER;
467 case TREE_LIST: return TS_LIST;
468 case TREE_VEC: return TS_VEC;
469 case SSA_NAME: return TS_SSA_NAME;
470 case PLACEHOLDER_EXPR: return TS_COMMON;
471 case STATEMENT_LIST: return TS_STATEMENT_LIST;
472 case BLOCK: return TS_BLOCK;
473 case CONSTRUCTOR: return TS_CONSTRUCTOR;
474 case TREE_BINFO: return TS_BINFO;
475 case OMP_CLAUSE: return TS_OMP_CLAUSE;
476 case OPTIMIZATION_NODE: return TS_OPTIMIZATION;
477 case TARGET_OPTION_NODE: return TS_TARGET_OPTION;
478
479 default:
480 gcc_unreachable ();
481 }
482 }
483
484
485 /* Initialize tree_contains_struct to describe the hierarchy of tree
486 nodes. */
487
488 static void
489 initialize_tree_contains_struct (void)
490 {
491 unsigned i;
492
493 for (i = ERROR_MARK; i < LAST_AND_UNUSED_TREE_CODE; i++)
494 {
495 enum tree_code code;
496 enum tree_node_structure_enum ts_code;
497
498 code = (enum tree_code) i;
499 ts_code = tree_node_structure_for_code (code);
500
501 /* Mark the TS structure itself. */
502 tree_contains_struct[code][ts_code] = 1;
503
504 /* Mark all the structures that TS is derived from. */
505 switch (ts_code)
506 {
507 case TS_TYPED:
508 case TS_BLOCK:
509 case TS_OPTIMIZATION:
510 case TS_TARGET_OPTION:
511 MARK_TS_BASE (code);
512 break;
513
514 case TS_COMMON:
515 case TS_INT_CST:
516 case TS_REAL_CST:
517 case TS_FIXED_CST:
518 case TS_VECTOR:
519 case TS_STRING:
520 case TS_COMPLEX:
521 case TS_SSA_NAME:
522 case TS_CONSTRUCTOR:
523 case TS_EXP:
524 case TS_STATEMENT_LIST:
525 MARK_TS_TYPED (code);
526 break;
527
528 case TS_IDENTIFIER:
529 case TS_DECL_MINIMAL:
530 case TS_TYPE_COMMON:
531 case TS_LIST:
532 case TS_VEC:
533 case TS_BINFO:
534 case TS_OMP_CLAUSE:
535 MARK_TS_COMMON (code);
536 break;
537
538 case TS_TYPE_WITH_LANG_SPECIFIC:
539 MARK_TS_TYPE_COMMON (code);
540 break;
541
542 case TS_TYPE_NON_COMMON:
543 MARK_TS_TYPE_WITH_LANG_SPECIFIC (code);
544 break;
545
546 case TS_DECL_COMMON:
547 MARK_TS_DECL_MINIMAL (code);
548 break;
549
550 case TS_DECL_WRTL:
551 case TS_CONST_DECL:
552 MARK_TS_DECL_COMMON (code);
553 break;
554
555 case TS_DECL_NON_COMMON:
556 MARK_TS_DECL_WITH_VIS (code);
557 break;
558
559 case TS_DECL_WITH_VIS:
560 case TS_PARM_DECL:
561 case TS_LABEL_DECL:
562 case TS_RESULT_DECL:
563 MARK_TS_DECL_WRTL (code);
564 break;
565
566 case TS_FIELD_DECL:
567 MARK_TS_DECL_COMMON (code);
568 break;
569
570 case TS_VAR_DECL:
571 MARK_TS_DECL_WITH_VIS (code);
572 break;
573
574 case TS_TYPE_DECL:
575 case TS_FUNCTION_DECL:
576 MARK_TS_DECL_NON_COMMON (code);
577 break;
578
579 case TS_TRANSLATION_UNIT_DECL:
580 MARK_TS_DECL_COMMON (code);
581 break;
582
583 default:
584 gcc_unreachable ();
585 }
586 }
587
588 /* Basic consistency checks for attributes used in fold. */
589 gcc_assert (tree_contains_struct[FUNCTION_DECL][TS_DECL_NON_COMMON]);
590 gcc_assert (tree_contains_struct[TYPE_DECL][TS_DECL_NON_COMMON]);
591 gcc_assert (tree_contains_struct[CONST_DECL][TS_DECL_COMMON]);
592 gcc_assert (tree_contains_struct[VAR_DECL][TS_DECL_COMMON]);
593 gcc_assert (tree_contains_struct[PARM_DECL][TS_DECL_COMMON]);
594 gcc_assert (tree_contains_struct[RESULT_DECL][TS_DECL_COMMON]);
595 gcc_assert (tree_contains_struct[FUNCTION_DECL][TS_DECL_COMMON]);
596 gcc_assert (tree_contains_struct[TYPE_DECL][TS_DECL_COMMON]);
597 gcc_assert (tree_contains_struct[TRANSLATION_UNIT_DECL][TS_DECL_COMMON]);
598 gcc_assert (tree_contains_struct[LABEL_DECL][TS_DECL_COMMON]);
599 gcc_assert (tree_contains_struct[FIELD_DECL][TS_DECL_COMMON]);
600 gcc_assert (tree_contains_struct[VAR_DECL][TS_DECL_WRTL]);
601 gcc_assert (tree_contains_struct[PARM_DECL][TS_DECL_WRTL]);
602 gcc_assert (tree_contains_struct[RESULT_DECL][TS_DECL_WRTL]);
603 gcc_assert (tree_contains_struct[FUNCTION_DECL][TS_DECL_WRTL]);
604 gcc_assert (tree_contains_struct[LABEL_DECL][TS_DECL_WRTL]);
605 gcc_assert (tree_contains_struct[CONST_DECL][TS_DECL_MINIMAL]);
606 gcc_assert (tree_contains_struct[VAR_DECL][TS_DECL_MINIMAL]);
607 gcc_assert (tree_contains_struct[PARM_DECL][TS_DECL_MINIMAL]);
608 gcc_assert (tree_contains_struct[RESULT_DECL][TS_DECL_MINIMAL]);
609 gcc_assert (tree_contains_struct[FUNCTION_DECL][TS_DECL_MINIMAL]);
610 gcc_assert (tree_contains_struct[TYPE_DECL][TS_DECL_MINIMAL]);
611 gcc_assert (tree_contains_struct[TRANSLATION_UNIT_DECL][TS_DECL_MINIMAL]);
612 gcc_assert (tree_contains_struct[LABEL_DECL][TS_DECL_MINIMAL]);
613 gcc_assert (tree_contains_struct[FIELD_DECL][TS_DECL_MINIMAL]);
614 gcc_assert (tree_contains_struct[VAR_DECL][TS_DECL_WITH_VIS]);
615 gcc_assert (tree_contains_struct[FUNCTION_DECL][TS_DECL_WITH_VIS]);
616 gcc_assert (tree_contains_struct[TYPE_DECL][TS_DECL_WITH_VIS]);
617 gcc_assert (tree_contains_struct[VAR_DECL][TS_VAR_DECL]);
618 gcc_assert (tree_contains_struct[FIELD_DECL][TS_FIELD_DECL]);
619 gcc_assert (tree_contains_struct[PARM_DECL][TS_PARM_DECL]);
620 gcc_assert (tree_contains_struct[LABEL_DECL][TS_LABEL_DECL]);
621 gcc_assert (tree_contains_struct[RESULT_DECL][TS_RESULT_DECL]);
622 gcc_assert (tree_contains_struct[CONST_DECL][TS_CONST_DECL]);
623 gcc_assert (tree_contains_struct[TYPE_DECL][TS_TYPE_DECL]);
624 gcc_assert (tree_contains_struct[FUNCTION_DECL][TS_FUNCTION_DECL]);
625 gcc_assert (tree_contains_struct[IMPORTED_DECL][TS_DECL_MINIMAL]);
626 gcc_assert (tree_contains_struct[IMPORTED_DECL][TS_DECL_COMMON]);
627 gcc_assert (tree_contains_struct[NAMELIST_DECL][TS_DECL_MINIMAL]);
628 gcc_assert (tree_contains_struct[NAMELIST_DECL][TS_DECL_COMMON]);
629 }
630
631
632 /* Init tree.c. */
633
634 void
635 init_ttree (void)
636 {
637 /* Initialize the hash table of types. */
638 type_hash_table
639 = hash_table<type_cache_hasher>::create_ggc (TYPE_HASH_INITIAL_SIZE);
640
641 debug_expr_for_decl
642 = hash_table<tree_decl_map_cache_hasher>::create_ggc (512);
643
644 value_expr_for_decl
645 = hash_table<tree_decl_map_cache_hasher>::create_ggc (512);
646
647 int_cst_hash_table = hash_table<int_cst_hasher>::create_ggc (1024);
648
649 int_cst_node = make_int_cst (1, 1);
650
651 cl_option_hash_table = hash_table<cl_option_hasher>::create_ggc (64);
652
653 cl_optimization_node = make_node (OPTIMIZATION_NODE);
654 cl_target_option_node = make_node (TARGET_OPTION_NODE);
655
656 /* Initialize the tree_contains_struct array. */
657 initialize_tree_contains_struct ();
658 lang_hooks.init_ts ();
659 }
660
661 \f
662 /* The name of the object as the assembler will see it (but before any
663 translations made by ASM_OUTPUT_LABELREF). Often this is the same
664 as DECL_NAME. It is an IDENTIFIER_NODE. */
665 tree
666 decl_assembler_name (tree decl)
667 {
668 if (!DECL_ASSEMBLER_NAME_SET_P (decl))
669 lang_hooks.set_decl_assembler_name (decl);
670 return DECL_WITH_VIS_CHECK (decl)->decl_with_vis.assembler_name;
671 }
672
673 /* When the target supports COMDAT groups, this indicates which group the
674 DECL is associated with. This can be either an IDENTIFIER_NODE or a
675 decl, in which case its DECL_ASSEMBLER_NAME identifies the group. */
676 tree
677 decl_comdat_group (const_tree node)
678 {
679 struct symtab_node *snode = symtab_node::get (node);
680 if (!snode)
681 return NULL;
682 return snode->get_comdat_group ();
683 }
684
685 /* Likewise, but make sure it's been reduced to an IDENTIFIER_NODE. */
686 tree
687 decl_comdat_group_id (const_tree node)
688 {
689 struct symtab_node *snode = symtab_node::get (node);
690 if (!snode)
691 return NULL;
692 return snode->get_comdat_group_id ();
693 }
694
695 /* When the target supports named section, return its name as IDENTIFIER_NODE
696 or NULL if it is in no section. */
697 const char *
698 decl_section_name (const_tree node)
699 {
700 struct symtab_node *snode = symtab_node::get (node);
701 if (!snode)
702 return NULL;
703 return snode->get_section ();
704 }
705
706 /* Set section name of NODE to VALUE (that is expected to be
707 identifier node) */
708 void
709 set_decl_section_name (tree node, const char *value)
710 {
711 struct symtab_node *snode;
712
713 if (value == NULL)
714 {
715 snode = symtab_node::get (node);
716 if (!snode)
717 return;
718 }
719 else if (VAR_P (node))
720 snode = varpool_node::get_create (node);
721 else
722 snode = cgraph_node::get_create (node);
723 snode->set_section (value);
724 }
725
726 /* Return TLS model of a variable NODE. */
727 enum tls_model
728 decl_tls_model (const_tree node)
729 {
730 struct varpool_node *snode = varpool_node::get (node);
731 if (!snode)
732 return TLS_MODEL_NONE;
733 return snode->tls_model;
734 }
735
736 /* Set TLS model of variable NODE to MODEL. */
737 void
738 set_decl_tls_model (tree node, enum tls_model model)
739 {
740 struct varpool_node *vnode;
741
742 if (model == TLS_MODEL_NONE)
743 {
744 vnode = varpool_node::get (node);
745 if (!vnode)
746 return;
747 }
748 else
749 vnode = varpool_node::get_create (node);
750 vnode->tls_model = model;
751 }
752
753 /* Compute the number of bytes occupied by a tree with code CODE.
754 This function cannot be used for nodes that have variable sizes,
755 including TREE_VEC, INTEGER_CST, STRING_CST, and CALL_EXPR. */
756 size_t
757 tree_code_size (enum tree_code code)
758 {
759 switch (TREE_CODE_CLASS (code))
760 {
761 case tcc_declaration: /* A decl node */
762 {
763 switch (code)
764 {
765 case FIELD_DECL:
766 return sizeof (struct tree_field_decl);
767 case PARM_DECL:
768 return sizeof (struct tree_parm_decl);
769 case VAR_DECL:
770 return sizeof (struct tree_var_decl);
771 case LABEL_DECL:
772 return sizeof (struct tree_label_decl);
773 case RESULT_DECL:
774 return sizeof (struct tree_result_decl);
775 case CONST_DECL:
776 return sizeof (struct tree_const_decl);
777 case TYPE_DECL:
778 return sizeof (struct tree_type_decl);
779 case FUNCTION_DECL:
780 return sizeof (struct tree_function_decl);
781 case DEBUG_EXPR_DECL:
782 return sizeof (struct tree_decl_with_rtl);
783 case TRANSLATION_UNIT_DECL:
784 return sizeof (struct tree_translation_unit_decl);
785 case NAMESPACE_DECL:
786 case IMPORTED_DECL:
787 case NAMELIST_DECL:
788 return sizeof (struct tree_decl_non_common);
789 default:
790 return lang_hooks.tree_size (code);
791 }
792 }
793
794 case tcc_type: /* a type node */
795 return sizeof (struct tree_type_non_common);
796
797 case tcc_reference: /* a reference */
798 case tcc_expression: /* an expression */
799 case tcc_statement: /* an expression with side effects */
800 case tcc_comparison: /* a comparison expression */
801 case tcc_unary: /* a unary arithmetic expression */
802 case tcc_binary: /* a binary arithmetic expression */
803 return (sizeof (struct tree_exp)
804 + (TREE_CODE_LENGTH (code) - 1) * sizeof (tree));
805
806 case tcc_constant: /* a constant */
807 switch (code)
808 {
809 case VOID_CST: return sizeof (struct tree_typed);
810 case INTEGER_CST: gcc_unreachable ();
811 case REAL_CST: return sizeof (struct tree_real_cst);
812 case FIXED_CST: return sizeof (struct tree_fixed_cst);
813 case COMPLEX_CST: return sizeof (struct tree_complex);
814 case VECTOR_CST: return sizeof (struct tree_vector);
815 case STRING_CST: gcc_unreachable ();
816 default:
817 return lang_hooks.tree_size (code);
818 }
819
820 case tcc_exceptional: /* something random, like an identifier. */
821 switch (code)
822 {
823 case IDENTIFIER_NODE: return lang_hooks.identifier_size;
824 case TREE_LIST: return sizeof (struct tree_list);
825
826 case ERROR_MARK:
827 case PLACEHOLDER_EXPR: return sizeof (struct tree_common);
828
829 case TREE_VEC:
830 case OMP_CLAUSE: gcc_unreachable ();
831
832 case SSA_NAME: return sizeof (struct tree_ssa_name);
833
834 case STATEMENT_LIST: return sizeof (struct tree_statement_list);
835 case BLOCK: return sizeof (struct tree_block);
836 case CONSTRUCTOR: return sizeof (struct tree_constructor);
837 case OPTIMIZATION_NODE: return sizeof (struct tree_optimization_option);
838 case TARGET_OPTION_NODE: return sizeof (struct tree_target_option);
839
840 default:
841 return lang_hooks.tree_size (code);
842 }
843
844 default:
845 gcc_unreachable ();
846 }
847 }
848
849 /* Compute the number of bytes occupied by NODE. This routine only
850 looks at TREE_CODE, except for those nodes that have variable sizes. */
851 size_t
852 tree_size (const_tree node)
853 {
854 const enum tree_code code = TREE_CODE (node);
855 switch (code)
856 {
857 case INTEGER_CST:
858 return (sizeof (struct tree_int_cst)
859 + (TREE_INT_CST_EXT_NUNITS (node) - 1) * sizeof (HOST_WIDE_INT));
860
861 case TREE_BINFO:
862 return (offsetof (struct tree_binfo, base_binfos)
863 + vec<tree, va_gc>
864 ::embedded_size (BINFO_N_BASE_BINFOS (node)));
865
866 case TREE_VEC:
867 return (sizeof (struct tree_vec)
868 + (TREE_VEC_LENGTH (node) - 1) * sizeof (tree));
869
870 case VECTOR_CST:
871 return (sizeof (struct tree_vector)
872 + (TYPE_VECTOR_SUBPARTS (TREE_TYPE (node)) - 1) * sizeof (tree));
873
874 case STRING_CST:
875 return TREE_STRING_LENGTH (node) + offsetof (struct tree_string, str) + 1;
876
877 case OMP_CLAUSE:
878 return (sizeof (struct tree_omp_clause)
879 + (omp_clause_num_ops[OMP_CLAUSE_CODE (node)] - 1)
880 * sizeof (tree));
881
882 default:
883 if (TREE_CODE_CLASS (code) == tcc_vl_exp)
884 return (sizeof (struct tree_exp)
885 + (VL_EXP_OPERAND_LENGTH (node) - 1) * sizeof (tree));
886 else
887 return tree_code_size (code);
888 }
889 }
890
891 /* Record interesting allocation statistics for a tree node with CODE
892 and LENGTH. */
893
894 static void
895 record_node_allocation_statistics (enum tree_code code ATTRIBUTE_UNUSED,
896 size_t length ATTRIBUTE_UNUSED)
897 {
898 enum tree_code_class type = TREE_CODE_CLASS (code);
899 tree_node_kind kind;
900
901 if (!GATHER_STATISTICS)
902 return;
903
904 switch (type)
905 {
906 case tcc_declaration: /* A decl node */
907 kind = d_kind;
908 break;
909
910 case tcc_type: /* a type node */
911 kind = t_kind;
912 break;
913
914 case tcc_statement: /* an expression with side effects */
915 kind = s_kind;
916 break;
917
918 case tcc_reference: /* a reference */
919 kind = r_kind;
920 break;
921
922 case tcc_expression: /* an expression */
923 case tcc_comparison: /* a comparison expression */
924 case tcc_unary: /* a unary arithmetic expression */
925 case tcc_binary: /* a binary arithmetic expression */
926 kind = e_kind;
927 break;
928
929 case tcc_constant: /* a constant */
930 kind = c_kind;
931 break;
932
933 case tcc_exceptional: /* something random, like an identifier. */
934 switch (code)
935 {
936 case IDENTIFIER_NODE:
937 kind = id_kind;
938 break;
939
940 case TREE_VEC:
941 kind = vec_kind;
942 break;
943
944 case TREE_BINFO:
945 kind = binfo_kind;
946 break;
947
948 case SSA_NAME:
949 kind = ssa_name_kind;
950 break;
951
952 case BLOCK:
953 kind = b_kind;
954 break;
955
956 case CONSTRUCTOR:
957 kind = constr_kind;
958 break;
959
960 case OMP_CLAUSE:
961 kind = omp_clause_kind;
962 break;
963
964 default:
965 kind = x_kind;
966 break;
967 }
968 break;
969
970 case tcc_vl_exp:
971 kind = e_kind;
972 break;
973
974 default:
975 gcc_unreachable ();
976 }
977
978 tree_code_counts[(int) code]++;
979 tree_node_counts[(int) kind]++;
980 tree_node_sizes[(int) kind] += length;
981 }
982
983 /* Allocate and return a new UID from the DECL_UID namespace. */
984
985 int
986 allocate_decl_uid (void)
987 {
988 return next_decl_uid++;
989 }
990
991 /* Return a newly allocated node of code CODE. For decl and type
992 nodes, some other fields are initialized. The rest of the node is
993 initialized to zero. This function cannot be used for TREE_VEC,
994 INTEGER_CST or OMP_CLAUSE nodes, which is enforced by asserts in
995 tree_code_size.
996
997 Achoo! I got a code in the node. */
998
999 tree
1000 make_node_stat (enum tree_code code MEM_STAT_DECL)
1001 {
1002 tree t;
1003 enum tree_code_class type = TREE_CODE_CLASS (code);
1004 size_t length = tree_code_size (code);
1005
1006 record_node_allocation_statistics (code, length);
1007
1008 t = ggc_alloc_cleared_tree_node_stat (length PASS_MEM_STAT);
1009 TREE_SET_CODE (t, code);
1010
1011 switch (type)
1012 {
1013 case tcc_statement:
1014 TREE_SIDE_EFFECTS (t) = 1;
1015 break;
1016
1017 case tcc_declaration:
1018 if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
1019 {
1020 if (code == FUNCTION_DECL)
1021 {
1022 SET_DECL_ALIGN (t, FUNCTION_ALIGNMENT (FUNCTION_BOUNDARY));
1023 SET_DECL_MODE (t, FUNCTION_MODE);
1024 }
1025 else
1026 SET_DECL_ALIGN (t, 1);
1027 }
1028 DECL_SOURCE_LOCATION (t) = input_location;
1029 if (TREE_CODE (t) == DEBUG_EXPR_DECL)
1030 DECL_UID (t) = --next_debug_decl_uid;
1031 else
1032 {
1033 DECL_UID (t) = allocate_decl_uid ();
1034 SET_DECL_PT_UID (t, -1);
1035 }
1036 if (TREE_CODE (t) == LABEL_DECL)
1037 LABEL_DECL_UID (t) = -1;
1038
1039 break;
1040
1041 case tcc_type:
1042 TYPE_UID (t) = next_type_uid++;
1043 SET_TYPE_ALIGN (t, BITS_PER_UNIT);
1044 TYPE_USER_ALIGN (t) = 0;
1045 TYPE_MAIN_VARIANT (t) = t;
1046 TYPE_CANONICAL (t) = t;
1047
1048 /* Default to no attributes for type, but let target change that. */
1049 TYPE_ATTRIBUTES (t) = NULL_TREE;
1050 targetm.set_default_type_attributes (t);
1051
1052 /* We have not yet computed the alias set for this type. */
1053 TYPE_ALIAS_SET (t) = -1;
1054 break;
1055
1056 case tcc_constant:
1057 TREE_CONSTANT (t) = 1;
1058 break;
1059
1060 case tcc_expression:
1061 switch (code)
1062 {
1063 case INIT_EXPR:
1064 case MODIFY_EXPR:
1065 case VA_ARG_EXPR:
1066 case PREDECREMENT_EXPR:
1067 case PREINCREMENT_EXPR:
1068 case POSTDECREMENT_EXPR:
1069 case POSTINCREMENT_EXPR:
1070 /* All of these have side-effects, no matter what their
1071 operands are. */
1072 TREE_SIDE_EFFECTS (t) = 1;
1073 break;
1074
1075 default:
1076 break;
1077 }
1078 break;
1079
1080 case tcc_exceptional:
1081 switch (code)
1082 {
1083 case TARGET_OPTION_NODE:
1084 TREE_TARGET_OPTION(t)
1085 = ggc_cleared_alloc<struct cl_target_option> ();
1086 break;
1087
1088 case OPTIMIZATION_NODE:
1089 TREE_OPTIMIZATION (t)
1090 = ggc_cleared_alloc<struct cl_optimization> ();
1091 break;
1092
1093 default:
1094 break;
1095 }
1096 break;
1097
1098 default:
1099 /* Other classes need no special treatment. */
1100 break;
1101 }
1102
1103 return t;
1104 }
1105
1106 /* Free tree node. */
1107
1108 void
1109 free_node (tree node)
1110 {
1111 enum tree_code code = TREE_CODE (node);
1112 if (GATHER_STATISTICS)
1113 {
1114 tree_code_counts[(int) TREE_CODE (node)]--;
1115 tree_node_counts[(int) t_kind]--;
1116 tree_node_sizes[(int) t_kind] -= tree_size (node);
1117 }
1118 if (CODE_CONTAINS_STRUCT (code, TS_CONSTRUCTOR))
1119 vec_free (CONSTRUCTOR_ELTS (node));
1120 else if (code == BLOCK)
1121 vec_free (BLOCK_NONLOCALIZED_VARS (node));
1122 else if (code == TREE_BINFO)
1123 vec_free (BINFO_BASE_ACCESSES (node));
1124 ggc_free (node);
1125 }
1126 \f
1127 /* Return a new node with the same contents as NODE except that its
1128 TREE_CHAIN, if it has one, is zero and it has a fresh uid. */
1129
1130 tree
1131 copy_node_stat (tree node MEM_STAT_DECL)
1132 {
1133 tree t;
1134 enum tree_code code = TREE_CODE (node);
1135 size_t length;
1136
1137 gcc_assert (code != STATEMENT_LIST);
1138
1139 length = tree_size (node);
1140 record_node_allocation_statistics (code, length);
1141 t = ggc_alloc_tree_node_stat (length PASS_MEM_STAT);
1142 memcpy (t, node, length);
1143
1144 if (CODE_CONTAINS_STRUCT (code, TS_COMMON))
1145 TREE_CHAIN (t) = 0;
1146 TREE_ASM_WRITTEN (t) = 0;
1147 TREE_VISITED (t) = 0;
1148
1149 if (TREE_CODE_CLASS (code) == tcc_declaration)
1150 {
1151 if (code == DEBUG_EXPR_DECL)
1152 DECL_UID (t) = --next_debug_decl_uid;
1153 else
1154 {
1155 DECL_UID (t) = allocate_decl_uid ();
1156 if (DECL_PT_UID_SET_P (node))
1157 SET_DECL_PT_UID (t, DECL_PT_UID (node));
1158 }
1159 if ((TREE_CODE (node) == PARM_DECL || VAR_P (node))
1160 && DECL_HAS_VALUE_EXPR_P (node))
1161 {
1162 SET_DECL_VALUE_EXPR (t, DECL_VALUE_EXPR (node));
1163 DECL_HAS_VALUE_EXPR_P (t) = 1;
1164 }
1165 /* DECL_DEBUG_EXPR is copied explicitely by callers. */
1166 if (VAR_P (node))
1167 {
1168 DECL_HAS_DEBUG_EXPR_P (t) = 0;
1169 t->decl_with_vis.symtab_node = NULL;
1170 }
1171 if (VAR_P (node) && DECL_HAS_INIT_PRIORITY_P (node))
1172 {
1173 SET_DECL_INIT_PRIORITY (t, DECL_INIT_PRIORITY (node));
1174 DECL_HAS_INIT_PRIORITY_P (t) = 1;
1175 }
1176 if (TREE_CODE (node) == FUNCTION_DECL)
1177 {
1178 DECL_STRUCT_FUNCTION (t) = NULL;
1179 t->decl_with_vis.symtab_node = NULL;
1180 }
1181 }
1182 else if (TREE_CODE_CLASS (code) == tcc_type)
1183 {
1184 TYPE_UID (t) = next_type_uid++;
1185 /* The following is so that the debug code for
1186 the copy is different from the original type.
1187 The two statements usually duplicate each other
1188 (because they clear fields of the same union),
1189 but the optimizer should catch that. */
1190 TYPE_SYMTAB_POINTER (t) = 0;
1191 TYPE_SYMTAB_ADDRESS (t) = 0;
1192
1193 /* Do not copy the values cache. */
1194 if (TYPE_CACHED_VALUES_P (t))
1195 {
1196 TYPE_CACHED_VALUES_P (t) = 0;
1197 TYPE_CACHED_VALUES (t) = NULL_TREE;
1198 }
1199 }
1200 else if (code == TARGET_OPTION_NODE)
1201 {
1202 TREE_TARGET_OPTION (t) = ggc_alloc<struct cl_target_option>();
1203 memcpy (TREE_TARGET_OPTION (t), TREE_TARGET_OPTION (node),
1204 sizeof (struct cl_target_option));
1205 }
1206 else if (code == OPTIMIZATION_NODE)
1207 {
1208 TREE_OPTIMIZATION (t) = ggc_alloc<struct cl_optimization>();
1209 memcpy (TREE_OPTIMIZATION (t), TREE_OPTIMIZATION (node),
1210 sizeof (struct cl_optimization));
1211 }
1212
1213 return t;
1214 }
1215
1216 /* Return a copy of a chain of nodes, chained through the TREE_CHAIN field.
1217 For example, this can copy a list made of TREE_LIST nodes. */
1218
1219 tree
1220 copy_list (tree list)
1221 {
1222 tree head;
1223 tree prev, next;
1224
1225 if (list == 0)
1226 return 0;
1227
1228 head = prev = copy_node (list);
1229 next = TREE_CHAIN (list);
1230 while (next)
1231 {
1232 TREE_CHAIN (prev) = copy_node (next);
1233 prev = TREE_CHAIN (prev);
1234 next = TREE_CHAIN (next);
1235 }
1236 return head;
1237 }
1238
1239 \f
1240 /* Return the value that TREE_INT_CST_EXT_NUNITS should have for an
1241 INTEGER_CST with value CST and type TYPE. */
1242
1243 static unsigned int
1244 get_int_cst_ext_nunits (tree type, const wide_int &cst)
1245 {
1246 gcc_checking_assert (cst.get_precision () == TYPE_PRECISION (type));
1247 /* We need extra HWIs if CST is an unsigned integer with its
1248 upper bit set. */
1249 if (TYPE_UNSIGNED (type) && wi::neg_p (cst))
1250 return cst.get_precision () / HOST_BITS_PER_WIDE_INT + 1;
1251 return cst.get_len ();
1252 }
1253
1254 /* Return a new INTEGER_CST with value CST and type TYPE. */
1255
1256 static tree
1257 build_new_int_cst (tree type, const wide_int &cst)
1258 {
1259 unsigned int len = cst.get_len ();
1260 unsigned int ext_len = get_int_cst_ext_nunits (type, cst);
1261 tree nt = make_int_cst (len, ext_len);
1262
1263 if (len < ext_len)
1264 {
1265 --ext_len;
1266 TREE_INT_CST_ELT (nt, ext_len)
1267 = zext_hwi (-1, cst.get_precision () % HOST_BITS_PER_WIDE_INT);
1268 for (unsigned int i = len; i < ext_len; ++i)
1269 TREE_INT_CST_ELT (nt, i) = -1;
1270 }
1271 else if (TYPE_UNSIGNED (type)
1272 && cst.get_precision () < len * HOST_BITS_PER_WIDE_INT)
1273 {
1274 len--;
1275 TREE_INT_CST_ELT (nt, len)
1276 = zext_hwi (cst.elt (len),
1277 cst.get_precision () % HOST_BITS_PER_WIDE_INT);
1278 }
1279
1280 for (unsigned int i = 0; i < len; i++)
1281 TREE_INT_CST_ELT (nt, i) = cst.elt (i);
1282 TREE_TYPE (nt) = type;
1283 return nt;
1284 }
1285
1286 /* Create an INT_CST node with a LOW value sign extended to TYPE. */
1287
1288 tree
1289 build_int_cst (tree type, HOST_WIDE_INT low)
1290 {
1291 /* Support legacy code. */
1292 if (!type)
1293 type = integer_type_node;
1294
1295 return wide_int_to_tree (type, wi::shwi (low, TYPE_PRECISION (type)));
1296 }
1297
1298 tree
1299 build_int_cstu (tree type, unsigned HOST_WIDE_INT cst)
1300 {
1301 return wide_int_to_tree (type, wi::uhwi (cst, TYPE_PRECISION (type)));
1302 }
1303
1304 /* Create an INT_CST node with a LOW value sign extended to TYPE. */
1305
1306 tree
1307 build_int_cst_type (tree type, HOST_WIDE_INT low)
1308 {
1309 gcc_assert (type);
1310 return wide_int_to_tree (type, wi::shwi (low, TYPE_PRECISION (type)));
1311 }
1312
1313 /* Constructs tree in type TYPE from with value given by CST. Signedness
1314 of CST is assumed to be the same as the signedness of TYPE. */
1315
1316 tree
1317 double_int_to_tree (tree type, double_int cst)
1318 {
1319 return wide_int_to_tree (type, widest_int::from (cst, TYPE_SIGN (type)));
1320 }
1321
1322 /* We force the wide_int CST to the range of the type TYPE by sign or
1323 zero extending it. OVERFLOWABLE indicates if we are interested in
1324 overflow of the value, when >0 we are only interested in signed
1325 overflow, for <0 we are interested in any overflow. OVERFLOWED
1326 indicates whether overflow has already occurred. CONST_OVERFLOWED
1327 indicates whether constant overflow has already occurred. We force
1328 T's value to be within range of T's type (by setting to 0 or 1 all
1329 the bits outside the type's range). We set TREE_OVERFLOWED if,
1330 OVERFLOWED is nonzero,
1331 or OVERFLOWABLE is >0 and signed overflow occurs
1332 or OVERFLOWABLE is <0 and any overflow occurs
1333 We return a new tree node for the extended wide_int. The node
1334 is shared if no overflow flags are set. */
1335
1336
1337 tree
1338 force_fit_type (tree type, const wide_int_ref &cst,
1339 int overflowable, bool overflowed)
1340 {
1341 signop sign = TYPE_SIGN (type);
1342
1343 /* If we need to set overflow flags, return a new unshared node. */
1344 if (overflowed || !wi::fits_to_tree_p (cst, type))
1345 {
1346 if (overflowed
1347 || overflowable < 0
1348 || (overflowable > 0 && sign == SIGNED))
1349 {
1350 wide_int tmp = wide_int::from (cst, TYPE_PRECISION (type), sign);
1351 tree t = build_new_int_cst (type, tmp);
1352 TREE_OVERFLOW (t) = 1;
1353 return t;
1354 }
1355 }
1356
1357 /* Else build a shared node. */
1358 return wide_int_to_tree (type, cst);
1359 }
1360
1361 /* These are the hash table functions for the hash table of INTEGER_CST
1362 nodes of a sizetype. */
1363
1364 /* Return the hash code X, an INTEGER_CST. */
1365
1366 hashval_t
1367 int_cst_hasher::hash (tree x)
1368 {
1369 const_tree const t = x;
1370 hashval_t code = TYPE_UID (TREE_TYPE (t));
1371 int i;
1372
1373 for (i = 0; i < TREE_INT_CST_NUNITS (t); i++)
1374 code = iterative_hash_host_wide_int (TREE_INT_CST_ELT(t, i), code);
1375
1376 return code;
1377 }
1378
1379 /* Return nonzero if the value represented by *X (an INTEGER_CST tree node)
1380 is the same as that given by *Y, which is the same. */
1381
1382 bool
1383 int_cst_hasher::equal (tree x, tree y)
1384 {
1385 const_tree const xt = x;
1386 const_tree const yt = y;
1387
1388 if (TREE_TYPE (xt) != TREE_TYPE (yt)
1389 || TREE_INT_CST_NUNITS (xt) != TREE_INT_CST_NUNITS (yt)
1390 || TREE_INT_CST_EXT_NUNITS (xt) != TREE_INT_CST_EXT_NUNITS (yt))
1391 return false;
1392
1393 for (int i = 0; i < TREE_INT_CST_NUNITS (xt); i++)
1394 if (TREE_INT_CST_ELT (xt, i) != TREE_INT_CST_ELT (yt, i))
1395 return false;
1396
1397 return true;
1398 }
1399
1400 /* Create an INT_CST node of TYPE and value CST.
1401 The returned node is always shared. For small integers we use a
1402 per-type vector cache, for larger ones we use a single hash table.
1403 The value is extended from its precision according to the sign of
1404 the type to be a multiple of HOST_BITS_PER_WIDE_INT. This defines
1405 the upper bits and ensures that hashing and value equality based
1406 upon the underlying HOST_WIDE_INTs works without masking. */
1407
1408 tree
1409 wide_int_to_tree (tree type, const wide_int_ref &pcst)
1410 {
1411 tree t;
1412 int ix = -1;
1413 int limit = 0;
1414
1415 gcc_assert (type);
1416 unsigned int prec = TYPE_PRECISION (type);
1417 signop sgn = TYPE_SIGN (type);
1418
1419 /* Verify that everything is canonical. */
1420 int l = pcst.get_len ();
1421 if (l > 1)
1422 {
1423 if (pcst.elt (l - 1) == 0)
1424 gcc_checking_assert (pcst.elt (l - 2) < 0);
1425 if (pcst.elt (l - 1) == HOST_WIDE_INT_M1)
1426 gcc_checking_assert (pcst.elt (l - 2) >= 0);
1427 }
1428
1429 wide_int cst = wide_int::from (pcst, prec, sgn);
1430 unsigned int ext_len = get_int_cst_ext_nunits (type, cst);
1431
1432 if (ext_len == 1)
1433 {
1434 /* We just need to store a single HOST_WIDE_INT. */
1435 HOST_WIDE_INT hwi;
1436 if (TYPE_UNSIGNED (type))
1437 hwi = cst.to_uhwi ();
1438 else
1439 hwi = cst.to_shwi ();
1440
1441 switch (TREE_CODE (type))
1442 {
1443 case NULLPTR_TYPE:
1444 gcc_assert (hwi == 0);
1445 /* Fallthru. */
1446
1447 case POINTER_TYPE:
1448 case REFERENCE_TYPE:
1449 case POINTER_BOUNDS_TYPE:
1450 /* Cache NULL pointer and zero bounds. */
1451 if (hwi == 0)
1452 {
1453 limit = 1;
1454 ix = 0;
1455 }
1456 break;
1457
1458 case BOOLEAN_TYPE:
1459 /* Cache false or true. */
1460 limit = 2;
1461 if (IN_RANGE (hwi, 0, 1))
1462 ix = hwi;
1463 break;
1464
1465 case INTEGER_TYPE:
1466 case OFFSET_TYPE:
1467 if (TYPE_SIGN (type) == UNSIGNED)
1468 {
1469 /* Cache [0, N). */
1470 limit = INTEGER_SHARE_LIMIT;
1471 if (IN_RANGE (hwi, 0, INTEGER_SHARE_LIMIT - 1))
1472 ix = hwi;
1473 }
1474 else
1475 {
1476 /* Cache [-1, N). */
1477 limit = INTEGER_SHARE_LIMIT + 1;
1478 if (IN_RANGE (hwi, -1, INTEGER_SHARE_LIMIT - 1))
1479 ix = hwi + 1;
1480 }
1481 break;
1482
1483 case ENUMERAL_TYPE:
1484 break;
1485
1486 default:
1487 gcc_unreachable ();
1488 }
1489
1490 if (ix >= 0)
1491 {
1492 /* Look for it in the type's vector of small shared ints. */
1493 if (!TYPE_CACHED_VALUES_P (type))
1494 {
1495 TYPE_CACHED_VALUES_P (type) = 1;
1496 TYPE_CACHED_VALUES (type) = make_tree_vec (limit);
1497 }
1498
1499 t = TREE_VEC_ELT (TYPE_CACHED_VALUES (type), ix);
1500 if (t)
1501 /* Make sure no one is clobbering the shared constant. */
1502 gcc_checking_assert (TREE_TYPE (t) == type
1503 && TREE_INT_CST_NUNITS (t) == 1
1504 && TREE_INT_CST_OFFSET_NUNITS (t) == 1
1505 && TREE_INT_CST_EXT_NUNITS (t) == 1
1506 && TREE_INT_CST_ELT (t, 0) == hwi);
1507 else
1508 {
1509 /* Create a new shared int. */
1510 t = build_new_int_cst (type, cst);
1511 TREE_VEC_ELT (TYPE_CACHED_VALUES (type), ix) = t;
1512 }
1513 }
1514 else
1515 {
1516 /* Use the cache of larger shared ints, using int_cst_node as
1517 a temporary. */
1518
1519 TREE_INT_CST_ELT (int_cst_node, 0) = hwi;
1520 TREE_TYPE (int_cst_node) = type;
1521
1522 tree *slot = int_cst_hash_table->find_slot (int_cst_node, INSERT);
1523 t = *slot;
1524 if (!t)
1525 {
1526 /* Insert this one into the hash table. */
1527 t = int_cst_node;
1528 *slot = t;
1529 /* Make a new node for next time round. */
1530 int_cst_node = make_int_cst (1, 1);
1531 }
1532 }
1533 }
1534 else
1535 {
1536 /* The value either hashes properly or we drop it on the floor
1537 for the gc to take care of. There will not be enough of them
1538 to worry about. */
1539
1540 tree nt = build_new_int_cst (type, cst);
1541 tree *slot = int_cst_hash_table->find_slot (nt, INSERT);
1542 t = *slot;
1543 if (!t)
1544 {
1545 /* Insert this one into the hash table. */
1546 t = nt;
1547 *slot = t;
1548 }
1549 }
1550
1551 return t;
1552 }
1553
1554 void
1555 cache_integer_cst (tree t)
1556 {
1557 tree type = TREE_TYPE (t);
1558 int ix = -1;
1559 int limit = 0;
1560 int prec = TYPE_PRECISION (type);
1561
1562 gcc_assert (!TREE_OVERFLOW (t));
1563
1564 switch (TREE_CODE (type))
1565 {
1566 case NULLPTR_TYPE:
1567 gcc_assert (integer_zerop (t));
1568 /* Fallthru. */
1569
1570 case POINTER_TYPE:
1571 case REFERENCE_TYPE:
1572 /* Cache NULL pointer. */
1573 if (integer_zerop (t))
1574 {
1575 limit = 1;
1576 ix = 0;
1577 }
1578 break;
1579
1580 case BOOLEAN_TYPE:
1581 /* Cache false or true. */
1582 limit = 2;
1583 if (wi::ltu_p (t, 2))
1584 ix = TREE_INT_CST_ELT (t, 0);
1585 break;
1586
1587 case INTEGER_TYPE:
1588 case OFFSET_TYPE:
1589 if (TYPE_UNSIGNED (type))
1590 {
1591 /* Cache 0..N */
1592 limit = INTEGER_SHARE_LIMIT;
1593
1594 /* This is a little hokie, but if the prec is smaller than
1595 what is necessary to hold INTEGER_SHARE_LIMIT, then the
1596 obvious test will not get the correct answer. */
1597 if (prec < HOST_BITS_PER_WIDE_INT)
1598 {
1599 if (tree_to_uhwi (t) < (unsigned HOST_WIDE_INT) INTEGER_SHARE_LIMIT)
1600 ix = tree_to_uhwi (t);
1601 }
1602 else if (wi::ltu_p (t, INTEGER_SHARE_LIMIT))
1603 ix = tree_to_uhwi (t);
1604 }
1605 else
1606 {
1607 /* Cache -1..N */
1608 limit = INTEGER_SHARE_LIMIT + 1;
1609
1610 if (integer_minus_onep (t))
1611 ix = 0;
1612 else if (!wi::neg_p (t))
1613 {
1614 if (prec < HOST_BITS_PER_WIDE_INT)
1615 {
1616 if (tree_to_shwi (t) < INTEGER_SHARE_LIMIT)
1617 ix = tree_to_shwi (t) + 1;
1618 }
1619 else if (wi::ltu_p (t, INTEGER_SHARE_LIMIT))
1620 ix = tree_to_shwi (t) + 1;
1621 }
1622 }
1623 break;
1624
1625 case ENUMERAL_TYPE:
1626 break;
1627
1628 default:
1629 gcc_unreachable ();
1630 }
1631
1632 if (ix >= 0)
1633 {
1634 /* Look for it in the type's vector of small shared ints. */
1635 if (!TYPE_CACHED_VALUES_P (type))
1636 {
1637 TYPE_CACHED_VALUES_P (type) = 1;
1638 TYPE_CACHED_VALUES (type) = make_tree_vec (limit);
1639 }
1640
1641 gcc_assert (TREE_VEC_ELT (TYPE_CACHED_VALUES (type), ix) == NULL_TREE);
1642 TREE_VEC_ELT (TYPE_CACHED_VALUES (type), ix) = t;
1643 }
1644 else
1645 {
1646 /* Use the cache of larger shared ints. */
1647 tree *slot = int_cst_hash_table->find_slot (t, INSERT);
1648 /* If there is already an entry for the number verify it's the
1649 same. */
1650 if (*slot)
1651 gcc_assert (wi::eq_p (tree (*slot), t));
1652 else
1653 /* Otherwise insert this one into the hash table. */
1654 *slot = t;
1655 }
1656 }
1657
1658
1659 /* Builds an integer constant in TYPE such that lowest BITS bits are ones
1660 and the rest are zeros. */
1661
1662 tree
1663 build_low_bits_mask (tree type, unsigned bits)
1664 {
1665 gcc_assert (bits <= TYPE_PRECISION (type));
1666
1667 return wide_int_to_tree (type, wi::mask (bits, false,
1668 TYPE_PRECISION (type)));
1669 }
1670
1671 /* Checks that X is integer constant that can be expressed in (unsigned)
1672 HOST_WIDE_INT without loss of precision. */
1673
1674 bool
1675 cst_and_fits_in_hwi (const_tree x)
1676 {
1677 return (TREE_CODE (x) == INTEGER_CST
1678 && (tree_fits_shwi_p (x) || tree_fits_uhwi_p (x)));
1679 }
1680
1681 /* Build a newly constructed VECTOR_CST node of length LEN. */
1682
1683 tree
1684 make_vector_stat (unsigned len MEM_STAT_DECL)
1685 {
1686 tree t;
1687 unsigned length = (len - 1) * sizeof (tree) + sizeof (struct tree_vector);
1688
1689 record_node_allocation_statistics (VECTOR_CST, length);
1690
1691 t = ggc_alloc_cleared_tree_node_stat (length PASS_MEM_STAT);
1692
1693 TREE_SET_CODE (t, VECTOR_CST);
1694 TREE_CONSTANT (t) = 1;
1695
1696 return t;
1697 }
1698
1699 /* Return a new VECTOR_CST node whose type is TYPE and whose values
1700 are in a list pointed to by VALS. */
1701
1702 tree
1703 build_vector_stat (tree type, tree *vals MEM_STAT_DECL)
1704 {
1705 int over = 0;
1706 unsigned cnt = 0;
1707 tree v = make_vector (TYPE_VECTOR_SUBPARTS (type));
1708 TREE_TYPE (v) = type;
1709
1710 /* Iterate through elements and check for overflow. */
1711 for (cnt = 0; cnt < TYPE_VECTOR_SUBPARTS (type); ++cnt)
1712 {
1713 tree value = vals[cnt];
1714
1715 VECTOR_CST_ELT (v, cnt) = value;
1716
1717 /* Don't crash if we get an address constant. */
1718 if (!CONSTANT_CLASS_P (value))
1719 continue;
1720
1721 over |= TREE_OVERFLOW (value);
1722 }
1723
1724 TREE_OVERFLOW (v) = over;
1725 return v;
1726 }
1727
1728 /* Return a new VECTOR_CST node whose type is TYPE and whose values
1729 are extracted from V, a vector of CONSTRUCTOR_ELT. */
1730
1731 tree
1732 build_vector_from_ctor (tree type, vec<constructor_elt, va_gc> *v)
1733 {
1734 tree *vec = XALLOCAVEC (tree, TYPE_VECTOR_SUBPARTS (type));
1735 unsigned HOST_WIDE_INT idx, pos = 0;
1736 tree value;
1737
1738 FOR_EACH_CONSTRUCTOR_VALUE (v, idx, value)
1739 {
1740 if (TREE_CODE (value) == VECTOR_CST)
1741 for (unsigned i = 0; i < VECTOR_CST_NELTS (value); ++i)
1742 vec[pos++] = VECTOR_CST_ELT (value, i);
1743 else
1744 vec[pos++] = value;
1745 }
1746 while (pos < TYPE_VECTOR_SUBPARTS (type))
1747 vec[pos++] = build_zero_cst (TREE_TYPE (type));
1748
1749 return build_vector (type, vec);
1750 }
1751
1752 /* Build a vector of type VECTYPE where all the elements are SCs. */
1753 tree
1754 build_vector_from_val (tree vectype, tree sc)
1755 {
1756 int i, nunits = TYPE_VECTOR_SUBPARTS (vectype);
1757
1758 if (sc == error_mark_node)
1759 return sc;
1760
1761 /* Verify that the vector type is suitable for SC. Note that there
1762 is some inconsistency in the type-system with respect to restrict
1763 qualifications of pointers. Vector types always have a main-variant
1764 element type and the qualification is applied to the vector-type.
1765 So TREE_TYPE (vector-type) does not return a properly qualified
1766 vector element-type. */
1767 gcc_checking_assert (types_compatible_p (TYPE_MAIN_VARIANT (TREE_TYPE (sc)),
1768 TREE_TYPE (vectype)));
1769
1770 if (CONSTANT_CLASS_P (sc))
1771 {
1772 tree *v = XALLOCAVEC (tree, nunits);
1773 for (i = 0; i < nunits; ++i)
1774 v[i] = sc;
1775 return build_vector (vectype, v);
1776 }
1777 else
1778 {
1779 vec<constructor_elt, va_gc> *v;
1780 vec_alloc (v, nunits);
1781 for (i = 0; i < nunits; ++i)
1782 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, sc);
1783 return build_constructor (vectype, v);
1784 }
1785 }
1786
1787 /* Something has messed with the elements of CONSTRUCTOR C after it was built;
1788 calculate TREE_CONSTANT and TREE_SIDE_EFFECTS. */
1789
1790 void
1791 recompute_constructor_flags (tree c)
1792 {
1793 unsigned int i;
1794 tree val;
1795 bool constant_p = true;
1796 bool side_effects_p = false;
1797 vec<constructor_elt, va_gc> *vals = CONSTRUCTOR_ELTS (c);
1798
1799 FOR_EACH_CONSTRUCTOR_VALUE (vals, i, val)
1800 {
1801 /* Mostly ctors will have elts that don't have side-effects, so
1802 the usual case is to scan all the elements. Hence a single
1803 loop for both const and side effects, rather than one loop
1804 each (with early outs). */
1805 if (!TREE_CONSTANT (val))
1806 constant_p = false;
1807 if (TREE_SIDE_EFFECTS (val))
1808 side_effects_p = true;
1809 }
1810
1811 TREE_SIDE_EFFECTS (c) = side_effects_p;
1812 TREE_CONSTANT (c) = constant_p;
1813 }
1814
1815 /* Make sure that TREE_CONSTANT and TREE_SIDE_EFFECTS are correct for
1816 CONSTRUCTOR C. */
1817
1818 void
1819 verify_constructor_flags (tree c)
1820 {
1821 unsigned int i;
1822 tree val;
1823 bool constant_p = TREE_CONSTANT (c);
1824 bool side_effects_p = TREE_SIDE_EFFECTS (c);
1825 vec<constructor_elt, va_gc> *vals = CONSTRUCTOR_ELTS (c);
1826
1827 FOR_EACH_CONSTRUCTOR_VALUE (vals, i, val)
1828 {
1829 if (constant_p && !TREE_CONSTANT (val))
1830 internal_error ("non-constant element in constant CONSTRUCTOR");
1831 if (!side_effects_p && TREE_SIDE_EFFECTS (val))
1832 internal_error ("side-effects element in no-side-effects CONSTRUCTOR");
1833 }
1834 }
1835
1836 /* Return a new CONSTRUCTOR node whose type is TYPE and whose values
1837 are in the vec pointed to by VALS. */
1838 tree
1839 build_constructor (tree type, vec<constructor_elt, va_gc> *vals)
1840 {
1841 tree c = make_node (CONSTRUCTOR);
1842
1843 TREE_TYPE (c) = type;
1844 CONSTRUCTOR_ELTS (c) = vals;
1845
1846 recompute_constructor_flags (c);
1847
1848 return c;
1849 }
1850
1851 /* Build a CONSTRUCTOR node made of a single initializer, with the specified
1852 INDEX and VALUE. */
1853 tree
1854 build_constructor_single (tree type, tree index, tree value)
1855 {
1856 vec<constructor_elt, va_gc> *v;
1857 constructor_elt elt = {index, value};
1858
1859 vec_alloc (v, 1);
1860 v->quick_push (elt);
1861
1862 return build_constructor (type, v);
1863 }
1864
1865
1866 /* Return a new CONSTRUCTOR node whose type is TYPE and whose values
1867 are in a list pointed to by VALS. */
1868 tree
1869 build_constructor_from_list (tree type, tree vals)
1870 {
1871 tree t;
1872 vec<constructor_elt, va_gc> *v = NULL;
1873
1874 if (vals)
1875 {
1876 vec_alloc (v, list_length (vals));
1877 for (t = vals; t; t = TREE_CHAIN (t))
1878 CONSTRUCTOR_APPEND_ELT (v, TREE_PURPOSE (t), TREE_VALUE (t));
1879 }
1880
1881 return build_constructor (type, v);
1882 }
1883
1884 /* Return a new CONSTRUCTOR node whose type is TYPE. NELTS is the number
1885 of elements, provided as index/value pairs. */
1886
1887 tree
1888 build_constructor_va (tree type, int nelts, ...)
1889 {
1890 vec<constructor_elt, va_gc> *v = NULL;
1891 va_list p;
1892
1893 va_start (p, nelts);
1894 vec_alloc (v, nelts);
1895 while (nelts--)
1896 {
1897 tree index = va_arg (p, tree);
1898 tree value = va_arg (p, tree);
1899 CONSTRUCTOR_APPEND_ELT (v, index, value);
1900 }
1901 va_end (p);
1902 return build_constructor (type, v);
1903 }
1904
1905 /* Return a new FIXED_CST node whose type is TYPE and value is F. */
1906
1907 tree
1908 build_fixed (tree type, FIXED_VALUE_TYPE f)
1909 {
1910 tree v;
1911 FIXED_VALUE_TYPE *fp;
1912
1913 v = make_node (FIXED_CST);
1914 fp = ggc_alloc<fixed_value> ();
1915 memcpy (fp, &f, sizeof (FIXED_VALUE_TYPE));
1916
1917 TREE_TYPE (v) = type;
1918 TREE_FIXED_CST_PTR (v) = fp;
1919 return v;
1920 }
1921
1922 /* Return a new REAL_CST node whose type is TYPE and value is D. */
1923
1924 tree
1925 build_real (tree type, REAL_VALUE_TYPE d)
1926 {
1927 tree v;
1928 REAL_VALUE_TYPE *dp;
1929 int overflow = 0;
1930
1931 /* ??? Used to check for overflow here via CHECK_FLOAT_TYPE.
1932 Consider doing it via real_convert now. */
1933
1934 v = make_node (REAL_CST);
1935 dp = ggc_alloc<real_value> ();
1936 memcpy (dp, &d, sizeof (REAL_VALUE_TYPE));
1937
1938 TREE_TYPE (v) = type;
1939 TREE_REAL_CST_PTR (v) = dp;
1940 TREE_OVERFLOW (v) = overflow;
1941 return v;
1942 }
1943
1944 /* Like build_real, but first truncate D to the type. */
1945
1946 tree
1947 build_real_truncate (tree type, REAL_VALUE_TYPE d)
1948 {
1949 return build_real (type, real_value_truncate (TYPE_MODE (type), d));
1950 }
1951
1952 /* Return a new REAL_CST node whose type is TYPE
1953 and whose value is the integer value of the INTEGER_CST node I. */
1954
1955 REAL_VALUE_TYPE
1956 real_value_from_int_cst (const_tree type, const_tree i)
1957 {
1958 REAL_VALUE_TYPE d;
1959
1960 /* Clear all bits of the real value type so that we can later do
1961 bitwise comparisons to see if two values are the same. */
1962 memset (&d, 0, sizeof d);
1963
1964 real_from_integer (&d, type ? TYPE_MODE (type) : VOIDmode, i,
1965 TYPE_SIGN (TREE_TYPE (i)));
1966 return d;
1967 }
1968
1969 /* Given a tree representing an integer constant I, return a tree
1970 representing the same value as a floating-point constant of type TYPE. */
1971
1972 tree
1973 build_real_from_int_cst (tree type, const_tree i)
1974 {
1975 tree v;
1976 int overflow = TREE_OVERFLOW (i);
1977
1978 v = build_real (type, real_value_from_int_cst (type, i));
1979
1980 TREE_OVERFLOW (v) |= overflow;
1981 return v;
1982 }
1983
1984 /* Return a newly constructed STRING_CST node whose value is
1985 the LEN characters at STR.
1986 Note that for a C string literal, LEN should include the trailing NUL.
1987 The TREE_TYPE is not initialized. */
1988
1989 tree
1990 build_string (int len, const char *str)
1991 {
1992 tree s;
1993 size_t length;
1994
1995 /* Do not waste bytes provided by padding of struct tree_string. */
1996 length = len + offsetof (struct tree_string, str) + 1;
1997
1998 record_node_allocation_statistics (STRING_CST, length);
1999
2000 s = (tree) ggc_internal_alloc (length);
2001
2002 memset (s, 0, sizeof (struct tree_typed));
2003 TREE_SET_CODE (s, STRING_CST);
2004 TREE_CONSTANT (s) = 1;
2005 TREE_STRING_LENGTH (s) = len;
2006 memcpy (s->string.str, str, len);
2007 s->string.str[len] = '\0';
2008
2009 return s;
2010 }
2011
2012 /* Return a newly constructed COMPLEX_CST node whose value is
2013 specified by the real and imaginary parts REAL and IMAG.
2014 Both REAL and IMAG should be constant nodes. TYPE, if specified,
2015 will be the type of the COMPLEX_CST; otherwise a new type will be made. */
2016
2017 tree
2018 build_complex (tree type, tree real, tree imag)
2019 {
2020 tree t = make_node (COMPLEX_CST);
2021
2022 TREE_REALPART (t) = real;
2023 TREE_IMAGPART (t) = imag;
2024 TREE_TYPE (t) = type ? type : build_complex_type (TREE_TYPE (real));
2025 TREE_OVERFLOW (t) = TREE_OVERFLOW (real) | TREE_OVERFLOW (imag);
2026 return t;
2027 }
2028
2029 /* Build a complex (inf +- 0i), such as for the result of cproj.
2030 TYPE is the complex tree type of the result. If NEG is true, the
2031 imaginary zero is negative. */
2032
2033 tree
2034 build_complex_inf (tree type, bool neg)
2035 {
2036 REAL_VALUE_TYPE rinf, rzero = dconst0;
2037
2038 real_inf (&rinf);
2039 rzero.sign = neg;
2040 return build_complex (type, build_real (TREE_TYPE (type), rinf),
2041 build_real (TREE_TYPE (type), rzero));
2042 }
2043
2044 /* Return the constant 1 in type TYPE. If TYPE has several elements, each
2045 element is set to 1. In particular, this is 1 + i for complex types. */
2046
2047 tree
2048 build_each_one_cst (tree type)
2049 {
2050 if (TREE_CODE (type) == COMPLEX_TYPE)
2051 {
2052 tree scalar = build_one_cst (TREE_TYPE (type));
2053 return build_complex (type, scalar, scalar);
2054 }
2055 else
2056 return build_one_cst (type);
2057 }
2058
2059 /* Return a constant of arithmetic type TYPE which is the
2060 multiplicative identity of the set TYPE. */
2061
2062 tree
2063 build_one_cst (tree type)
2064 {
2065 switch (TREE_CODE (type))
2066 {
2067 case INTEGER_TYPE: case ENUMERAL_TYPE: case BOOLEAN_TYPE:
2068 case POINTER_TYPE: case REFERENCE_TYPE:
2069 case OFFSET_TYPE:
2070 return build_int_cst (type, 1);
2071
2072 case REAL_TYPE:
2073 return build_real (type, dconst1);
2074
2075 case FIXED_POINT_TYPE:
2076 /* We can only generate 1 for accum types. */
2077 gcc_assert (ALL_SCALAR_ACCUM_MODE_P (TYPE_MODE (type)));
2078 return build_fixed (type, FCONST1 (TYPE_MODE (type)));
2079
2080 case VECTOR_TYPE:
2081 {
2082 tree scalar = build_one_cst (TREE_TYPE (type));
2083
2084 return build_vector_from_val (type, scalar);
2085 }
2086
2087 case COMPLEX_TYPE:
2088 return build_complex (type,
2089 build_one_cst (TREE_TYPE (type)),
2090 build_zero_cst (TREE_TYPE (type)));
2091
2092 default:
2093 gcc_unreachable ();
2094 }
2095 }
2096
2097 /* Return an integer of type TYPE containing all 1's in as much precision as
2098 it contains, or a complex or vector whose subparts are such integers. */
2099
2100 tree
2101 build_all_ones_cst (tree type)
2102 {
2103 if (TREE_CODE (type) == COMPLEX_TYPE)
2104 {
2105 tree scalar = build_all_ones_cst (TREE_TYPE (type));
2106 return build_complex (type, scalar, scalar);
2107 }
2108 else
2109 return build_minus_one_cst (type);
2110 }
2111
2112 /* Return a constant of arithmetic type TYPE which is the
2113 opposite of the multiplicative identity of the set TYPE. */
2114
2115 tree
2116 build_minus_one_cst (tree type)
2117 {
2118 switch (TREE_CODE (type))
2119 {
2120 case INTEGER_TYPE: case ENUMERAL_TYPE: case BOOLEAN_TYPE:
2121 case POINTER_TYPE: case REFERENCE_TYPE:
2122 case OFFSET_TYPE:
2123 return build_int_cst (type, -1);
2124
2125 case REAL_TYPE:
2126 return build_real (type, dconstm1);
2127
2128 case FIXED_POINT_TYPE:
2129 /* We can only generate 1 for accum types. */
2130 gcc_assert (ALL_SCALAR_ACCUM_MODE_P (TYPE_MODE (type)));
2131 return build_fixed (type, fixed_from_double_int (double_int_minus_one,
2132 TYPE_MODE (type)));
2133
2134 case VECTOR_TYPE:
2135 {
2136 tree scalar = build_minus_one_cst (TREE_TYPE (type));
2137
2138 return build_vector_from_val (type, scalar);
2139 }
2140
2141 case COMPLEX_TYPE:
2142 return build_complex (type,
2143 build_minus_one_cst (TREE_TYPE (type)),
2144 build_zero_cst (TREE_TYPE (type)));
2145
2146 default:
2147 gcc_unreachable ();
2148 }
2149 }
2150
2151 /* Build 0 constant of type TYPE. This is used by constructor folding
2152 and thus the constant should be represented in memory by
2153 zero(es). */
2154
2155 tree
2156 build_zero_cst (tree type)
2157 {
2158 switch (TREE_CODE (type))
2159 {
2160 case INTEGER_TYPE: case ENUMERAL_TYPE: case BOOLEAN_TYPE:
2161 case POINTER_TYPE: case REFERENCE_TYPE:
2162 case OFFSET_TYPE: case NULLPTR_TYPE:
2163 return build_int_cst (type, 0);
2164
2165 case REAL_TYPE:
2166 return build_real (type, dconst0);
2167
2168 case FIXED_POINT_TYPE:
2169 return build_fixed (type, FCONST0 (TYPE_MODE (type)));
2170
2171 case VECTOR_TYPE:
2172 {
2173 tree scalar = build_zero_cst (TREE_TYPE (type));
2174
2175 return build_vector_from_val (type, scalar);
2176 }
2177
2178 case COMPLEX_TYPE:
2179 {
2180 tree zero = build_zero_cst (TREE_TYPE (type));
2181
2182 return build_complex (type, zero, zero);
2183 }
2184
2185 default:
2186 if (!AGGREGATE_TYPE_P (type))
2187 return fold_convert (type, integer_zero_node);
2188 return build_constructor (type, NULL);
2189 }
2190 }
2191
2192
2193 /* Build a BINFO with LEN language slots. */
2194
2195 tree
2196 make_tree_binfo_stat (unsigned base_binfos MEM_STAT_DECL)
2197 {
2198 tree t;
2199 size_t length = (offsetof (struct tree_binfo, base_binfos)
2200 + vec<tree, va_gc>::embedded_size (base_binfos));
2201
2202 record_node_allocation_statistics (TREE_BINFO, length);
2203
2204 t = ggc_alloc_tree_node_stat (length PASS_MEM_STAT);
2205
2206 memset (t, 0, offsetof (struct tree_binfo, base_binfos));
2207
2208 TREE_SET_CODE (t, TREE_BINFO);
2209
2210 BINFO_BASE_BINFOS (t)->embedded_init (base_binfos);
2211
2212 return t;
2213 }
2214
2215 /* Create a CASE_LABEL_EXPR tree node and return it. */
2216
2217 tree
2218 build_case_label (tree low_value, tree high_value, tree label_decl)
2219 {
2220 tree t = make_node (CASE_LABEL_EXPR);
2221
2222 TREE_TYPE (t) = void_type_node;
2223 SET_EXPR_LOCATION (t, DECL_SOURCE_LOCATION (label_decl));
2224
2225 CASE_LOW (t) = low_value;
2226 CASE_HIGH (t) = high_value;
2227 CASE_LABEL (t) = label_decl;
2228 CASE_CHAIN (t) = NULL_TREE;
2229
2230 return t;
2231 }
2232
2233 /* Build a newly constructed INTEGER_CST node. LEN and EXT_LEN are the
2234 values of TREE_INT_CST_NUNITS and TREE_INT_CST_EXT_NUNITS respectively.
2235 The latter determines the length of the HOST_WIDE_INT vector. */
2236
2237 tree
2238 make_int_cst_stat (int len, int ext_len MEM_STAT_DECL)
2239 {
2240 tree t;
2241 int length = ((ext_len - 1) * sizeof (HOST_WIDE_INT)
2242 + sizeof (struct tree_int_cst));
2243
2244 gcc_assert (len);
2245 record_node_allocation_statistics (INTEGER_CST, length);
2246
2247 t = ggc_alloc_cleared_tree_node_stat (length PASS_MEM_STAT);
2248
2249 TREE_SET_CODE (t, INTEGER_CST);
2250 TREE_INT_CST_NUNITS (t) = len;
2251 TREE_INT_CST_EXT_NUNITS (t) = ext_len;
2252 /* to_offset can only be applied to trees that are offset_int-sized
2253 or smaller. EXT_LEN is correct if it fits, otherwise the constant
2254 must be exactly the precision of offset_int and so LEN is correct. */
2255 if (ext_len <= OFFSET_INT_ELTS)
2256 TREE_INT_CST_OFFSET_NUNITS (t) = ext_len;
2257 else
2258 TREE_INT_CST_OFFSET_NUNITS (t) = len;
2259
2260 TREE_CONSTANT (t) = 1;
2261
2262 return t;
2263 }
2264
2265 /* Build a newly constructed TREE_VEC node of length LEN. */
2266
2267 tree
2268 make_tree_vec_stat (int len MEM_STAT_DECL)
2269 {
2270 tree t;
2271 size_t length = (len - 1) * sizeof (tree) + sizeof (struct tree_vec);
2272
2273 record_node_allocation_statistics (TREE_VEC, length);
2274
2275 t = ggc_alloc_cleared_tree_node_stat (length PASS_MEM_STAT);
2276
2277 TREE_SET_CODE (t, TREE_VEC);
2278 TREE_VEC_LENGTH (t) = len;
2279
2280 return t;
2281 }
2282
2283 /* Grow a TREE_VEC node to new length LEN. */
2284
2285 tree
2286 grow_tree_vec_stat (tree v, int len MEM_STAT_DECL)
2287 {
2288 gcc_assert (TREE_CODE (v) == TREE_VEC);
2289
2290 int oldlen = TREE_VEC_LENGTH (v);
2291 gcc_assert (len > oldlen);
2292
2293 size_t oldlength = (oldlen - 1) * sizeof (tree) + sizeof (struct tree_vec);
2294 size_t length = (len - 1) * sizeof (tree) + sizeof (struct tree_vec);
2295
2296 record_node_allocation_statistics (TREE_VEC, length - oldlength);
2297
2298 v = (tree) ggc_realloc (v, length PASS_MEM_STAT);
2299
2300 TREE_VEC_LENGTH (v) = len;
2301
2302 return v;
2303 }
2304 \f
2305 /* Return 1 if EXPR is the constant zero, whether it is integral, float or
2306 fixed, and scalar, complex or vector. */
2307
2308 int
2309 zerop (const_tree expr)
2310 {
2311 return (integer_zerop (expr)
2312 || real_zerop (expr)
2313 || fixed_zerop (expr));
2314 }
2315
2316 /* Return 1 if EXPR is the integer constant zero or a complex constant
2317 of zero. */
2318
2319 int
2320 integer_zerop (const_tree expr)
2321 {
2322 switch (TREE_CODE (expr))
2323 {
2324 case INTEGER_CST:
2325 return wi::eq_p (expr, 0);
2326 case COMPLEX_CST:
2327 return (integer_zerop (TREE_REALPART (expr))
2328 && integer_zerop (TREE_IMAGPART (expr)));
2329 case VECTOR_CST:
2330 {
2331 unsigned i;
2332 for (i = 0; i < VECTOR_CST_NELTS (expr); ++i)
2333 if (!integer_zerop (VECTOR_CST_ELT (expr, i)))
2334 return false;
2335 return true;
2336 }
2337 default:
2338 return false;
2339 }
2340 }
2341
2342 /* Return 1 if EXPR is the integer constant one or the corresponding
2343 complex constant. */
2344
2345 int
2346 integer_onep (const_tree expr)
2347 {
2348 switch (TREE_CODE (expr))
2349 {
2350 case INTEGER_CST:
2351 return wi::eq_p (wi::to_widest (expr), 1);
2352 case COMPLEX_CST:
2353 return (integer_onep (TREE_REALPART (expr))
2354 && integer_zerop (TREE_IMAGPART (expr)));
2355 case VECTOR_CST:
2356 {
2357 unsigned i;
2358 for (i = 0; i < VECTOR_CST_NELTS (expr); ++i)
2359 if (!integer_onep (VECTOR_CST_ELT (expr, i)))
2360 return false;
2361 return true;
2362 }
2363 default:
2364 return false;
2365 }
2366 }
2367
2368 /* Return 1 if EXPR is the integer constant one. For complex and vector,
2369 return 1 if every piece is the integer constant one. */
2370
2371 int
2372 integer_each_onep (const_tree expr)
2373 {
2374 if (TREE_CODE (expr) == COMPLEX_CST)
2375 return (integer_onep (TREE_REALPART (expr))
2376 && integer_onep (TREE_IMAGPART (expr)));
2377 else
2378 return integer_onep (expr);
2379 }
2380
2381 /* Return 1 if EXPR is an integer containing all 1's in as much precision as
2382 it contains, or a complex or vector whose subparts are such integers. */
2383
2384 int
2385 integer_all_onesp (const_tree expr)
2386 {
2387 if (TREE_CODE (expr) == COMPLEX_CST
2388 && integer_all_onesp (TREE_REALPART (expr))
2389 && integer_all_onesp (TREE_IMAGPART (expr)))
2390 return 1;
2391
2392 else if (TREE_CODE (expr) == VECTOR_CST)
2393 {
2394 unsigned i;
2395 for (i = 0; i < VECTOR_CST_NELTS (expr); ++i)
2396 if (!integer_all_onesp (VECTOR_CST_ELT (expr, i)))
2397 return 0;
2398 return 1;
2399 }
2400
2401 else if (TREE_CODE (expr) != INTEGER_CST)
2402 return 0;
2403
2404 return wi::max_value (TYPE_PRECISION (TREE_TYPE (expr)), UNSIGNED) == expr;
2405 }
2406
2407 /* Return 1 if EXPR is the integer constant minus one. */
2408
2409 int
2410 integer_minus_onep (const_tree expr)
2411 {
2412 if (TREE_CODE (expr) == COMPLEX_CST)
2413 return (integer_all_onesp (TREE_REALPART (expr))
2414 && integer_zerop (TREE_IMAGPART (expr)));
2415 else
2416 return integer_all_onesp (expr);
2417 }
2418
2419 /* Return 1 if EXPR is an integer constant that is a power of 2 (i.e., has only
2420 one bit on). */
2421
2422 int
2423 integer_pow2p (const_tree expr)
2424 {
2425 if (TREE_CODE (expr) == COMPLEX_CST
2426 && integer_pow2p (TREE_REALPART (expr))
2427 && integer_zerop (TREE_IMAGPART (expr)))
2428 return 1;
2429
2430 if (TREE_CODE (expr) != INTEGER_CST)
2431 return 0;
2432
2433 return wi::popcount (expr) == 1;
2434 }
2435
2436 /* Return 1 if EXPR is an integer constant other than zero or a
2437 complex constant other than zero. */
2438
2439 int
2440 integer_nonzerop (const_tree expr)
2441 {
2442 return ((TREE_CODE (expr) == INTEGER_CST
2443 && !wi::eq_p (expr, 0))
2444 || (TREE_CODE (expr) == COMPLEX_CST
2445 && (integer_nonzerop (TREE_REALPART (expr))
2446 || integer_nonzerop (TREE_IMAGPART (expr)))));
2447 }
2448
2449 /* Return 1 if EXPR is the integer constant one. For vector,
2450 return 1 if every piece is the integer constant minus one
2451 (representing the value TRUE). */
2452
2453 int
2454 integer_truep (const_tree expr)
2455 {
2456 if (TREE_CODE (expr) == VECTOR_CST)
2457 return integer_all_onesp (expr);
2458 return integer_onep (expr);
2459 }
2460
2461 /* Return 1 if EXPR is the fixed-point constant zero. */
2462
2463 int
2464 fixed_zerop (const_tree expr)
2465 {
2466 return (TREE_CODE (expr) == FIXED_CST
2467 && TREE_FIXED_CST (expr).data.is_zero ());
2468 }
2469
2470 /* Return the power of two represented by a tree node known to be a
2471 power of two. */
2472
2473 int
2474 tree_log2 (const_tree expr)
2475 {
2476 if (TREE_CODE (expr) == COMPLEX_CST)
2477 return tree_log2 (TREE_REALPART (expr));
2478
2479 return wi::exact_log2 (expr);
2480 }
2481
2482 /* Similar, but return the largest integer Y such that 2 ** Y is less
2483 than or equal to EXPR. */
2484
2485 int
2486 tree_floor_log2 (const_tree expr)
2487 {
2488 if (TREE_CODE (expr) == COMPLEX_CST)
2489 return tree_log2 (TREE_REALPART (expr));
2490
2491 return wi::floor_log2 (expr);
2492 }
2493
2494 /* Return number of known trailing zero bits in EXPR, or, if the value of
2495 EXPR is known to be zero, the precision of it's type. */
2496
2497 unsigned int
2498 tree_ctz (const_tree expr)
2499 {
2500 if (!INTEGRAL_TYPE_P (TREE_TYPE (expr))
2501 && !POINTER_TYPE_P (TREE_TYPE (expr)))
2502 return 0;
2503
2504 unsigned int ret1, ret2, prec = TYPE_PRECISION (TREE_TYPE (expr));
2505 switch (TREE_CODE (expr))
2506 {
2507 case INTEGER_CST:
2508 ret1 = wi::ctz (expr);
2509 return MIN (ret1, prec);
2510 case SSA_NAME:
2511 ret1 = wi::ctz (get_nonzero_bits (expr));
2512 return MIN (ret1, prec);
2513 case PLUS_EXPR:
2514 case MINUS_EXPR:
2515 case BIT_IOR_EXPR:
2516 case BIT_XOR_EXPR:
2517 case MIN_EXPR:
2518 case MAX_EXPR:
2519 ret1 = tree_ctz (TREE_OPERAND (expr, 0));
2520 if (ret1 == 0)
2521 return ret1;
2522 ret2 = tree_ctz (TREE_OPERAND (expr, 1));
2523 return MIN (ret1, ret2);
2524 case POINTER_PLUS_EXPR:
2525 ret1 = tree_ctz (TREE_OPERAND (expr, 0));
2526 ret2 = tree_ctz (TREE_OPERAND (expr, 1));
2527 /* Second operand is sizetype, which could be in theory
2528 wider than pointer's precision. Make sure we never
2529 return more than prec. */
2530 ret2 = MIN (ret2, prec);
2531 return MIN (ret1, ret2);
2532 case BIT_AND_EXPR:
2533 ret1 = tree_ctz (TREE_OPERAND (expr, 0));
2534 ret2 = tree_ctz (TREE_OPERAND (expr, 1));
2535 return MAX (ret1, ret2);
2536 case MULT_EXPR:
2537 ret1 = tree_ctz (TREE_OPERAND (expr, 0));
2538 ret2 = tree_ctz (TREE_OPERAND (expr, 1));
2539 return MIN (ret1 + ret2, prec);
2540 case LSHIFT_EXPR:
2541 ret1 = tree_ctz (TREE_OPERAND (expr, 0));
2542 if (tree_fits_uhwi_p (TREE_OPERAND (expr, 1))
2543 && (tree_to_uhwi (TREE_OPERAND (expr, 1)) < prec))
2544 {
2545 ret2 = tree_to_uhwi (TREE_OPERAND (expr, 1));
2546 return MIN (ret1 + ret2, prec);
2547 }
2548 return ret1;
2549 case RSHIFT_EXPR:
2550 if (tree_fits_uhwi_p (TREE_OPERAND (expr, 1))
2551 && (tree_to_uhwi (TREE_OPERAND (expr, 1)) < prec))
2552 {
2553 ret1 = tree_ctz (TREE_OPERAND (expr, 0));
2554 ret2 = tree_to_uhwi (TREE_OPERAND (expr, 1));
2555 if (ret1 > ret2)
2556 return ret1 - ret2;
2557 }
2558 return 0;
2559 case TRUNC_DIV_EXPR:
2560 case CEIL_DIV_EXPR:
2561 case FLOOR_DIV_EXPR:
2562 case ROUND_DIV_EXPR:
2563 case EXACT_DIV_EXPR:
2564 if (TREE_CODE (TREE_OPERAND (expr, 1)) == INTEGER_CST
2565 && tree_int_cst_sgn (TREE_OPERAND (expr, 1)) == 1)
2566 {
2567 int l = tree_log2 (TREE_OPERAND (expr, 1));
2568 if (l >= 0)
2569 {
2570 ret1 = tree_ctz (TREE_OPERAND (expr, 0));
2571 ret2 = l;
2572 if (ret1 > ret2)
2573 return ret1 - ret2;
2574 }
2575 }
2576 return 0;
2577 CASE_CONVERT:
2578 ret1 = tree_ctz (TREE_OPERAND (expr, 0));
2579 if (ret1 && ret1 == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (expr, 0))))
2580 ret1 = prec;
2581 return MIN (ret1, prec);
2582 case SAVE_EXPR:
2583 return tree_ctz (TREE_OPERAND (expr, 0));
2584 case COND_EXPR:
2585 ret1 = tree_ctz (TREE_OPERAND (expr, 1));
2586 if (ret1 == 0)
2587 return 0;
2588 ret2 = tree_ctz (TREE_OPERAND (expr, 2));
2589 return MIN (ret1, ret2);
2590 case COMPOUND_EXPR:
2591 return tree_ctz (TREE_OPERAND (expr, 1));
2592 case ADDR_EXPR:
2593 ret1 = get_pointer_alignment (CONST_CAST_TREE (expr));
2594 if (ret1 > BITS_PER_UNIT)
2595 {
2596 ret1 = ctz_hwi (ret1 / BITS_PER_UNIT);
2597 return MIN (ret1, prec);
2598 }
2599 return 0;
2600 default:
2601 return 0;
2602 }
2603 }
2604
2605 /* Return 1 if EXPR is the real constant zero. Trailing zeroes matter for
2606 decimal float constants, so don't return 1 for them. */
2607
2608 int
2609 real_zerop (const_tree expr)
2610 {
2611 switch (TREE_CODE (expr))
2612 {
2613 case REAL_CST:
2614 return real_equal (&TREE_REAL_CST (expr), &dconst0)
2615 && !(DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (expr))));
2616 case COMPLEX_CST:
2617 return real_zerop (TREE_REALPART (expr))
2618 && real_zerop (TREE_IMAGPART (expr));
2619 case VECTOR_CST:
2620 {
2621 unsigned i;
2622 for (i = 0; i < VECTOR_CST_NELTS (expr); ++i)
2623 if (!real_zerop (VECTOR_CST_ELT (expr, i)))
2624 return false;
2625 return true;
2626 }
2627 default:
2628 return false;
2629 }
2630 }
2631
2632 /* Return 1 if EXPR is the real constant one in real or complex form.
2633 Trailing zeroes matter for decimal float constants, so don't return
2634 1 for them. */
2635
2636 int
2637 real_onep (const_tree expr)
2638 {
2639 switch (TREE_CODE (expr))
2640 {
2641 case REAL_CST:
2642 return real_equal (&TREE_REAL_CST (expr), &dconst1)
2643 && !(DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (expr))));
2644 case COMPLEX_CST:
2645 return real_onep (TREE_REALPART (expr))
2646 && real_zerop (TREE_IMAGPART (expr));
2647 case VECTOR_CST:
2648 {
2649 unsigned i;
2650 for (i = 0; i < VECTOR_CST_NELTS (expr); ++i)
2651 if (!real_onep (VECTOR_CST_ELT (expr, i)))
2652 return false;
2653 return true;
2654 }
2655 default:
2656 return false;
2657 }
2658 }
2659
2660 /* Return 1 if EXPR is the real constant minus one. Trailing zeroes
2661 matter for decimal float constants, so don't return 1 for them. */
2662
2663 int
2664 real_minus_onep (const_tree expr)
2665 {
2666 switch (TREE_CODE (expr))
2667 {
2668 case REAL_CST:
2669 return real_equal (&TREE_REAL_CST (expr), &dconstm1)
2670 && !(DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (expr))));
2671 case COMPLEX_CST:
2672 return real_minus_onep (TREE_REALPART (expr))
2673 && real_zerop (TREE_IMAGPART (expr));
2674 case VECTOR_CST:
2675 {
2676 unsigned i;
2677 for (i = 0; i < VECTOR_CST_NELTS (expr); ++i)
2678 if (!real_minus_onep (VECTOR_CST_ELT (expr, i)))
2679 return false;
2680 return true;
2681 }
2682 default:
2683 return false;
2684 }
2685 }
2686
2687 /* Nonzero if EXP is a constant or a cast of a constant. */
2688
2689 int
2690 really_constant_p (const_tree exp)
2691 {
2692 /* This is not quite the same as STRIP_NOPS. It does more. */
2693 while (CONVERT_EXPR_P (exp)
2694 || TREE_CODE (exp) == NON_LVALUE_EXPR)
2695 exp = TREE_OPERAND (exp, 0);
2696 return TREE_CONSTANT (exp);
2697 }
2698 \f
2699 /* Return first list element whose TREE_VALUE is ELEM.
2700 Return 0 if ELEM is not in LIST. */
2701
2702 tree
2703 value_member (tree elem, tree list)
2704 {
2705 while (list)
2706 {
2707 if (elem == TREE_VALUE (list))
2708 return list;
2709 list = TREE_CHAIN (list);
2710 }
2711 return NULL_TREE;
2712 }
2713
2714 /* Return first list element whose TREE_PURPOSE is ELEM.
2715 Return 0 if ELEM is not in LIST. */
2716
2717 tree
2718 purpose_member (const_tree elem, tree list)
2719 {
2720 while (list)
2721 {
2722 if (elem == TREE_PURPOSE (list))
2723 return list;
2724 list = TREE_CHAIN (list);
2725 }
2726 return NULL_TREE;
2727 }
2728
2729 /* Return true if ELEM is in V. */
2730
2731 bool
2732 vec_member (const_tree elem, vec<tree, va_gc> *v)
2733 {
2734 unsigned ix;
2735 tree t;
2736 FOR_EACH_VEC_SAFE_ELT (v, ix, t)
2737 if (elem == t)
2738 return true;
2739 return false;
2740 }
2741
2742 /* Returns element number IDX (zero-origin) of chain CHAIN, or
2743 NULL_TREE. */
2744
2745 tree
2746 chain_index (int idx, tree chain)
2747 {
2748 for (; chain && idx > 0; --idx)
2749 chain = TREE_CHAIN (chain);
2750 return chain;
2751 }
2752
2753 /* Return nonzero if ELEM is part of the chain CHAIN. */
2754
2755 int
2756 chain_member (const_tree elem, const_tree chain)
2757 {
2758 while (chain)
2759 {
2760 if (elem == chain)
2761 return 1;
2762 chain = DECL_CHAIN (chain);
2763 }
2764
2765 return 0;
2766 }
2767
2768 /* Return the length of a chain of nodes chained through TREE_CHAIN.
2769 We expect a null pointer to mark the end of the chain.
2770 This is the Lisp primitive `length'. */
2771
2772 int
2773 list_length (const_tree t)
2774 {
2775 const_tree p = t;
2776 #ifdef ENABLE_TREE_CHECKING
2777 const_tree q = t;
2778 #endif
2779 int len = 0;
2780
2781 while (p)
2782 {
2783 p = TREE_CHAIN (p);
2784 #ifdef ENABLE_TREE_CHECKING
2785 if (len % 2)
2786 q = TREE_CHAIN (q);
2787 gcc_assert (p != q);
2788 #endif
2789 len++;
2790 }
2791
2792 return len;
2793 }
2794
2795 /* Returns the first FIELD_DECL in the TYPE_FIELDS of the RECORD_TYPE or
2796 UNION_TYPE TYPE, or NULL_TREE if none. */
2797
2798 tree
2799 first_field (const_tree type)
2800 {
2801 tree t = TYPE_FIELDS (type);
2802 while (t && TREE_CODE (t) != FIELD_DECL)
2803 t = TREE_CHAIN (t);
2804 return t;
2805 }
2806
2807 /* Concatenate two chains of nodes (chained through TREE_CHAIN)
2808 by modifying the last node in chain 1 to point to chain 2.
2809 This is the Lisp primitive `nconc'. */
2810
2811 tree
2812 chainon (tree op1, tree op2)
2813 {
2814 tree t1;
2815
2816 if (!op1)
2817 return op2;
2818 if (!op2)
2819 return op1;
2820
2821 for (t1 = op1; TREE_CHAIN (t1); t1 = TREE_CHAIN (t1))
2822 continue;
2823 TREE_CHAIN (t1) = op2;
2824
2825 #ifdef ENABLE_TREE_CHECKING
2826 {
2827 tree t2;
2828 for (t2 = op2; t2; t2 = TREE_CHAIN (t2))
2829 gcc_assert (t2 != t1);
2830 }
2831 #endif
2832
2833 return op1;
2834 }
2835
2836 /* Return the last node in a chain of nodes (chained through TREE_CHAIN). */
2837
2838 tree
2839 tree_last (tree chain)
2840 {
2841 tree next;
2842 if (chain)
2843 while ((next = TREE_CHAIN (chain)))
2844 chain = next;
2845 return chain;
2846 }
2847
2848 /* Reverse the order of elements in the chain T,
2849 and return the new head of the chain (old last element). */
2850
2851 tree
2852 nreverse (tree t)
2853 {
2854 tree prev = 0, decl, next;
2855 for (decl = t; decl; decl = next)
2856 {
2857 /* We shouldn't be using this function to reverse BLOCK chains; we
2858 have blocks_nreverse for that. */
2859 gcc_checking_assert (TREE_CODE (decl) != BLOCK);
2860 next = TREE_CHAIN (decl);
2861 TREE_CHAIN (decl) = prev;
2862 prev = decl;
2863 }
2864 return prev;
2865 }
2866 \f
2867 /* Return a newly created TREE_LIST node whose
2868 purpose and value fields are PARM and VALUE. */
2869
2870 tree
2871 build_tree_list_stat (tree parm, tree value MEM_STAT_DECL)
2872 {
2873 tree t = make_node_stat (TREE_LIST PASS_MEM_STAT);
2874 TREE_PURPOSE (t) = parm;
2875 TREE_VALUE (t) = value;
2876 return t;
2877 }
2878
2879 /* Build a chain of TREE_LIST nodes from a vector. */
2880
2881 tree
2882 build_tree_list_vec_stat (const vec<tree, va_gc> *vec MEM_STAT_DECL)
2883 {
2884 tree ret = NULL_TREE;
2885 tree *pp = &ret;
2886 unsigned int i;
2887 tree t;
2888 FOR_EACH_VEC_SAFE_ELT (vec, i, t)
2889 {
2890 *pp = build_tree_list_stat (NULL, t PASS_MEM_STAT);
2891 pp = &TREE_CHAIN (*pp);
2892 }
2893 return ret;
2894 }
2895
2896 /* Return a newly created TREE_LIST node whose
2897 purpose and value fields are PURPOSE and VALUE
2898 and whose TREE_CHAIN is CHAIN. */
2899
2900 tree
2901 tree_cons_stat (tree purpose, tree value, tree chain MEM_STAT_DECL)
2902 {
2903 tree node;
2904
2905 node = ggc_alloc_tree_node_stat (sizeof (struct tree_list) PASS_MEM_STAT);
2906 memset (node, 0, sizeof (struct tree_common));
2907
2908 record_node_allocation_statistics (TREE_LIST, sizeof (struct tree_list));
2909
2910 TREE_SET_CODE (node, TREE_LIST);
2911 TREE_CHAIN (node) = chain;
2912 TREE_PURPOSE (node) = purpose;
2913 TREE_VALUE (node) = value;
2914 return node;
2915 }
2916
2917 /* Return the values of the elements of a CONSTRUCTOR as a vector of
2918 trees. */
2919
2920 vec<tree, va_gc> *
2921 ctor_to_vec (tree ctor)
2922 {
2923 vec<tree, va_gc> *vec;
2924 vec_alloc (vec, CONSTRUCTOR_NELTS (ctor));
2925 unsigned int ix;
2926 tree val;
2927
2928 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (ctor), ix, val)
2929 vec->quick_push (val);
2930
2931 return vec;
2932 }
2933 \f
2934 /* Return the size nominally occupied by an object of type TYPE
2935 when it resides in memory. The value is measured in units of bytes,
2936 and its data type is that normally used for type sizes
2937 (which is the first type created by make_signed_type or
2938 make_unsigned_type). */
2939
2940 tree
2941 size_in_bytes_loc (location_t loc, const_tree type)
2942 {
2943 tree t;
2944
2945 if (type == error_mark_node)
2946 return integer_zero_node;
2947
2948 type = TYPE_MAIN_VARIANT (type);
2949 t = TYPE_SIZE_UNIT (type);
2950
2951 if (t == 0)
2952 {
2953 lang_hooks.types.incomplete_type_error (loc, NULL_TREE, type);
2954 return size_zero_node;
2955 }
2956
2957 return t;
2958 }
2959
2960 /* Return the size of TYPE (in bytes) as a wide integer
2961 or return -1 if the size can vary or is larger than an integer. */
2962
2963 HOST_WIDE_INT
2964 int_size_in_bytes (const_tree type)
2965 {
2966 tree t;
2967
2968 if (type == error_mark_node)
2969 return 0;
2970
2971 type = TYPE_MAIN_VARIANT (type);
2972 t = TYPE_SIZE_UNIT (type);
2973
2974 if (t && tree_fits_uhwi_p (t))
2975 return TREE_INT_CST_LOW (t);
2976 else
2977 return -1;
2978 }
2979
2980 /* Return the maximum size of TYPE (in bytes) as a wide integer
2981 or return -1 if the size can vary or is larger than an integer. */
2982
2983 HOST_WIDE_INT
2984 max_int_size_in_bytes (const_tree type)
2985 {
2986 HOST_WIDE_INT size = -1;
2987 tree size_tree;
2988
2989 /* If this is an array type, check for a possible MAX_SIZE attached. */
2990
2991 if (TREE_CODE (type) == ARRAY_TYPE)
2992 {
2993 size_tree = TYPE_ARRAY_MAX_SIZE (type);
2994
2995 if (size_tree && tree_fits_uhwi_p (size_tree))
2996 size = tree_to_uhwi (size_tree);
2997 }
2998
2999 /* If we still haven't been able to get a size, see if the language
3000 can compute a maximum size. */
3001
3002 if (size == -1)
3003 {
3004 size_tree = lang_hooks.types.max_size (type);
3005
3006 if (size_tree && tree_fits_uhwi_p (size_tree))
3007 size = tree_to_uhwi (size_tree);
3008 }
3009
3010 return size;
3011 }
3012 \f
3013 /* Return the bit position of FIELD, in bits from the start of the record.
3014 This is a tree of type bitsizetype. */
3015
3016 tree
3017 bit_position (const_tree field)
3018 {
3019 return bit_from_pos (DECL_FIELD_OFFSET (field),
3020 DECL_FIELD_BIT_OFFSET (field));
3021 }
3022 \f
3023 /* Return the byte position of FIELD, in bytes from the start of the record.
3024 This is a tree of type sizetype. */
3025
3026 tree
3027 byte_position (const_tree field)
3028 {
3029 return byte_from_pos (DECL_FIELD_OFFSET (field),
3030 DECL_FIELD_BIT_OFFSET (field));
3031 }
3032
3033 /* Likewise, but return as an integer. It must be representable in
3034 that way (since it could be a signed value, we don't have the
3035 option of returning -1 like int_size_in_byte can. */
3036
3037 HOST_WIDE_INT
3038 int_byte_position (const_tree field)
3039 {
3040 return tree_to_shwi (byte_position (field));
3041 }
3042 \f
3043 /* Return the strictest alignment, in bits, that T is known to have. */
3044
3045 unsigned int
3046 expr_align (const_tree t)
3047 {
3048 unsigned int align0, align1;
3049
3050 switch (TREE_CODE (t))
3051 {
3052 CASE_CONVERT: case NON_LVALUE_EXPR:
3053 /* If we have conversions, we know that the alignment of the
3054 object must meet each of the alignments of the types. */
3055 align0 = expr_align (TREE_OPERAND (t, 0));
3056 align1 = TYPE_ALIGN (TREE_TYPE (t));
3057 return MAX (align0, align1);
3058
3059 case SAVE_EXPR: case COMPOUND_EXPR: case MODIFY_EXPR:
3060 case INIT_EXPR: case TARGET_EXPR: case WITH_CLEANUP_EXPR:
3061 case CLEANUP_POINT_EXPR:
3062 /* These don't change the alignment of an object. */
3063 return expr_align (TREE_OPERAND (t, 0));
3064
3065 case COND_EXPR:
3066 /* The best we can do is say that the alignment is the least aligned
3067 of the two arms. */
3068 align0 = expr_align (TREE_OPERAND (t, 1));
3069 align1 = expr_align (TREE_OPERAND (t, 2));
3070 return MIN (align0, align1);
3071
3072 /* FIXME: LABEL_DECL and CONST_DECL never have DECL_ALIGN set
3073 meaningfully, it's always 1. */
3074 case LABEL_DECL: case CONST_DECL:
3075 case VAR_DECL: case PARM_DECL: case RESULT_DECL:
3076 case FUNCTION_DECL:
3077 gcc_assert (DECL_ALIGN (t) != 0);
3078 return DECL_ALIGN (t);
3079
3080 default:
3081 break;
3082 }
3083
3084 /* Otherwise take the alignment from that of the type. */
3085 return TYPE_ALIGN (TREE_TYPE (t));
3086 }
3087 \f
3088 /* Return, as a tree node, the number of elements for TYPE (which is an
3089 ARRAY_TYPE) minus one. This counts only elements of the top array. */
3090
3091 tree
3092 array_type_nelts (const_tree type)
3093 {
3094 tree index_type, min, max;
3095
3096 /* If they did it with unspecified bounds, then we should have already
3097 given an error about it before we got here. */
3098 if (! TYPE_DOMAIN (type))
3099 return error_mark_node;
3100
3101 index_type = TYPE_DOMAIN (type);
3102 min = TYPE_MIN_VALUE (index_type);
3103 max = TYPE_MAX_VALUE (index_type);
3104
3105 /* TYPE_MAX_VALUE may not be set if the array has unknown length. */
3106 if (!max)
3107 return error_mark_node;
3108
3109 return (integer_zerop (min)
3110 ? max
3111 : fold_build2 (MINUS_EXPR, TREE_TYPE (max), max, min));
3112 }
3113 \f
3114 /* If arg is static -- a reference to an object in static storage -- then
3115 return the object. This is not the same as the C meaning of `static'.
3116 If arg isn't static, return NULL. */
3117
3118 tree
3119 staticp (tree arg)
3120 {
3121 switch (TREE_CODE (arg))
3122 {
3123 case FUNCTION_DECL:
3124 /* Nested functions are static, even though taking their address will
3125 involve a trampoline as we unnest the nested function and create
3126 the trampoline on the tree level. */
3127 return arg;
3128
3129 case VAR_DECL:
3130 return ((TREE_STATIC (arg) || DECL_EXTERNAL (arg))
3131 && ! DECL_THREAD_LOCAL_P (arg)
3132 && ! DECL_DLLIMPORT_P (arg)
3133 ? arg : NULL);
3134
3135 case CONST_DECL:
3136 return ((TREE_STATIC (arg) || DECL_EXTERNAL (arg))
3137 ? arg : NULL);
3138
3139 case CONSTRUCTOR:
3140 return TREE_STATIC (arg) ? arg : NULL;
3141
3142 case LABEL_DECL:
3143 case STRING_CST:
3144 return arg;
3145
3146 case COMPONENT_REF:
3147 /* If the thing being referenced is not a field, then it is
3148 something language specific. */
3149 gcc_assert (TREE_CODE (TREE_OPERAND (arg, 1)) == FIELD_DECL);
3150
3151 /* If we are referencing a bitfield, we can't evaluate an
3152 ADDR_EXPR at compile time and so it isn't a constant. */
3153 if (DECL_BIT_FIELD (TREE_OPERAND (arg, 1)))
3154 return NULL;
3155
3156 return staticp (TREE_OPERAND (arg, 0));
3157
3158 case BIT_FIELD_REF:
3159 return NULL;
3160
3161 case INDIRECT_REF:
3162 return TREE_CONSTANT (TREE_OPERAND (arg, 0)) ? arg : NULL;
3163
3164 case ARRAY_REF:
3165 case ARRAY_RANGE_REF:
3166 if (TREE_CODE (TYPE_SIZE (TREE_TYPE (arg))) == INTEGER_CST
3167 && TREE_CODE (TREE_OPERAND (arg, 1)) == INTEGER_CST)
3168 return staticp (TREE_OPERAND (arg, 0));
3169 else
3170 return NULL;
3171
3172 case COMPOUND_LITERAL_EXPR:
3173 return TREE_STATIC (COMPOUND_LITERAL_EXPR_DECL (arg)) ? arg : NULL;
3174
3175 default:
3176 return NULL;
3177 }
3178 }
3179
3180 \f
3181
3182
3183 /* Return whether OP is a DECL whose address is function-invariant. */
3184
3185 bool
3186 decl_address_invariant_p (const_tree op)
3187 {
3188 /* The conditions below are slightly less strict than the one in
3189 staticp. */
3190
3191 switch (TREE_CODE (op))
3192 {
3193 case PARM_DECL:
3194 case RESULT_DECL:
3195 case LABEL_DECL:
3196 case FUNCTION_DECL:
3197 return true;
3198
3199 case VAR_DECL:
3200 if ((TREE_STATIC (op) || DECL_EXTERNAL (op))
3201 || DECL_THREAD_LOCAL_P (op)
3202 || DECL_CONTEXT (op) == current_function_decl
3203 || decl_function_context (op) == current_function_decl)
3204 return true;
3205 break;
3206
3207 case CONST_DECL:
3208 if ((TREE_STATIC (op) || DECL_EXTERNAL (op))
3209 || decl_function_context (op) == current_function_decl)
3210 return true;
3211 break;
3212
3213 default:
3214 break;
3215 }
3216
3217 return false;
3218 }
3219
3220 /* Return whether OP is a DECL whose address is interprocedural-invariant. */
3221
3222 bool
3223 decl_address_ip_invariant_p (const_tree op)
3224 {
3225 /* The conditions below are slightly less strict than the one in
3226 staticp. */
3227
3228 switch (TREE_CODE (op))
3229 {
3230 case LABEL_DECL:
3231 case FUNCTION_DECL:
3232 case STRING_CST:
3233 return true;
3234
3235 case VAR_DECL:
3236 if (((TREE_STATIC (op) || DECL_EXTERNAL (op))
3237 && !DECL_DLLIMPORT_P (op))
3238 || DECL_THREAD_LOCAL_P (op))
3239 return true;
3240 break;
3241
3242 case CONST_DECL:
3243 if ((TREE_STATIC (op) || DECL_EXTERNAL (op)))
3244 return true;
3245 break;
3246
3247 default:
3248 break;
3249 }
3250
3251 return false;
3252 }
3253
3254
3255 /* Return true if T is function-invariant (internal function, does
3256 not handle arithmetic; that's handled in skip_simple_arithmetic and
3257 tree_invariant_p). */
3258
3259 static bool
3260 tree_invariant_p_1 (tree t)
3261 {
3262 tree op;
3263
3264 if (TREE_CONSTANT (t)
3265 || (TREE_READONLY (t) && !TREE_SIDE_EFFECTS (t)))
3266 return true;
3267
3268 switch (TREE_CODE (t))
3269 {
3270 case SAVE_EXPR:
3271 return true;
3272
3273 case ADDR_EXPR:
3274 op = TREE_OPERAND (t, 0);
3275 while (handled_component_p (op))
3276 {
3277 switch (TREE_CODE (op))
3278 {
3279 case ARRAY_REF:
3280 case ARRAY_RANGE_REF:
3281 if (!tree_invariant_p (TREE_OPERAND (op, 1))
3282 || TREE_OPERAND (op, 2) != NULL_TREE
3283 || TREE_OPERAND (op, 3) != NULL_TREE)
3284 return false;
3285 break;
3286
3287 case COMPONENT_REF:
3288 if (TREE_OPERAND (op, 2) != NULL_TREE)
3289 return false;
3290 break;
3291
3292 default:;
3293 }
3294 op = TREE_OPERAND (op, 0);
3295 }
3296
3297 return CONSTANT_CLASS_P (op) || decl_address_invariant_p (op);
3298
3299 default:
3300 break;
3301 }
3302
3303 return false;
3304 }
3305
3306 /* Return true if T is function-invariant. */
3307
3308 bool
3309 tree_invariant_p (tree t)
3310 {
3311 tree inner = skip_simple_arithmetic (t);
3312 return tree_invariant_p_1 (inner);
3313 }
3314
3315 /* Wrap a SAVE_EXPR around EXPR, if appropriate.
3316 Do this to any expression which may be used in more than one place,
3317 but must be evaluated only once.
3318
3319 Normally, expand_expr would reevaluate the expression each time.
3320 Calling save_expr produces something that is evaluated and recorded
3321 the first time expand_expr is called on it. Subsequent calls to
3322 expand_expr just reuse the recorded value.
3323
3324 The call to expand_expr that generates code that actually computes
3325 the value is the first call *at compile time*. Subsequent calls
3326 *at compile time* generate code to use the saved value.
3327 This produces correct result provided that *at run time* control
3328 always flows through the insns made by the first expand_expr
3329 before reaching the other places where the save_expr was evaluated.
3330 You, the caller of save_expr, must make sure this is so.
3331
3332 Constants, and certain read-only nodes, are returned with no
3333 SAVE_EXPR because that is safe. Expressions containing placeholders
3334 are not touched; see tree.def for an explanation of what these
3335 are used for. */
3336
3337 tree
3338 save_expr (tree expr)
3339 {
3340 tree inner;
3341
3342 /* If the tree evaluates to a constant, then we don't want to hide that
3343 fact (i.e. this allows further folding, and direct checks for constants).
3344 However, a read-only object that has side effects cannot be bypassed.
3345 Since it is no problem to reevaluate literals, we just return the
3346 literal node. */
3347 inner = skip_simple_arithmetic (expr);
3348 if (TREE_CODE (inner) == ERROR_MARK)
3349 return inner;
3350
3351 if (tree_invariant_p_1 (inner))
3352 return expr;
3353
3354 /* If INNER contains a PLACEHOLDER_EXPR, we must evaluate it each time, since
3355 it means that the size or offset of some field of an object depends on
3356 the value within another field.
3357
3358 Note that it must not be the case that EXPR contains both a PLACEHOLDER_EXPR
3359 and some variable since it would then need to be both evaluated once and
3360 evaluated more than once. Front-ends must assure this case cannot
3361 happen by surrounding any such subexpressions in their own SAVE_EXPR
3362 and forcing evaluation at the proper time. */
3363 if (contains_placeholder_p (inner))
3364 return expr;
3365
3366 expr = build1_loc (EXPR_LOCATION (expr), SAVE_EXPR, TREE_TYPE (expr), expr);
3367
3368 /* This expression might be placed ahead of a jump to ensure that the
3369 value was computed on both sides of the jump. So make sure it isn't
3370 eliminated as dead. */
3371 TREE_SIDE_EFFECTS (expr) = 1;
3372 return expr;
3373 }
3374
3375 /* Look inside EXPR into any simple arithmetic operations. Return the
3376 outermost non-arithmetic or non-invariant node. */
3377
3378 tree
3379 skip_simple_arithmetic (tree expr)
3380 {
3381 /* We don't care about whether this can be used as an lvalue in this
3382 context. */
3383 while (TREE_CODE (expr) == NON_LVALUE_EXPR)
3384 expr = TREE_OPERAND (expr, 0);
3385
3386 /* If we have simple operations applied to a SAVE_EXPR or to a SAVE_EXPR and
3387 a constant, it will be more efficient to not make another SAVE_EXPR since
3388 it will allow better simplification and GCSE will be able to merge the
3389 computations if they actually occur. */
3390 while (true)
3391 {
3392 if (UNARY_CLASS_P (expr))
3393 expr = TREE_OPERAND (expr, 0);
3394 else if (BINARY_CLASS_P (expr))
3395 {
3396 if (tree_invariant_p (TREE_OPERAND (expr, 1)))
3397 expr = TREE_OPERAND (expr, 0);
3398 else if (tree_invariant_p (TREE_OPERAND (expr, 0)))
3399 expr = TREE_OPERAND (expr, 1);
3400 else
3401 break;
3402 }
3403 else
3404 break;
3405 }
3406
3407 return expr;
3408 }
3409
3410 /* Look inside EXPR into simple arithmetic operations involving constants.
3411 Return the outermost non-arithmetic or non-constant node. */
3412
3413 tree
3414 skip_simple_constant_arithmetic (tree expr)
3415 {
3416 while (TREE_CODE (expr) == NON_LVALUE_EXPR)
3417 expr = TREE_OPERAND (expr, 0);
3418
3419 while (true)
3420 {
3421 if (UNARY_CLASS_P (expr))
3422 expr = TREE_OPERAND (expr, 0);
3423 else if (BINARY_CLASS_P (expr))
3424 {
3425 if (TREE_CONSTANT (TREE_OPERAND (expr, 1)))
3426 expr = TREE_OPERAND (expr, 0);
3427 else if (TREE_CONSTANT (TREE_OPERAND (expr, 0)))
3428 expr = TREE_OPERAND (expr, 1);
3429 else
3430 break;
3431 }
3432 else
3433 break;
3434 }
3435
3436 return expr;
3437 }
3438
3439 /* Return which tree structure is used by T. */
3440
3441 enum tree_node_structure_enum
3442 tree_node_structure (const_tree t)
3443 {
3444 const enum tree_code code = TREE_CODE (t);
3445 return tree_node_structure_for_code (code);
3446 }
3447
3448 /* Set various status flags when building a CALL_EXPR object T. */
3449
3450 static void
3451 process_call_operands (tree t)
3452 {
3453 bool side_effects = TREE_SIDE_EFFECTS (t);
3454 bool read_only = false;
3455 int i = call_expr_flags (t);
3456
3457 /* Calls have side-effects, except those to const or pure functions. */
3458 if ((i & ECF_LOOPING_CONST_OR_PURE) || !(i & (ECF_CONST | ECF_PURE)))
3459 side_effects = true;
3460 /* Propagate TREE_READONLY of arguments for const functions. */
3461 if (i & ECF_CONST)
3462 read_only = true;
3463
3464 if (!side_effects || read_only)
3465 for (i = 1; i < TREE_OPERAND_LENGTH (t); i++)
3466 {
3467 tree op = TREE_OPERAND (t, i);
3468 if (op && TREE_SIDE_EFFECTS (op))
3469 side_effects = true;
3470 if (op && !TREE_READONLY (op) && !CONSTANT_CLASS_P (op))
3471 read_only = false;
3472 }
3473
3474 TREE_SIDE_EFFECTS (t) = side_effects;
3475 TREE_READONLY (t) = read_only;
3476 }
3477 \f
3478 /* Return true if EXP contains a PLACEHOLDER_EXPR, i.e. if it represents a
3479 size or offset that depends on a field within a record. */
3480
3481 bool
3482 contains_placeholder_p (const_tree exp)
3483 {
3484 enum tree_code code;
3485
3486 if (!exp)
3487 return 0;
3488
3489 code = TREE_CODE (exp);
3490 if (code == PLACEHOLDER_EXPR)
3491 return 1;
3492
3493 switch (TREE_CODE_CLASS (code))
3494 {
3495 case tcc_reference:
3496 /* Don't look at any PLACEHOLDER_EXPRs that might be in index or bit
3497 position computations since they will be converted into a
3498 WITH_RECORD_EXPR involving the reference, which will assume
3499 here will be valid. */
3500 return CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 0));
3501
3502 case tcc_exceptional:
3503 if (code == TREE_LIST)
3504 return (CONTAINS_PLACEHOLDER_P (TREE_VALUE (exp))
3505 || CONTAINS_PLACEHOLDER_P (TREE_CHAIN (exp)));
3506 break;
3507
3508 case tcc_unary:
3509 case tcc_binary:
3510 case tcc_comparison:
3511 case tcc_expression:
3512 switch (code)
3513 {
3514 case COMPOUND_EXPR:
3515 /* Ignoring the first operand isn't quite right, but works best. */
3516 return CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 1));
3517
3518 case COND_EXPR:
3519 return (CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 0))
3520 || CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 1))
3521 || CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 2)));
3522
3523 case SAVE_EXPR:
3524 /* The save_expr function never wraps anything containing
3525 a PLACEHOLDER_EXPR. */
3526 return 0;
3527
3528 default:
3529 break;
3530 }
3531
3532 switch (TREE_CODE_LENGTH (code))
3533 {
3534 case 1:
3535 return CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 0));
3536 case 2:
3537 return (CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 0))
3538 || CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 1)));
3539 default:
3540 return 0;
3541 }
3542
3543 case tcc_vl_exp:
3544 switch (code)
3545 {
3546 case CALL_EXPR:
3547 {
3548 const_tree arg;
3549 const_call_expr_arg_iterator iter;
3550 FOR_EACH_CONST_CALL_EXPR_ARG (arg, iter, exp)
3551 if (CONTAINS_PLACEHOLDER_P (arg))
3552 return 1;
3553 return 0;
3554 }
3555 default:
3556 return 0;
3557 }
3558
3559 default:
3560 return 0;
3561 }
3562 return 0;
3563 }
3564
3565 /* Return true if any part of the structure of TYPE involves a PLACEHOLDER_EXPR
3566 directly. This includes size, bounds, qualifiers (for QUAL_UNION_TYPE) and
3567 field positions. */
3568
3569 static bool
3570 type_contains_placeholder_1 (const_tree type)
3571 {
3572 /* If the size contains a placeholder or the parent type (component type in
3573 the case of arrays) type involves a placeholder, this type does. */
3574 if (CONTAINS_PLACEHOLDER_P (TYPE_SIZE (type))
3575 || CONTAINS_PLACEHOLDER_P (TYPE_SIZE_UNIT (type))
3576 || (!POINTER_TYPE_P (type)
3577 && TREE_TYPE (type)
3578 && type_contains_placeholder_p (TREE_TYPE (type))))
3579 return true;
3580
3581 /* Now do type-specific checks. Note that the last part of the check above
3582 greatly limits what we have to do below. */
3583 switch (TREE_CODE (type))
3584 {
3585 case VOID_TYPE:
3586 case POINTER_BOUNDS_TYPE:
3587 case COMPLEX_TYPE:
3588 case ENUMERAL_TYPE:
3589 case BOOLEAN_TYPE:
3590 case POINTER_TYPE:
3591 case OFFSET_TYPE:
3592 case REFERENCE_TYPE:
3593 case METHOD_TYPE:
3594 case FUNCTION_TYPE:
3595 case VECTOR_TYPE:
3596 case NULLPTR_TYPE:
3597 return false;
3598
3599 case INTEGER_TYPE:
3600 case REAL_TYPE:
3601 case FIXED_POINT_TYPE:
3602 /* Here we just check the bounds. */
3603 return (CONTAINS_PLACEHOLDER_P (TYPE_MIN_VALUE (type))
3604 || CONTAINS_PLACEHOLDER_P (TYPE_MAX_VALUE (type)));
3605
3606 case ARRAY_TYPE:
3607 /* We have already checked the component type above, so just check
3608 the domain type. Flexible array members have a null domain. */
3609 return TYPE_DOMAIN (type) ?
3610 type_contains_placeholder_p (TYPE_DOMAIN (type)) : false;
3611
3612 case RECORD_TYPE:
3613 case UNION_TYPE:
3614 case QUAL_UNION_TYPE:
3615 {
3616 tree field;
3617
3618 for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
3619 if (TREE_CODE (field) == FIELD_DECL
3620 && (CONTAINS_PLACEHOLDER_P (DECL_FIELD_OFFSET (field))
3621 || (TREE_CODE (type) == QUAL_UNION_TYPE
3622 && CONTAINS_PLACEHOLDER_P (DECL_QUALIFIER (field)))
3623 || type_contains_placeholder_p (TREE_TYPE (field))))
3624 return true;
3625
3626 return false;
3627 }
3628
3629 default:
3630 gcc_unreachable ();
3631 }
3632 }
3633
3634 /* Wrapper around above function used to cache its result. */
3635
3636 bool
3637 type_contains_placeholder_p (tree type)
3638 {
3639 bool result;
3640
3641 /* If the contains_placeholder_bits field has been initialized,
3642 then we know the answer. */
3643 if (TYPE_CONTAINS_PLACEHOLDER_INTERNAL (type) > 0)
3644 return TYPE_CONTAINS_PLACEHOLDER_INTERNAL (type) - 1;
3645
3646 /* Indicate that we've seen this type node, and the answer is false.
3647 This is what we want to return if we run into recursion via fields. */
3648 TYPE_CONTAINS_PLACEHOLDER_INTERNAL (type) = 1;
3649
3650 /* Compute the real value. */
3651 result = type_contains_placeholder_1 (type);
3652
3653 /* Store the real value. */
3654 TYPE_CONTAINS_PLACEHOLDER_INTERNAL (type) = result + 1;
3655
3656 return result;
3657 }
3658 \f
3659 /* Push tree EXP onto vector QUEUE if it is not already present. */
3660
3661 static void
3662 push_without_duplicates (tree exp, vec<tree> *queue)
3663 {
3664 unsigned int i;
3665 tree iter;
3666
3667 FOR_EACH_VEC_ELT (*queue, i, iter)
3668 if (simple_cst_equal (iter, exp) == 1)
3669 break;
3670
3671 if (!iter)
3672 queue->safe_push (exp);
3673 }
3674
3675 /* Given a tree EXP, find all occurrences of references to fields
3676 in a PLACEHOLDER_EXPR and place them in vector REFS without
3677 duplicates. Also record VAR_DECLs and CONST_DECLs. Note that
3678 we assume here that EXP contains only arithmetic expressions
3679 or CALL_EXPRs with PLACEHOLDER_EXPRs occurring only in their
3680 argument list. */
3681
3682 void
3683 find_placeholder_in_expr (tree exp, vec<tree> *refs)
3684 {
3685 enum tree_code code = TREE_CODE (exp);
3686 tree inner;
3687 int i;
3688
3689 /* We handle TREE_LIST and COMPONENT_REF separately. */
3690 if (code == TREE_LIST)
3691 {
3692 FIND_PLACEHOLDER_IN_EXPR (TREE_CHAIN (exp), refs);
3693 FIND_PLACEHOLDER_IN_EXPR (TREE_VALUE (exp), refs);
3694 }
3695 else if (code == COMPONENT_REF)
3696 {
3697 for (inner = TREE_OPERAND (exp, 0);
3698 REFERENCE_CLASS_P (inner);
3699 inner = TREE_OPERAND (inner, 0))
3700 ;
3701
3702 if (TREE_CODE (inner) == PLACEHOLDER_EXPR)
3703 push_without_duplicates (exp, refs);
3704 else
3705 FIND_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 0), refs);
3706 }
3707 else
3708 switch (TREE_CODE_CLASS (code))
3709 {
3710 case tcc_constant:
3711 break;
3712
3713 case tcc_declaration:
3714 /* Variables allocated to static storage can stay. */
3715 if (!TREE_STATIC (exp))
3716 push_without_duplicates (exp, refs);
3717 break;
3718
3719 case tcc_expression:
3720 /* This is the pattern built in ada/make_aligning_type. */
3721 if (code == ADDR_EXPR
3722 && TREE_CODE (TREE_OPERAND (exp, 0)) == PLACEHOLDER_EXPR)
3723 {
3724 push_without_duplicates (exp, refs);
3725 break;
3726 }
3727
3728 /* Fall through. */
3729
3730 case tcc_exceptional:
3731 case tcc_unary:
3732 case tcc_binary:
3733 case tcc_comparison:
3734 case tcc_reference:
3735 for (i = 0; i < TREE_CODE_LENGTH (code); i++)
3736 FIND_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, i), refs);
3737 break;
3738
3739 case tcc_vl_exp:
3740 for (i = 1; i < TREE_OPERAND_LENGTH (exp); i++)
3741 FIND_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, i), refs);
3742 break;
3743
3744 default:
3745 gcc_unreachable ();
3746 }
3747 }
3748
3749 /* Given a tree EXP, a FIELD_DECL F, and a replacement value R,
3750 return a tree with all occurrences of references to F in a
3751 PLACEHOLDER_EXPR replaced by R. Also handle VAR_DECLs and
3752 CONST_DECLs. Note that we assume here that EXP contains only
3753 arithmetic expressions or CALL_EXPRs with PLACEHOLDER_EXPRs
3754 occurring only in their argument list. */
3755
3756 tree
3757 substitute_in_expr (tree exp, tree f, tree r)
3758 {
3759 enum tree_code code = TREE_CODE (exp);
3760 tree op0, op1, op2, op3;
3761 tree new_tree;
3762
3763 /* We handle TREE_LIST and COMPONENT_REF separately. */
3764 if (code == TREE_LIST)
3765 {
3766 op0 = SUBSTITUTE_IN_EXPR (TREE_CHAIN (exp), f, r);
3767 op1 = SUBSTITUTE_IN_EXPR (TREE_VALUE (exp), f, r);
3768 if (op0 == TREE_CHAIN (exp) && op1 == TREE_VALUE (exp))
3769 return exp;
3770
3771 return tree_cons (TREE_PURPOSE (exp), op1, op0);
3772 }
3773 else if (code == COMPONENT_REF)
3774 {
3775 tree inner;
3776
3777 /* If this expression is getting a value from a PLACEHOLDER_EXPR
3778 and it is the right field, replace it with R. */
3779 for (inner = TREE_OPERAND (exp, 0);
3780 REFERENCE_CLASS_P (inner);
3781 inner = TREE_OPERAND (inner, 0))
3782 ;
3783
3784 /* The field. */
3785 op1 = TREE_OPERAND (exp, 1);
3786
3787 if (TREE_CODE (inner) == PLACEHOLDER_EXPR && op1 == f)
3788 return r;
3789
3790 /* If this expression hasn't been completed let, leave it alone. */
3791 if (TREE_CODE (inner) == PLACEHOLDER_EXPR && !TREE_TYPE (inner))
3792 return exp;
3793
3794 op0 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 0), f, r);
3795 if (op0 == TREE_OPERAND (exp, 0))
3796 return exp;
3797
3798 new_tree
3799 = fold_build3 (COMPONENT_REF, TREE_TYPE (exp), op0, op1, NULL_TREE);
3800 }
3801 else
3802 switch (TREE_CODE_CLASS (code))
3803 {
3804 case tcc_constant:
3805 return exp;
3806
3807 case tcc_declaration:
3808 if (exp == f)
3809 return r;
3810 else
3811 return exp;
3812
3813 case tcc_expression:
3814 if (exp == f)
3815 return r;
3816
3817 /* Fall through. */
3818
3819 case tcc_exceptional:
3820 case tcc_unary:
3821 case tcc_binary:
3822 case tcc_comparison:
3823 case tcc_reference:
3824 switch (TREE_CODE_LENGTH (code))
3825 {
3826 case 0:
3827 return exp;
3828
3829 case 1:
3830 op0 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 0), f, r);
3831 if (op0 == TREE_OPERAND (exp, 0))
3832 return exp;
3833
3834 new_tree = fold_build1 (code, TREE_TYPE (exp), op0);
3835 break;
3836
3837 case 2:
3838 op0 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 0), f, r);
3839 op1 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 1), f, r);
3840
3841 if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1))
3842 return exp;
3843
3844 new_tree = fold_build2 (code, TREE_TYPE (exp), op0, op1);
3845 break;
3846
3847 case 3:
3848 op0 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 0), f, r);
3849 op1 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 1), f, r);
3850 op2 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 2), f, r);
3851
3852 if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1)
3853 && op2 == TREE_OPERAND (exp, 2))
3854 return exp;
3855
3856 new_tree = fold_build3 (code, TREE_TYPE (exp), op0, op1, op2);
3857 break;
3858
3859 case 4:
3860 op0 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 0), f, r);
3861 op1 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 1), f, r);
3862 op2 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 2), f, r);
3863 op3 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 3), f, r);
3864
3865 if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1)
3866 && op2 == TREE_OPERAND (exp, 2)
3867 && op3 == TREE_OPERAND (exp, 3))
3868 return exp;
3869
3870 new_tree
3871 = fold (build4 (code, TREE_TYPE (exp), op0, op1, op2, op3));
3872 break;
3873
3874 default:
3875 gcc_unreachable ();
3876 }
3877 break;
3878
3879 case tcc_vl_exp:
3880 {
3881 int i;
3882
3883 new_tree = NULL_TREE;
3884
3885 /* If we are trying to replace F with a constant or with another
3886 instance of one of the arguments of the call, inline back
3887 functions which do nothing else than computing a value from
3888 the arguments they are passed. This makes it possible to
3889 fold partially or entirely the replacement expression. */
3890 if (code == CALL_EXPR)
3891 {
3892 bool maybe_inline = false;
3893 if (CONSTANT_CLASS_P (r))
3894 maybe_inline = true;
3895 else
3896 for (i = 3; i < TREE_OPERAND_LENGTH (exp); i++)
3897 if (operand_equal_p (TREE_OPERAND (exp, i), r, 0))
3898 {
3899 maybe_inline = true;
3900 break;
3901 }
3902 if (maybe_inline)
3903 {
3904 tree t = maybe_inline_call_in_expr (exp);
3905 if (t)
3906 return SUBSTITUTE_IN_EXPR (t, f, r);
3907 }
3908 }
3909
3910 for (i = 1; i < TREE_OPERAND_LENGTH (exp); i++)
3911 {
3912 tree op = TREE_OPERAND (exp, i);
3913 tree new_op = SUBSTITUTE_IN_EXPR (op, f, r);
3914 if (new_op != op)
3915 {
3916 if (!new_tree)
3917 new_tree = copy_node (exp);
3918 TREE_OPERAND (new_tree, i) = new_op;
3919 }
3920 }
3921
3922 if (new_tree)
3923 {
3924 new_tree = fold (new_tree);
3925 if (TREE_CODE (new_tree) == CALL_EXPR)
3926 process_call_operands (new_tree);
3927 }
3928 else
3929 return exp;
3930 }
3931 break;
3932
3933 default:
3934 gcc_unreachable ();
3935 }
3936
3937 TREE_READONLY (new_tree) |= TREE_READONLY (exp);
3938
3939 if (code == INDIRECT_REF || code == ARRAY_REF || code == ARRAY_RANGE_REF)
3940 TREE_THIS_NOTRAP (new_tree) |= TREE_THIS_NOTRAP (exp);
3941
3942 return new_tree;
3943 }
3944
3945 /* Similar, but look for a PLACEHOLDER_EXPR in EXP and find a replacement
3946 for it within OBJ, a tree that is an object or a chain of references. */
3947
3948 tree
3949 substitute_placeholder_in_expr (tree exp, tree obj)
3950 {
3951 enum tree_code code = TREE_CODE (exp);
3952 tree op0, op1, op2, op3;
3953 tree new_tree;
3954
3955 /* If this is a PLACEHOLDER_EXPR, see if we find a corresponding type
3956 in the chain of OBJ. */
3957 if (code == PLACEHOLDER_EXPR)
3958 {
3959 tree need_type = TYPE_MAIN_VARIANT (TREE_TYPE (exp));
3960 tree elt;
3961
3962 for (elt = obj; elt != 0;
3963 elt = ((TREE_CODE (elt) == COMPOUND_EXPR
3964 || TREE_CODE (elt) == COND_EXPR)
3965 ? TREE_OPERAND (elt, 1)
3966 : (REFERENCE_CLASS_P (elt)
3967 || UNARY_CLASS_P (elt)
3968 || BINARY_CLASS_P (elt)
3969 || VL_EXP_CLASS_P (elt)
3970 || EXPRESSION_CLASS_P (elt))
3971 ? TREE_OPERAND (elt, 0) : 0))
3972 if (TYPE_MAIN_VARIANT (TREE_TYPE (elt)) == need_type)
3973 return elt;
3974
3975 for (elt = obj; elt != 0;
3976 elt = ((TREE_CODE (elt) == COMPOUND_EXPR
3977 || TREE_CODE (elt) == COND_EXPR)
3978 ? TREE_OPERAND (elt, 1)
3979 : (REFERENCE_CLASS_P (elt)
3980 || UNARY_CLASS_P (elt)
3981 || BINARY_CLASS_P (elt)
3982 || VL_EXP_CLASS_P (elt)
3983 || EXPRESSION_CLASS_P (elt))
3984 ? TREE_OPERAND (elt, 0) : 0))
3985 if (POINTER_TYPE_P (TREE_TYPE (elt))
3986 && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (elt)))
3987 == need_type))
3988 return fold_build1 (INDIRECT_REF, need_type, elt);
3989
3990 /* If we didn't find it, return the original PLACEHOLDER_EXPR. If it
3991 survives until RTL generation, there will be an error. */
3992 return exp;
3993 }
3994
3995 /* TREE_LIST is special because we need to look at TREE_VALUE
3996 and TREE_CHAIN, not TREE_OPERANDS. */
3997 else if (code == TREE_LIST)
3998 {
3999 op0 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_CHAIN (exp), obj);
4000 op1 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_VALUE (exp), obj);
4001 if (op0 == TREE_CHAIN (exp) && op1 == TREE_VALUE (exp))
4002 return exp;
4003
4004 return tree_cons (TREE_PURPOSE (exp), op1, op0);
4005 }
4006 else
4007 switch (TREE_CODE_CLASS (code))
4008 {
4009 case tcc_constant:
4010 case tcc_declaration:
4011 return exp;
4012
4013 case tcc_exceptional:
4014 case tcc_unary:
4015 case tcc_binary:
4016 case tcc_comparison:
4017 case tcc_expression:
4018 case tcc_reference:
4019 case tcc_statement:
4020 switch (TREE_CODE_LENGTH (code))
4021 {
4022 case 0:
4023 return exp;
4024
4025 case 1:
4026 op0 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 0), obj);
4027 if (op0 == TREE_OPERAND (exp, 0))
4028 return exp;
4029
4030 new_tree = fold_build1 (code, TREE_TYPE (exp), op0);
4031 break;
4032
4033 case 2:
4034 op0 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 0), obj);
4035 op1 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 1), obj);
4036
4037 if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1))
4038 return exp;
4039
4040 new_tree = fold_build2 (code, TREE_TYPE (exp), op0, op1);
4041 break;
4042
4043 case 3:
4044 op0 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 0), obj);
4045 op1 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 1), obj);
4046 op2 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 2), obj);
4047
4048 if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1)
4049 && op2 == TREE_OPERAND (exp, 2))
4050 return exp;
4051
4052 new_tree = fold_build3 (code, TREE_TYPE (exp), op0, op1, op2);
4053 break;
4054
4055 case 4:
4056 op0 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 0), obj);
4057 op1 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 1), obj);
4058 op2 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 2), obj);
4059 op3 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 3), obj);
4060
4061 if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1)
4062 && op2 == TREE_OPERAND (exp, 2)
4063 && op3 == TREE_OPERAND (exp, 3))
4064 return exp;
4065
4066 new_tree
4067 = fold (build4 (code, TREE_TYPE (exp), op0, op1, op2, op3));
4068 break;
4069
4070 default:
4071 gcc_unreachable ();
4072 }
4073 break;
4074
4075 case tcc_vl_exp:
4076 {
4077 int i;
4078
4079 new_tree = NULL_TREE;
4080
4081 for (i = 1; i < TREE_OPERAND_LENGTH (exp); i++)
4082 {
4083 tree op = TREE_OPERAND (exp, i);
4084 tree new_op = SUBSTITUTE_PLACEHOLDER_IN_EXPR (op, obj);
4085 if (new_op != op)
4086 {
4087 if (!new_tree)
4088 new_tree = copy_node (exp);
4089 TREE_OPERAND (new_tree, i) = new_op;
4090 }
4091 }
4092
4093 if (new_tree)
4094 {
4095 new_tree = fold (new_tree);
4096 if (TREE_CODE (new_tree) == CALL_EXPR)
4097 process_call_operands (new_tree);
4098 }
4099 else
4100 return exp;
4101 }
4102 break;
4103
4104 default:
4105 gcc_unreachable ();
4106 }
4107
4108 TREE_READONLY (new_tree) |= TREE_READONLY (exp);
4109
4110 if (code == INDIRECT_REF || code == ARRAY_REF || code == ARRAY_RANGE_REF)
4111 TREE_THIS_NOTRAP (new_tree) |= TREE_THIS_NOTRAP (exp);
4112
4113 return new_tree;
4114 }
4115 \f
4116
4117 /* Subroutine of stabilize_reference; this is called for subtrees of
4118 references. Any expression with side-effects must be put in a SAVE_EXPR
4119 to ensure that it is only evaluated once.
4120
4121 We don't put SAVE_EXPR nodes around everything, because assigning very
4122 simple expressions to temporaries causes us to miss good opportunities
4123 for optimizations. Among other things, the opportunity to fold in the
4124 addition of a constant into an addressing mode often gets lost, e.g.
4125 "y[i+1] += x;". In general, we take the approach that we should not make
4126 an assignment unless we are forced into it - i.e., that any non-side effect
4127 operator should be allowed, and that cse should take care of coalescing
4128 multiple utterances of the same expression should that prove fruitful. */
4129
4130 static tree
4131 stabilize_reference_1 (tree e)
4132 {
4133 tree result;
4134 enum tree_code code = TREE_CODE (e);
4135
4136 /* We cannot ignore const expressions because it might be a reference
4137 to a const array but whose index contains side-effects. But we can
4138 ignore things that are actual constant or that already have been
4139 handled by this function. */
4140
4141 if (tree_invariant_p (e))
4142 return e;
4143
4144 switch (TREE_CODE_CLASS (code))
4145 {
4146 case tcc_exceptional:
4147 case tcc_type:
4148 case tcc_declaration:
4149 case tcc_comparison:
4150 case tcc_statement:
4151 case tcc_expression:
4152 case tcc_reference:
4153 case tcc_vl_exp:
4154 /* If the expression has side-effects, then encase it in a SAVE_EXPR
4155 so that it will only be evaluated once. */
4156 /* The reference (r) and comparison (<) classes could be handled as
4157 below, but it is generally faster to only evaluate them once. */
4158 if (TREE_SIDE_EFFECTS (e))
4159 return save_expr (e);
4160 return e;
4161
4162 case tcc_constant:
4163 /* Constants need no processing. In fact, we should never reach
4164 here. */
4165 return e;
4166
4167 case tcc_binary:
4168 /* Division is slow and tends to be compiled with jumps,
4169 especially the division by powers of 2 that is often
4170 found inside of an array reference. So do it just once. */
4171 if (code == TRUNC_DIV_EXPR || code == TRUNC_MOD_EXPR
4172 || code == FLOOR_DIV_EXPR || code == FLOOR_MOD_EXPR
4173 || code == CEIL_DIV_EXPR || code == CEIL_MOD_EXPR
4174 || code == ROUND_DIV_EXPR || code == ROUND_MOD_EXPR)
4175 return save_expr (e);
4176 /* Recursively stabilize each operand. */
4177 result = build_nt (code, stabilize_reference_1 (TREE_OPERAND (e, 0)),
4178 stabilize_reference_1 (TREE_OPERAND (e, 1)));
4179 break;
4180
4181 case tcc_unary:
4182 /* Recursively stabilize each operand. */
4183 result = build_nt (code, stabilize_reference_1 (TREE_OPERAND (e, 0)));
4184 break;
4185
4186 default:
4187 gcc_unreachable ();
4188 }
4189
4190 TREE_TYPE (result) = TREE_TYPE (e);
4191 TREE_READONLY (result) = TREE_READONLY (e);
4192 TREE_SIDE_EFFECTS (result) = TREE_SIDE_EFFECTS (e);
4193 TREE_THIS_VOLATILE (result) = TREE_THIS_VOLATILE (e);
4194
4195 return result;
4196 }
4197
4198 /* Stabilize a reference so that we can use it any number of times
4199 without causing its operands to be evaluated more than once.
4200 Returns the stabilized reference. This works by means of save_expr,
4201 so see the caveats in the comments about save_expr.
4202
4203 Also allows conversion expressions whose operands are references.
4204 Any other kind of expression is returned unchanged. */
4205
4206 tree
4207 stabilize_reference (tree ref)
4208 {
4209 tree result;
4210 enum tree_code code = TREE_CODE (ref);
4211
4212 switch (code)
4213 {
4214 case VAR_DECL:
4215 case PARM_DECL:
4216 case RESULT_DECL:
4217 /* No action is needed in this case. */
4218 return ref;
4219
4220 CASE_CONVERT:
4221 case FLOAT_EXPR:
4222 case FIX_TRUNC_EXPR:
4223 result = build_nt (code, stabilize_reference (TREE_OPERAND (ref, 0)));
4224 break;
4225
4226 case INDIRECT_REF:
4227 result = build_nt (INDIRECT_REF,
4228 stabilize_reference_1 (TREE_OPERAND (ref, 0)));
4229 break;
4230
4231 case COMPONENT_REF:
4232 result = build_nt (COMPONENT_REF,
4233 stabilize_reference (TREE_OPERAND (ref, 0)),
4234 TREE_OPERAND (ref, 1), NULL_TREE);
4235 break;
4236
4237 case BIT_FIELD_REF:
4238 result = build_nt (BIT_FIELD_REF,
4239 stabilize_reference (TREE_OPERAND (ref, 0)),
4240 TREE_OPERAND (ref, 1), TREE_OPERAND (ref, 2));
4241 REF_REVERSE_STORAGE_ORDER (result) = REF_REVERSE_STORAGE_ORDER (ref);
4242 break;
4243
4244 case ARRAY_REF:
4245 result = build_nt (ARRAY_REF,
4246 stabilize_reference (TREE_OPERAND (ref, 0)),
4247 stabilize_reference_1 (TREE_OPERAND (ref, 1)),
4248 TREE_OPERAND (ref, 2), TREE_OPERAND (ref, 3));
4249 break;
4250
4251 case ARRAY_RANGE_REF:
4252 result = build_nt (ARRAY_RANGE_REF,
4253 stabilize_reference (TREE_OPERAND (ref, 0)),
4254 stabilize_reference_1 (TREE_OPERAND (ref, 1)),
4255 TREE_OPERAND (ref, 2), TREE_OPERAND (ref, 3));
4256 break;
4257
4258 case COMPOUND_EXPR:
4259 /* We cannot wrap the first expression in a SAVE_EXPR, as then
4260 it wouldn't be ignored. This matters when dealing with
4261 volatiles. */
4262 return stabilize_reference_1 (ref);
4263
4264 /* If arg isn't a kind of lvalue we recognize, make no change.
4265 Caller should recognize the error for an invalid lvalue. */
4266 default:
4267 return ref;
4268
4269 case ERROR_MARK:
4270 return error_mark_node;
4271 }
4272
4273 TREE_TYPE (result) = TREE_TYPE (ref);
4274 TREE_READONLY (result) = TREE_READONLY (ref);
4275 TREE_SIDE_EFFECTS (result) = TREE_SIDE_EFFECTS (ref);
4276 TREE_THIS_VOLATILE (result) = TREE_THIS_VOLATILE (ref);
4277
4278 return result;
4279 }
4280 \f
4281 /* Low-level constructors for expressions. */
4282
4283 /* A helper function for build1 and constant folders. Set TREE_CONSTANT,
4284 and TREE_SIDE_EFFECTS for an ADDR_EXPR. */
4285
4286 void
4287 recompute_tree_invariant_for_addr_expr (tree t)
4288 {
4289 tree node;
4290 bool tc = true, se = false;
4291
4292 gcc_assert (TREE_CODE (t) == ADDR_EXPR);
4293
4294 /* We started out assuming this address is both invariant and constant, but
4295 does not have side effects. Now go down any handled components and see if
4296 any of them involve offsets that are either non-constant or non-invariant.
4297 Also check for side-effects.
4298
4299 ??? Note that this code makes no attempt to deal with the case where
4300 taking the address of something causes a copy due to misalignment. */
4301
4302 #define UPDATE_FLAGS(NODE) \
4303 do { tree _node = (NODE); \
4304 if (_node && !TREE_CONSTANT (_node)) tc = false; \
4305 if (_node && TREE_SIDE_EFFECTS (_node)) se = true; } while (0)
4306
4307 for (node = TREE_OPERAND (t, 0); handled_component_p (node);
4308 node = TREE_OPERAND (node, 0))
4309 {
4310 /* If the first operand doesn't have an ARRAY_TYPE, this is a bogus
4311 array reference (probably made temporarily by the G++ front end),
4312 so ignore all the operands. */
4313 if ((TREE_CODE (node) == ARRAY_REF
4314 || TREE_CODE (node) == ARRAY_RANGE_REF)
4315 && TREE_CODE (TREE_TYPE (TREE_OPERAND (node, 0))) == ARRAY_TYPE)
4316 {
4317 UPDATE_FLAGS (TREE_OPERAND (node, 1));
4318 if (TREE_OPERAND (node, 2))
4319 UPDATE_FLAGS (TREE_OPERAND (node, 2));
4320 if (TREE_OPERAND (node, 3))
4321 UPDATE_FLAGS (TREE_OPERAND (node, 3));
4322 }
4323 /* Likewise, just because this is a COMPONENT_REF doesn't mean we have a
4324 FIELD_DECL, apparently. The G++ front end can put something else
4325 there, at least temporarily. */
4326 else if (TREE_CODE (node) == COMPONENT_REF
4327 && TREE_CODE (TREE_OPERAND (node, 1)) == FIELD_DECL)
4328 {
4329 if (TREE_OPERAND (node, 2))
4330 UPDATE_FLAGS (TREE_OPERAND (node, 2));
4331 }
4332 }
4333
4334 node = lang_hooks.expr_to_decl (node, &tc, &se);
4335
4336 /* Now see what's inside. If it's an INDIRECT_REF, copy our properties from
4337 the address, since &(*a)->b is a form of addition. If it's a constant, the
4338 address is constant too. If it's a decl, its address is constant if the
4339 decl is static. Everything else is not constant and, furthermore,
4340 taking the address of a volatile variable is not volatile. */
4341 if (TREE_CODE (node) == INDIRECT_REF
4342 || TREE_CODE (node) == MEM_REF)
4343 UPDATE_FLAGS (TREE_OPERAND (node, 0));
4344 else if (CONSTANT_CLASS_P (node))
4345 ;
4346 else if (DECL_P (node))
4347 tc &= (staticp (node) != NULL_TREE);
4348 else
4349 {
4350 tc = false;
4351 se |= TREE_SIDE_EFFECTS (node);
4352 }
4353
4354
4355 TREE_CONSTANT (t) = tc;
4356 TREE_SIDE_EFFECTS (t) = se;
4357 #undef UPDATE_FLAGS
4358 }
4359
4360 /* Build an expression of code CODE, data type TYPE, and operands as
4361 specified. Expressions and reference nodes can be created this way.
4362 Constants, decls, types and misc nodes cannot be.
4363
4364 We define 5 non-variadic functions, from 0 to 4 arguments. This is
4365 enough for all extant tree codes. */
4366
4367 tree
4368 build0_stat (enum tree_code code, tree tt MEM_STAT_DECL)
4369 {
4370 tree t;
4371
4372 gcc_assert (TREE_CODE_LENGTH (code) == 0);
4373
4374 t = make_node_stat (code PASS_MEM_STAT);
4375 TREE_TYPE (t) = tt;
4376
4377 return t;
4378 }
4379
4380 tree
4381 build1_stat (enum tree_code code, tree type, tree node MEM_STAT_DECL)
4382 {
4383 int length = sizeof (struct tree_exp);
4384 tree t;
4385
4386 record_node_allocation_statistics (code, length);
4387
4388 gcc_assert (TREE_CODE_LENGTH (code) == 1);
4389
4390 t = ggc_alloc_tree_node_stat (length PASS_MEM_STAT);
4391
4392 memset (t, 0, sizeof (struct tree_common));
4393
4394 TREE_SET_CODE (t, code);
4395
4396 TREE_TYPE (t) = type;
4397 SET_EXPR_LOCATION (t, UNKNOWN_LOCATION);
4398 TREE_OPERAND (t, 0) = node;
4399 if (node && !TYPE_P (node))
4400 {
4401 TREE_SIDE_EFFECTS (t) = TREE_SIDE_EFFECTS (node);
4402 TREE_READONLY (t) = TREE_READONLY (node);
4403 }
4404
4405 if (TREE_CODE_CLASS (code) == tcc_statement)
4406 TREE_SIDE_EFFECTS (t) = 1;
4407 else switch (code)
4408 {
4409 case VA_ARG_EXPR:
4410 /* All of these have side-effects, no matter what their
4411 operands are. */
4412 TREE_SIDE_EFFECTS (t) = 1;
4413 TREE_READONLY (t) = 0;
4414 break;
4415
4416 case INDIRECT_REF:
4417 /* Whether a dereference is readonly has nothing to do with whether
4418 its operand is readonly. */
4419 TREE_READONLY (t) = 0;
4420 break;
4421
4422 case ADDR_EXPR:
4423 if (node)
4424 recompute_tree_invariant_for_addr_expr (t);
4425 break;
4426
4427 default:
4428 if ((TREE_CODE_CLASS (code) == tcc_unary || code == VIEW_CONVERT_EXPR)
4429 && node && !TYPE_P (node)
4430 && TREE_CONSTANT (node))
4431 TREE_CONSTANT (t) = 1;
4432 if (TREE_CODE_CLASS (code) == tcc_reference
4433 && node && TREE_THIS_VOLATILE (node))
4434 TREE_THIS_VOLATILE (t) = 1;
4435 break;
4436 }
4437
4438 return t;
4439 }
4440
4441 #define PROCESS_ARG(N) \
4442 do { \
4443 TREE_OPERAND (t, N) = arg##N; \
4444 if (arg##N &&!TYPE_P (arg##N)) \
4445 { \
4446 if (TREE_SIDE_EFFECTS (arg##N)) \
4447 side_effects = 1; \
4448 if (!TREE_READONLY (arg##N) \
4449 && !CONSTANT_CLASS_P (arg##N)) \
4450 (void) (read_only = 0); \
4451 if (!TREE_CONSTANT (arg##N)) \
4452 (void) (constant = 0); \
4453 } \
4454 } while (0)
4455
4456 tree
4457 build2_stat (enum tree_code code, tree tt, tree arg0, tree arg1 MEM_STAT_DECL)
4458 {
4459 bool constant, read_only, side_effects;
4460 tree t;
4461
4462 gcc_assert (TREE_CODE_LENGTH (code) == 2);
4463
4464 if ((code == MINUS_EXPR || code == PLUS_EXPR || code == MULT_EXPR)
4465 && arg0 && arg1 && tt && POINTER_TYPE_P (tt)
4466 /* When sizetype precision doesn't match that of pointers
4467 we need to be able to build explicit extensions or truncations
4468 of the offset argument. */
4469 && TYPE_PRECISION (sizetype) == TYPE_PRECISION (tt))
4470 gcc_assert (TREE_CODE (arg0) == INTEGER_CST
4471 && TREE_CODE (arg1) == INTEGER_CST);
4472
4473 if (code == POINTER_PLUS_EXPR && arg0 && arg1 && tt)
4474 gcc_assert (POINTER_TYPE_P (tt) && POINTER_TYPE_P (TREE_TYPE (arg0))
4475 && ptrofftype_p (TREE_TYPE (arg1)));
4476
4477 t = make_node_stat (code PASS_MEM_STAT);
4478 TREE_TYPE (t) = tt;
4479
4480 /* Below, we automatically set TREE_SIDE_EFFECTS and TREE_READONLY for the
4481 result based on those same flags for the arguments. But if the
4482 arguments aren't really even `tree' expressions, we shouldn't be trying
4483 to do this. */
4484
4485 /* Expressions without side effects may be constant if their
4486 arguments are as well. */
4487 constant = (TREE_CODE_CLASS (code) == tcc_comparison
4488 || TREE_CODE_CLASS (code) == tcc_binary);
4489 read_only = 1;
4490 side_effects = TREE_SIDE_EFFECTS (t);
4491
4492 PROCESS_ARG (0);
4493 PROCESS_ARG (1);
4494
4495 TREE_SIDE_EFFECTS (t) = side_effects;
4496 if (code == MEM_REF)
4497 {
4498 if (arg0 && TREE_CODE (arg0) == ADDR_EXPR)
4499 {
4500 tree o = TREE_OPERAND (arg0, 0);
4501 TREE_READONLY (t) = TREE_READONLY (o);
4502 TREE_THIS_VOLATILE (t) = TREE_THIS_VOLATILE (o);
4503 }
4504 }
4505 else
4506 {
4507 TREE_READONLY (t) = read_only;
4508 TREE_CONSTANT (t) = constant;
4509 TREE_THIS_VOLATILE (t)
4510 = (TREE_CODE_CLASS (code) == tcc_reference
4511 && arg0 && TREE_THIS_VOLATILE (arg0));
4512 }
4513
4514 return t;
4515 }
4516
4517
4518 tree
4519 build3_stat (enum tree_code code, tree tt, tree arg0, tree arg1,
4520 tree arg2 MEM_STAT_DECL)
4521 {
4522 bool constant, read_only, side_effects;
4523 tree t;
4524
4525 gcc_assert (TREE_CODE_LENGTH (code) == 3);
4526 gcc_assert (TREE_CODE_CLASS (code) != tcc_vl_exp);
4527
4528 t = make_node_stat (code PASS_MEM_STAT);
4529 TREE_TYPE (t) = tt;
4530
4531 read_only = 1;
4532
4533 /* As a special exception, if COND_EXPR has NULL branches, we
4534 assume that it is a gimple statement and always consider
4535 it to have side effects. */
4536 if (code == COND_EXPR
4537 && tt == void_type_node
4538 && arg1 == NULL_TREE
4539 && arg2 == NULL_TREE)
4540 side_effects = true;
4541 else
4542 side_effects = TREE_SIDE_EFFECTS (t);
4543
4544 PROCESS_ARG (0);
4545 PROCESS_ARG (1);
4546 PROCESS_ARG (2);
4547
4548 if (code == COND_EXPR)
4549 TREE_READONLY (t) = read_only;
4550
4551 TREE_SIDE_EFFECTS (t) = side_effects;
4552 TREE_THIS_VOLATILE (t)
4553 = (TREE_CODE_CLASS (code) == tcc_reference
4554 && arg0 && TREE_THIS_VOLATILE (arg0));
4555
4556 return t;
4557 }
4558
4559 tree
4560 build4_stat (enum tree_code code, tree tt, tree arg0, tree arg1,
4561 tree arg2, tree arg3 MEM_STAT_DECL)
4562 {
4563 bool constant, read_only, side_effects;
4564 tree t;
4565
4566 gcc_assert (TREE_CODE_LENGTH (code) == 4);
4567
4568 t = make_node_stat (code PASS_MEM_STAT);
4569 TREE_TYPE (t) = tt;
4570
4571 side_effects = TREE_SIDE_EFFECTS (t);
4572
4573 PROCESS_ARG (0);
4574 PROCESS_ARG (1);
4575 PROCESS_ARG (2);
4576 PROCESS_ARG (3);
4577
4578 TREE_SIDE_EFFECTS (t) = side_effects;
4579 TREE_THIS_VOLATILE (t)
4580 = (TREE_CODE_CLASS (code) == tcc_reference
4581 && arg0 && TREE_THIS_VOLATILE (arg0));
4582
4583 return t;
4584 }
4585
4586 tree
4587 build5_stat (enum tree_code code, tree tt, tree arg0, tree arg1,
4588 tree arg2, tree arg3, tree arg4 MEM_STAT_DECL)
4589 {
4590 bool constant, read_only, side_effects;
4591 tree t;
4592
4593 gcc_assert (TREE_CODE_LENGTH (code) == 5);
4594
4595 t = make_node_stat (code PASS_MEM_STAT);
4596 TREE_TYPE (t) = tt;
4597
4598 side_effects = TREE_SIDE_EFFECTS (t);
4599
4600 PROCESS_ARG (0);
4601 PROCESS_ARG (1);
4602 PROCESS_ARG (2);
4603 PROCESS_ARG (3);
4604 PROCESS_ARG (4);
4605
4606 TREE_SIDE_EFFECTS (t) = side_effects;
4607 if (code == TARGET_MEM_REF)
4608 {
4609 if (arg0 && TREE_CODE (arg0) == ADDR_EXPR)
4610 {
4611 tree o = TREE_OPERAND (arg0, 0);
4612 TREE_READONLY (t) = TREE_READONLY (o);
4613 TREE_THIS_VOLATILE (t) = TREE_THIS_VOLATILE (o);
4614 }
4615 }
4616 else
4617 TREE_THIS_VOLATILE (t)
4618 = (TREE_CODE_CLASS (code) == tcc_reference
4619 && arg0 && TREE_THIS_VOLATILE (arg0));
4620
4621 return t;
4622 }
4623
4624 /* Build a simple MEM_REF tree with the sematics of a plain INDIRECT_REF
4625 on the pointer PTR. */
4626
4627 tree
4628 build_simple_mem_ref_loc (location_t loc, tree ptr)
4629 {
4630 HOST_WIDE_INT offset = 0;
4631 tree ptype = TREE_TYPE (ptr);
4632 tree tem;
4633 /* For convenience allow addresses that collapse to a simple base
4634 and offset. */
4635 if (TREE_CODE (ptr) == ADDR_EXPR
4636 && (handled_component_p (TREE_OPERAND (ptr, 0))
4637 || TREE_CODE (TREE_OPERAND (ptr, 0)) == MEM_REF))
4638 {
4639 ptr = get_addr_base_and_unit_offset (TREE_OPERAND (ptr, 0), &offset);
4640 gcc_assert (ptr);
4641 ptr = build_fold_addr_expr (ptr);
4642 gcc_assert (is_gimple_reg (ptr) || is_gimple_min_invariant (ptr));
4643 }
4644 tem = build2 (MEM_REF, TREE_TYPE (ptype),
4645 ptr, build_int_cst (ptype, offset));
4646 SET_EXPR_LOCATION (tem, loc);
4647 return tem;
4648 }
4649
4650 /* Return the constant offset of a MEM_REF or TARGET_MEM_REF tree T. */
4651
4652 offset_int
4653 mem_ref_offset (const_tree t)
4654 {
4655 return offset_int::from (TREE_OPERAND (t, 1), SIGNED);
4656 }
4657
4658 /* Return an invariant ADDR_EXPR of type TYPE taking the address of BASE
4659 offsetted by OFFSET units. */
4660
4661 tree
4662 build_invariant_address (tree type, tree base, HOST_WIDE_INT offset)
4663 {
4664 tree ref = fold_build2 (MEM_REF, TREE_TYPE (type),
4665 build_fold_addr_expr (base),
4666 build_int_cst (ptr_type_node, offset));
4667 tree addr = build1 (ADDR_EXPR, type, ref);
4668 recompute_tree_invariant_for_addr_expr (addr);
4669 return addr;
4670 }
4671
4672 /* Similar except don't specify the TREE_TYPE
4673 and leave the TREE_SIDE_EFFECTS as 0.
4674 It is permissible for arguments to be null,
4675 or even garbage if their values do not matter. */
4676
4677 tree
4678 build_nt (enum tree_code code, ...)
4679 {
4680 tree t;
4681 int length;
4682 int i;
4683 va_list p;
4684
4685 gcc_assert (TREE_CODE_CLASS (code) != tcc_vl_exp);
4686
4687 va_start (p, code);
4688
4689 t = make_node (code);
4690 length = TREE_CODE_LENGTH (code);
4691
4692 for (i = 0; i < length; i++)
4693 TREE_OPERAND (t, i) = va_arg (p, tree);
4694
4695 va_end (p);
4696 return t;
4697 }
4698
4699 /* Similar to build_nt, but for creating a CALL_EXPR object with a
4700 tree vec. */
4701
4702 tree
4703 build_nt_call_vec (tree fn, vec<tree, va_gc> *args)
4704 {
4705 tree ret, t;
4706 unsigned int ix;
4707
4708 ret = build_vl_exp (CALL_EXPR, vec_safe_length (args) + 3);
4709 CALL_EXPR_FN (ret) = fn;
4710 CALL_EXPR_STATIC_CHAIN (ret) = NULL_TREE;
4711 FOR_EACH_VEC_SAFE_ELT (args, ix, t)
4712 CALL_EXPR_ARG (ret, ix) = t;
4713 return ret;
4714 }
4715 \f
4716 /* Create a DECL_... node of code CODE, name NAME and data type TYPE.
4717 We do NOT enter this node in any sort of symbol table.
4718
4719 LOC is the location of the decl.
4720
4721 layout_decl is used to set up the decl's storage layout.
4722 Other slots are initialized to 0 or null pointers. */
4723
4724 tree
4725 build_decl_stat (location_t loc, enum tree_code code, tree name,
4726 tree type MEM_STAT_DECL)
4727 {
4728 tree t;
4729
4730 t = make_node_stat (code PASS_MEM_STAT);
4731 DECL_SOURCE_LOCATION (t) = loc;
4732
4733 /* if (type == error_mark_node)
4734 type = integer_type_node; */
4735 /* That is not done, deliberately, so that having error_mark_node
4736 as the type can suppress useless errors in the use of this variable. */
4737
4738 DECL_NAME (t) = name;
4739 TREE_TYPE (t) = type;
4740
4741 if (code == VAR_DECL || code == PARM_DECL || code == RESULT_DECL)
4742 layout_decl (t, 0);
4743
4744 return t;
4745 }
4746
4747 /* Builds and returns function declaration with NAME and TYPE. */
4748
4749 tree
4750 build_fn_decl (const char *name, tree type)
4751 {
4752 tree id = get_identifier (name);
4753 tree decl = build_decl (input_location, FUNCTION_DECL, id, type);
4754
4755 DECL_EXTERNAL (decl) = 1;
4756 TREE_PUBLIC (decl) = 1;
4757 DECL_ARTIFICIAL (decl) = 1;
4758 TREE_NOTHROW (decl) = 1;
4759
4760 return decl;
4761 }
4762
4763 vec<tree, va_gc> *all_translation_units;
4764
4765 /* Builds a new translation-unit decl with name NAME, queues it in the
4766 global list of translation-unit decls and returns it. */
4767
4768 tree
4769 build_translation_unit_decl (tree name)
4770 {
4771 tree tu = build_decl (UNKNOWN_LOCATION, TRANSLATION_UNIT_DECL,
4772 name, NULL_TREE);
4773 TRANSLATION_UNIT_LANGUAGE (tu) = lang_hooks.name;
4774 vec_safe_push (all_translation_units, tu);
4775 return tu;
4776 }
4777
4778 \f
4779 /* BLOCK nodes are used to represent the structure of binding contours
4780 and declarations, once those contours have been exited and their contents
4781 compiled. This information is used for outputting debugging info. */
4782
4783 tree
4784 build_block (tree vars, tree subblocks, tree supercontext, tree chain)
4785 {
4786 tree block = make_node (BLOCK);
4787
4788 BLOCK_VARS (block) = vars;
4789 BLOCK_SUBBLOCKS (block) = subblocks;
4790 BLOCK_SUPERCONTEXT (block) = supercontext;
4791 BLOCK_CHAIN (block) = chain;
4792 return block;
4793 }
4794
4795 \f
4796 /* Like SET_EXPR_LOCATION, but make sure the tree can have a location.
4797
4798 LOC is the location to use in tree T. */
4799
4800 void
4801 protected_set_expr_location (tree t, location_t loc)
4802 {
4803 if (CAN_HAVE_LOCATION_P (t))
4804 SET_EXPR_LOCATION (t, loc);
4805 }
4806 \f
4807 /* Return a declaration like DDECL except that its DECL_ATTRIBUTES
4808 is ATTRIBUTE. */
4809
4810 tree
4811 build_decl_attribute_variant (tree ddecl, tree attribute)
4812 {
4813 DECL_ATTRIBUTES (ddecl) = attribute;
4814 return ddecl;
4815 }
4816
4817 /* Return a type like TTYPE except that its TYPE_ATTRIBUTE
4818 is ATTRIBUTE and its qualifiers are QUALS.
4819
4820 Record such modified types already made so we don't make duplicates. */
4821
4822 tree
4823 build_type_attribute_qual_variant (tree ttype, tree attribute, int quals)
4824 {
4825 if (! attribute_list_equal (TYPE_ATTRIBUTES (ttype), attribute))
4826 {
4827 tree ntype;
4828
4829 /* Building a distinct copy of a tagged type is inappropriate; it
4830 causes breakage in code that expects there to be a one-to-one
4831 relationship between a struct and its fields.
4832 build_duplicate_type is another solution (as used in
4833 handle_transparent_union_attribute), but that doesn't play well
4834 with the stronger C++ type identity model. */
4835 if (TREE_CODE (ttype) == RECORD_TYPE
4836 || TREE_CODE (ttype) == UNION_TYPE
4837 || TREE_CODE (ttype) == QUAL_UNION_TYPE
4838 || TREE_CODE (ttype) == ENUMERAL_TYPE)
4839 {
4840 warning (OPT_Wattributes,
4841 "ignoring attributes applied to %qT after definition",
4842 TYPE_MAIN_VARIANT (ttype));
4843 return build_qualified_type (ttype, quals);
4844 }
4845
4846 ttype = build_qualified_type (ttype, TYPE_UNQUALIFIED);
4847 ntype = build_distinct_type_copy (ttype);
4848
4849 TYPE_ATTRIBUTES (ntype) = attribute;
4850
4851 hashval_t hash = type_hash_canon_hash (ntype);
4852 ntype = type_hash_canon (hash, ntype);
4853
4854 /* If the target-dependent attributes make NTYPE different from
4855 its canonical type, we will need to use structural equality
4856 checks for this type. */
4857 if (TYPE_STRUCTURAL_EQUALITY_P (ttype)
4858 || !comp_type_attributes (ntype, ttype))
4859 SET_TYPE_STRUCTURAL_EQUALITY (ntype);
4860 else if (TYPE_CANONICAL (ntype) == ntype)
4861 TYPE_CANONICAL (ntype) = TYPE_CANONICAL (ttype);
4862
4863 ttype = build_qualified_type (ntype, quals);
4864 }
4865 else if (TYPE_QUALS (ttype) != quals)
4866 ttype = build_qualified_type (ttype, quals);
4867
4868 return ttype;
4869 }
4870
4871 /* Check if "omp declare simd" attribute arguments, CLAUSES1 and CLAUSES2, are
4872 the same. */
4873
4874 static bool
4875 omp_declare_simd_clauses_equal (tree clauses1, tree clauses2)
4876 {
4877 tree cl1, cl2;
4878 for (cl1 = clauses1, cl2 = clauses2;
4879 cl1 && cl2;
4880 cl1 = OMP_CLAUSE_CHAIN (cl1), cl2 = OMP_CLAUSE_CHAIN (cl2))
4881 {
4882 if (OMP_CLAUSE_CODE (cl1) != OMP_CLAUSE_CODE (cl2))
4883 return false;
4884 if (OMP_CLAUSE_CODE (cl1) != OMP_CLAUSE_SIMDLEN)
4885 {
4886 if (simple_cst_equal (OMP_CLAUSE_DECL (cl1),
4887 OMP_CLAUSE_DECL (cl2)) != 1)
4888 return false;
4889 }
4890 switch (OMP_CLAUSE_CODE (cl1))
4891 {
4892 case OMP_CLAUSE_ALIGNED:
4893 if (simple_cst_equal (OMP_CLAUSE_ALIGNED_ALIGNMENT (cl1),
4894 OMP_CLAUSE_ALIGNED_ALIGNMENT (cl2)) != 1)
4895 return false;
4896 break;
4897 case OMP_CLAUSE_LINEAR:
4898 if (simple_cst_equal (OMP_CLAUSE_LINEAR_STEP (cl1),
4899 OMP_CLAUSE_LINEAR_STEP (cl2)) != 1)
4900 return false;
4901 break;
4902 case OMP_CLAUSE_SIMDLEN:
4903 if (simple_cst_equal (OMP_CLAUSE_SIMDLEN_EXPR (cl1),
4904 OMP_CLAUSE_SIMDLEN_EXPR (cl2)) != 1)
4905 return false;
4906 default:
4907 break;
4908 }
4909 }
4910 return true;
4911 }
4912
4913 /* Compare two constructor-element-type constants. Return 1 if the lists
4914 are known to be equal; otherwise return 0. */
4915
4916 static bool
4917 simple_cst_list_equal (const_tree l1, const_tree l2)
4918 {
4919 while (l1 != NULL_TREE && l2 != NULL_TREE)
4920 {
4921 if (simple_cst_equal (TREE_VALUE (l1), TREE_VALUE (l2)) != 1)
4922 return false;
4923
4924 l1 = TREE_CHAIN (l1);
4925 l2 = TREE_CHAIN (l2);
4926 }
4927
4928 return l1 == l2;
4929 }
4930
4931 /* Compare two identifier nodes representing attributes. Either one may
4932 be in wrapped __ATTR__ form. Return true if they are the same, false
4933 otherwise. */
4934
4935 static bool
4936 cmp_attrib_identifiers (const_tree attr1, const_tree attr2)
4937 {
4938 /* Make sure we're dealing with IDENTIFIER_NODEs. */
4939 gcc_checking_assert (TREE_CODE (attr1) == IDENTIFIER_NODE
4940 && TREE_CODE (attr2) == IDENTIFIER_NODE);
4941
4942 /* Identifiers can be compared directly for equality. */
4943 if (attr1 == attr2)
4944 return true;
4945
4946 /* If they are not equal, they may still be one in the form
4947 'text' while the other one is in the form '__text__'. TODO:
4948 If we were storing attributes in normalized 'text' form, then
4949 this could all go away and we could take full advantage of
4950 the fact that we're comparing identifiers. :-) */
4951 const size_t attr1_len = IDENTIFIER_LENGTH (attr1);
4952 const size_t attr2_len = IDENTIFIER_LENGTH (attr2);
4953
4954 if (attr2_len == attr1_len + 4)
4955 {
4956 const char *p = IDENTIFIER_POINTER (attr2);
4957 const char *q = IDENTIFIER_POINTER (attr1);
4958 if (p[0] == '_' && p[1] == '_'
4959 && p[attr2_len - 2] == '_' && p[attr2_len - 1] == '_'
4960 && strncmp (q, p + 2, attr1_len) == 0)
4961 return true;;
4962 }
4963 else if (attr2_len + 4 == attr1_len)
4964 {
4965 const char *p = IDENTIFIER_POINTER (attr2);
4966 const char *q = IDENTIFIER_POINTER (attr1);
4967 if (q[0] == '_' && q[1] == '_'
4968 && q[attr1_len - 2] == '_' && q[attr1_len - 1] == '_'
4969 && strncmp (q + 2, p, attr2_len) == 0)
4970 return true;
4971 }
4972
4973 return false;
4974 }
4975
4976 /* Compare two attributes for their value identity. Return true if the
4977 attribute values are known to be equal; otherwise return false. */
4978
4979 bool
4980 attribute_value_equal (const_tree attr1, const_tree attr2)
4981 {
4982 if (TREE_VALUE (attr1) == TREE_VALUE (attr2))
4983 return true;
4984
4985 if (TREE_VALUE (attr1) != NULL_TREE
4986 && TREE_CODE (TREE_VALUE (attr1)) == TREE_LIST
4987 && TREE_VALUE (attr2) != NULL_TREE
4988 && TREE_CODE (TREE_VALUE (attr2)) == TREE_LIST)
4989 {
4990 /* Handle attribute format. */
4991 if (is_attribute_p ("format", get_attribute_name (attr1)))
4992 {
4993 attr1 = TREE_VALUE (attr1);
4994 attr2 = TREE_VALUE (attr2);
4995 /* Compare the archetypes (printf/scanf/strftime/...). */
4996 if (!cmp_attrib_identifiers (TREE_VALUE (attr1),
4997 TREE_VALUE (attr2)))
4998 return false;
4999 /* Archetypes are the same. Compare the rest. */
5000 return (simple_cst_list_equal (TREE_CHAIN (attr1),
5001 TREE_CHAIN (attr2)) == 1);
5002 }
5003 return (simple_cst_list_equal (TREE_VALUE (attr1),
5004 TREE_VALUE (attr2)) == 1);
5005 }
5006
5007 if ((flag_openmp || flag_openmp_simd)
5008 && TREE_VALUE (attr1) && TREE_VALUE (attr2)
5009 && TREE_CODE (TREE_VALUE (attr1)) == OMP_CLAUSE
5010 && TREE_CODE (TREE_VALUE (attr2)) == OMP_CLAUSE)
5011 return omp_declare_simd_clauses_equal (TREE_VALUE (attr1),
5012 TREE_VALUE (attr2));
5013
5014 return (simple_cst_equal (TREE_VALUE (attr1), TREE_VALUE (attr2)) == 1);
5015 }
5016
5017 /* Return 0 if the attributes for two types are incompatible, 1 if they
5018 are compatible, and 2 if they are nearly compatible (which causes a
5019 warning to be generated). */
5020 int
5021 comp_type_attributes (const_tree type1, const_tree type2)
5022 {
5023 const_tree a1 = TYPE_ATTRIBUTES (type1);
5024 const_tree a2 = TYPE_ATTRIBUTES (type2);
5025 const_tree a;
5026
5027 if (a1 == a2)
5028 return 1;
5029 for (a = a1; a != NULL_TREE; a = TREE_CHAIN (a))
5030 {
5031 const struct attribute_spec *as;
5032 const_tree attr;
5033
5034 as = lookup_attribute_spec (get_attribute_name (a));
5035 if (!as || as->affects_type_identity == false)
5036 continue;
5037
5038 attr = lookup_attribute (as->name, CONST_CAST_TREE (a2));
5039 if (!attr || !attribute_value_equal (a, attr))
5040 break;
5041 }
5042 if (!a)
5043 {
5044 for (a = a2; a != NULL_TREE; a = TREE_CHAIN (a))
5045 {
5046 const struct attribute_spec *as;
5047
5048 as = lookup_attribute_spec (get_attribute_name (a));
5049 if (!as || as->affects_type_identity == false)
5050 continue;
5051
5052 if (!lookup_attribute (as->name, CONST_CAST_TREE (a1)))
5053 break;
5054 /* We don't need to compare trees again, as we did this
5055 already in first loop. */
5056 }
5057 /* All types - affecting identity - are equal, so
5058 there is no need to call target hook for comparison. */
5059 if (!a)
5060 return 1;
5061 }
5062 if (lookup_attribute ("transaction_safe", CONST_CAST_TREE (a)))
5063 return 0;
5064 /* As some type combinations - like default calling-convention - might
5065 be compatible, we have to call the target hook to get the final result. */
5066 return targetm.comp_type_attributes (type1, type2);
5067 }
5068
5069 /* Return a type like TTYPE except that its TYPE_ATTRIBUTE
5070 is ATTRIBUTE.
5071
5072 Record such modified types already made so we don't make duplicates. */
5073
5074 tree
5075 build_type_attribute_variant (tree ttype, tree attribute)
5076 {
5077 return build_type_attribute_qual_variant (ttype, attribute,
5078 TYPE_QUALS (ttype));
5079 }
5080
5081
5082 /* Reset the expression *EXPR_P, a size or position.
5083
5084 ??? We could reset all non-constant sizes or positions. But it's cheap
5085 enough to not do so and refrain from adding workarounds to dwarf2out.c.
5086
5087 We need to reset self-referential sizes or positions because they cannot
5088 be gimplified and thus can contain a CALL_EXPR after the gimplification
5089 is finished, which will run afoul of LTO streaming. And they need to be
5090 reset to something essentially dummy but not constant, so as to preserve
5091 the properties of the object they are attached to. */
5092
5093 static inline void
5094 free_lang_data_in_one_sizepos (tree *expr_p)
5095 {
5096 tree expr = *expr_p;
5097 if (CONTAINS_PLACEHOLDER_P (expr))
5098 *expr_p = build0 (PLACEHOLDER_EXPR, TREE_TYPE (expr));
5099 }
5100
5101
5102 /* Reset all the fields in a binfo node BINFO. We only keep
5103 BINFO_VTABLE, which is used by gimple_fold_obj_type_ref. */
5104
5105 static void
5106 free_lang_data_in_binfo (tree binfo)
5107 {
5108 unsigned i;
5109 tree t;
5110
5111 gcc_assert (TREE_CODE (binfo) == TREE_BINFO);
5112
5113 BINFO_VIRTUALS (binfo) = NULL_TREE;
5114 BINFO_BASE_ACCESSES (binfo) = NULL;
5115 BINFO_INHERITANCE_CHAIN (binfo) = NULL_TREE;
5116 BINFO_SUBVTT_INDEX (binfo) = NULL_TREE;
5117
5118 FOR_EACH_VEC_ELT (*BINFO_BASE_BINFOS (binfo), i, t)
5119 free_lang_data_in_binfo (t);
5120 }
5121
5122
5123 /* Reset all language specific information still present in TYPE. */
5124
5125 static void
5126 free_lang_data_in_type (tree type)
5127 {
5128 gcc_assert (TYPE_P (type));
5129
5130 /* Give the FE a chance to remove its own data first. */
5131 lang_hooks.free_lang_data (type);
5132
5133 TREE_LANG_FLAG_0 (type) = 0;
5134 TREE_LANG_FLAG_1 (type) = 0;
5135 TREE_LANG_FLAG_2 (type) = 0;
5136 TREE_LANG_FLAG_3 (type) = 0;
5137 TREE_LANG_FLAG_4 (type) = 0;
5138 TREE_LANG_FLAG_5 (type) = 0;
5139 TREE_LANG_FLAG_6 (type) = 0;
5140
5141 if (TREE_CODE (type) == FUNCTION_TYPE)
5142 {
5143 /* Remove the const and volatile qualifiers from arguments. The
5144 C++ front end removes them, but the C front end does not,
5145 leading to false ODR violation errors when merging two
5146 instances of the same function signature compiled by
5147 different front ends. */
5148 tree p;
5149
5150 for (p = TYPE_ARG_TYPES (type); p; p = TREE_CHAIN (p))
5151 {
5152 tree arg_type = TREE_VALUE (p);
5153
5154 if (TYPE_READONLY (arg_type) || TYPE_VOLATILE (arg_type))
5155 {
5156 int quals = TYPE_QUALS (arg_type)
5157 & ~TYPE_QUAL_CONST
5158 & ~TYPE_QUAL_VOLATILE;
5159 TREE_VALUE (p) = build_qualified_type (arg_type, quals);
5160 free_lang_data_in_type (TREE_VALUE (p));
5161 }
5162 /* C++ FE uses TREE_PURPOSE to store initial values. */
5163 TREE_PURPOSE (p) = NULL;
5164 }
5165 /* Java uses TYPE_MINVAL for TYPE_ARGUMENT_SIGNATURE. */
5166 TYPE_MINVAL (type) = NULL;
5167 }
5168 if (TREE_CODE (type) == METHOD_TYPE)
5169 {
5170 tree p;
5171
5172 for (p = TYPE_ARG_TYPES (type); p; p = TREE_CHAIN (p))
5173 {
5174 /* C++ FE uses TREE_PURPOSE to store initial values. */
5175 TREE_PURPOSE (p) = NULL;
5176 }
5177 /* Java uses TYPE_MINVAL for TYPE_ARGUMENT_SIGNATURE. */
5178 TYPE_MINVAL (type) = NULL;
5179 }
5180
5181 /* Remove members that are not actually FIELD_DECLs from the field
5182 list of an aggregate. These occur in C++. */
5183 if (RECORD_OR_UNION_TYPE_P (type))
5184 {
5185 tree prev, member;
5186
5187 /* Note that TYPE_FIELDS can be shared across distinct
5188 TREE_TYPEs. Therefore, if the first field of TYPE_FIELDS is
5189 to be removed, we cannot set its TREE_CHAIN to NULL.
5190 Otherwise, we would not be able to find all the other fields
5191 in the other instances of this TREE_TYPE.
5192
5193 This was causing an ICE in testsuite/g++.dg/lto/20080915.C. */
5194 prev = NULL_TREE;
5195 member = TYPE_FIELDS (type);
5196 while (member)
5197 {
5198 if (TREE_CODE (member) == FIELD_DECL
5199 || (TREE_CODE (member) == TYPE_DECL
5200 && !DECL_IGNORED_P (member)
5201 && debug_info_level > DINFO_LEVEL_TERSE
5202 && !is_redundant_typedef (member)))
5203 {
5204 if (prev)
5205 TREE_CHAIN (prev) = member;
5206 else
5207 TYPE_FIELDS (type) = member;
5208 prev = member;
5209 }
5210
5211 member = TREE_CHAIN (member);
5212 }
5213
5214 if (prev)
5215 TREE_CHAIN (prev) = NULL_TREE;
5216 else
5217 TYPE_FIELDS (type) = NULL_TREE;
5218
5219 /* FIXME: C FE uses TYPE_VFIELD to record C_TYPE_INCOMPLETE_VARS
5220 and danagle the pointer from time to time. */
5221 if (TYPE_VFIELD (type) && TREE_CODE (TYPE_VFIELD (type)) != FIELD_DECL)
5222 TYPE_VFIELD (type) = NULL_TREE;
5223
5224 /* Remove TYPE_METHODS list. While it would be nice to keep it
5225 to enable ODR warnings about different method lists, doing so
5226 seems to impractically increase size of LTO data streamed.
5227 Keep the information if TYPE_METHODS was non-NULL. This is used
5228 by function.c and pretty printers. */
5229 if (TYPE_METHODS (type))
5230 TYPE_METHODS (type) = error_mark_node;
5231 if (TYPE_BINFO (type))
5232 {
5233 free_lang_data_in_binfo (TYPE_BINFO (type));
5234 /* We need to preserve link to bases and virtual table for all
5235 polymorphic types to make devirtualization machinery working.
5236 Debug output cares only about bases, but output also
5237 virtual table pointers so merging of -fdevirtualize and
5238 -fno-devirtualize units is easier. */
5239 if ((!BINFO_VTABLE (TYPE_BINFO (type))
5240 || !flag_devirtualize)
5241 && ((!BINFO_N_BASE_BINFOS (TYPE_BINFO (type))
5242 && !BINFO_VTABLE (TYPE_BINFO (type)))
5243 || debug_info_level != DINFO_LEVEL_NONE))
5244 TYPE_BINFO (type) = NULL;
5245 }
5246 }
5247 else
5248 {
5249 /* For non-aggregate types, clear out the language slot (which
5250 overloads TYPE_BINFO). */
5251 TYPE_LANG_SLOT_1 (type) = NULL_TREE;
5252
5253 if (INTEGRAL_TYPE_P (type)
5254 || SCALAR_FLOAT_TYPE_P (type)
5255 || FIXED_POINT_TYPE_P (type))
5256 {
5257 free_lang_data_in_one_sizepos (&TYPE_MIN_VALUE (type));
5258 free_lang_data_in_one_sizepos (&TYPE_MAX_VALUE (type));
5259 }
5260 }
5261
5262 free_lang_data_in_one_sizepos (&TYPE_SIZE (type));
5263 free_lang_data_in_one_sizepos (&TYPE_SIZE_UNIT (type));
5264
5265 if (TYPE_CONTEXT (type)
5266 && TREE_CODE (TYPE_CONTEXT (type)) == BLOCK)
5267 {
5268 tree ctx = TYPE_CONTEXT (type);
5269 do
5270 {
5271 ctx = BLOCK_SUPERCONTEXT (ctx);
5272 }
5273 while (ctx && TREE_CODE (ctx) == BLOCK);
5274 TYPE_CONTEXT (type) = ctx;
5275 }
5276 }
5277
5278
5279 /* Return true if DECL may need an assembler name to be set. */
5280
5281 static inline bool
5282 need_assembler_name_p (tree decl)
5283 {
5284 /* We use DECL_ASSEMBLER_NAME to hold mangled type names for One Definition
5285 Rule merging. This makes type_odr_p to return true on those types during
5286 LTO and by comparing the mangled name, we can say what types are intended
5287 to be equivalent across compilation unit.
5288
5289 We do not store names of type_in_anonymous_namespace_p.
5290
5291 Record, union and enumeration type have linkage that allows use
5292 to check type_in_anonymous_namespace_p. We do not mangle compound types
5293 that always can be compared structurally.
5294
5295 Similarly for builtin types, we compare properties of their main variant.
5296 A special case are integer types where mangling do make differences
5297 between char/signed char/unsigned char etc. Storing name for these makes
5298 e.g. -fno-signed-char/-fsigned-char mismatches to be handled well.
5299 See cp/mangle.c:write_builtin_type for details. */
5300
5301 if (flag_lto_odr_type_mering
5302 && TREE_CODE (decl) == TYPE_DECL
5303 && DECL_NAME (decl)
5304 && decl == TYPE_NAME (TREE_TYPE (decl))
5305 && TYPE_MAIN_VARIANT (TREE_TYPE (decl)) == TREE_TYPE (decl)
5306 && !TYPE_ARTIFICIAL (TREE_TYPE (decl))
5307 && (type_with_linkage_p (TREE_TYPE (decl))
5308 || TREE_CODE (TREE_TYPE (decl)) == INTEGER_TYPE)
5309 && !variably_modified_type_p (TREE_TYPE (decl), NULL_TREE))
5310 return !DECL_ASSEMBLER_NAME_SET_P (decl);
5311 /* Only FUNCTION_DECLs and VAR_DECLs are considered. */
5312 if (!VAR_OR_FUNCTION_DECL_P (decl))
5313 return false;
5314
5315 /* If DECL already has its assembler name set, it does not need a
5316 new one. */
5317 if (!HAS_DECL_ASSEMBLER_NAME_P (decl)
5318 || DECL_ASSEMBLER_NAME_SET_P (decl))
5319 return false;
5320
5321 /* Abstract decls do not need an assembler name. */
5322 if (DECL_ABSTRACT_P (decl))
5323 return false;
5324
5325 /* For VAR_DECLs, only static, public and external symbols need an
5326 assembler name. */
5327 if (VAR_P (decl)
5328 && !TREE_STATIC (decl)
5329 && !TREE_PUBLIC (decl)
5330 && !DECL_EXTERNAL (decl))
5331 return false;
5332
5333 if (TREE_CODE (decl) == FUNCTION_DECL)
5334 {
5335 /* Do not set assembler name on builtins. Allow RTL expansion to
5336 decide whether to expand inline or via a regular call. */
5337 if (DECL_BUILT_IN (decl)
5338 && DECL_BUILT_IN_CLASS (decl) != BUILT_IN_FRONTEND)
5339 return false;
5340
5341 /* Functions represented in the callgraph need an assembler name. */
5342 if (cgraph_node::get (decl) != NULL)
5343 return true;
5344
5345 /* Unused and not public functions don't need an assembler name. */
5346 if (!TREE_USED (decl) && !TREE_PUBLIC (decl))
5347 return false;
5348 }
5349
5350 return true;
5351 }
5352
5353
5354 /* Reset all language specific information still present in symbol
5355 DECL. */
5356
5357 static void
5358 free_lang_data_in_decl (tree decl)
5359 {
5360 gcc_assert (DECL_P (decl));
5361
5362 /* Give the FE a chance to remove its own data first. */
5363 lang_hooks.free_lang_data (decl);
5364
5365 TREE_LANG_FLAG_0 (decl) = 0;
5366 TREE_LANG_FLAG_1 (decl) = 0;
5367 TREE_LANG_FLAG_2 (decl) = 0;
5368 TREE_LANG_FLAG_3 (decl) = 0;
5369 TREE_LANG_FLAG_4 (decl) = 0;
5370 TREE_LANG_FLAG_5 (decl) = 0;
5371 TREE_LANG_FLAG_6 (decl) = 0;
5372
5373 free_lang_data_in_one_sizepos (&DECL_SIZE (decl));
5374 free_lang_data_in_one_sizepos (&DECL_SIZE_UNIT (decl));
5375 if (TREE_CODE (decl) == FIELD_DECL)
5376 {
5377 free_lang_data_in_one_sizepos (&DECL_FIELD_OFFSET (decl));
5378 if (TREE_CODE (DECL_CONTEXT (decl)) == QUAL_UNION_TYPE)
5379 DECL_QUALIFIER (decl) = NULL_TREE;
5380 }
5381
5382 if (TREE_CODE (decl) == FUNCTION_DECL)
5383 {
5384 struct cgraph_node *node;
5385 if (!(node = cgraph_node::get (decl))
5386 || (!node->definition && !node->clones))
5387 {
5388 if (node)
5389 node->release_body ();
5390 else
5391 {
5392 release_function_body (decl);
5393 DECL_ARGUMENTS (decl) = NULL;
5394 DECL_RESULT (decl) = NULL;
5395 DECL_INITIAL (decl) = error_mark_node;
5396 }
5397 }
5398 if (gimple_has_body_p (decl) || (node && node->thunk.thunk_p))
5399 {
5400 tree t;
5401
5402 /* If DECL has a gimple body, then the context for its
5403 arguments must be DECL. Otherwise, it doesn't really
5404 matter, as we will not be emitting any code for DECL. In
5405 general, there may be other instances of DECL created by
5406 the front end and since PARM_DECLs are generally shared,
5407 their DECL_CONTEXT changes as the replicas of DECL are
5408 created. The only time where DECL_CONTEXT is important
5409 is for the FUNCTION_DECLs that have a gimple body (since
5410 the PARM_DECL will be used in the function's body). */
5411 for (t = DECL_ARGUMENTS (decl); t; t = TREE_CHAIN (t))
5412 DECL_CONTEXT (t) = decl;
5413 if (!DECL_FUNCTION_SPECIFIC_TARGET (decl))
5414 DECL_FUNCTION_SPECIFIC_TARGET (decl)
5415 = target_option_default_node;
5416 if (!DECL_FUNCTION_SPECIFIC_OPTIMIZATION (decl))
5417 DECL_FUNCTION_SPECIFIC_OPTIMIZATION (decl)
5418 = optimization_default_node;
5419 }
5420
5421 /* DECL_SAVED_TREE holds the GENERIC representation for DECL.
5422 At this point, it is not needed anymore. */
5423 DECL_SAVED_TREE (decl) = NULL_TREE;
5424
5425 /* Clear the abstract origin if it refers to a method. Otherwise
5426 dwarf2out.c will ICE as we clear TYPE_METHODS and thus the
5427 origin will not be output correctly. */
5428 if (DECL_ABSTRACT_ORIGIN (decl)
5429 && DECL_CONTEXT (DECL_ABSTRACT_ORIGIN (decl))
5430 && RECORD_OR_UNION_TYPE_P
5431 (DECL_CONTEXT (DECL_ABSTRACT_ORIGIN (decl))))
5432 DECL_ABSTRACT_ORIGIN (decl) = NULL_TREE;
5433
5434 /* Sometimes the C++ frontend doesn't manage to transform a temporary
5435 DECL_VINDEX referring to itself into a vtable slot number as it
5436 should. Happens with functions that are copied and then forgotten
5437 about. Just clear it, it won't matter anymore. */
5438 if (DECL_VINDEX (decl) && !tree_fits_shwi_p (DECL_VINDEX (decl)))
5439 DECL_VINDEX (decl) = NULL_TREE;
5440 }
5441 else if (VAR_P (decl))
5442 {
5443 if ((DECL_EXTERNAL (decl)
5444 && (!TREE_STATIC (decl) || !TREE_READONLY (decl)))
5445 || (decl_function_context (decl) && !TREE_STATIC (decl)))
5446 DECL_INITIAL (decl) = NULL_TREE;
5447 }
5448 else if (TREE_CODE (decl) == TYPE_DECL)
5449 {
5450 DECL_VISIBILITY (decl) = VISIBILITY_DEFAULT;
5451 DECL_VISIBILITY_SPECIFIED (decl) = 0;
5452 DECL_INITIAL (decl) = NULL_TREE;
5453 }
5454 else if (TREE_CODE (decl) == FIELD_DECL)
5455 DECL_INITIAL (decl) = NULL_TREE;
5456 else if (TREE_CODE (decl) == TRANSLATION_UNIT_DECL
5457 && DECL_INITIAL (decl)
5458 && TREE_CODE (DECL_INITIAL (decl)) == BLOCK)
5459 {
5460 /* Strip builtins from the translation-unit BLOCK. We still have targets
5461 without builtin_decl_explicit support and also builtins are shared
5462 nodes and thus we can't use TREE_CHAIN in multiple lists. */
5463 tree *nextp = &BLOCK_VARS (DECL_INITIAL (decl));
5464 while (*nextp)
5465 {
5466 tree var = *nextp;
5467 if (TREE_CODE (var) == FUNCTION_DECL
5468 && DECL_BUILT_IN (var))
5469 *nextp = TREE_CHAIN (var);
5470 else
5471 nextp = &TREE_CHAIN (var);
5472 }
5473 }
5474 }
5475
5476
5477 /* Data used when collecting DECLs and TYPEs for language data removal. */
5478
5479 struct free_lang_data_d
5480 {
5481 free_lang_data_d () : decls (100), types (100) {}
5482
5483 /* Worklist to avoid excessive recursion. */
5484 auto_vec<tree> worklist;
5485
5486 /* Set of traversed objects. Used to avoid duplicate visits. */
5487 hash_set<tree> pset;
5488
5489 /* Array of symbols to process with free_lang_data_in_decl. */
5490 auto_vec<tree> decls;
5491
5492 /* Array of types to process with free_lang_data_in_type. */
5493 auto_vec<tree> types;
5494 };
5495
5496
5497 /* Save all language fields needed to generate proper debug information
5498 for DECL. This saves most fields cleared out by free_lang_data_in_decl. */
5499
5500 static void
5501 save_debug_info_for_decl (tree t)
5502 {
5503 /*struct saved_debug_info_d *sdi;*/
5504
5505 gcc_assert (debug_info_level > DINFO_LEVEL_TERSE && t && DECL_P (t));
5506
5507 /* FIXME. Partial implementation for saving debug info removed. */
5508 }
5509
5510
5511 /* Save all language fields needed to generate proper debug information
5512 for TYPE. This saves most fields cleared out by free_lang_data_in_type. */
5513
5514 static void
5515 save_debug_info_for_type (tree t)
5516 {
5517 /*struct saved_debug_info_d *sdi;*/
5518
5519 gcc_assert (debug_info_level > DINFO_LEVEL_TERSE && t && TYPE_P (t));
5520
5521 /* FIXME. Partial implementation for saving debug info removed. */
5522 }
5523
5524
5525 /* Add type or decl T to one of the list of tree nodes that need their
5526 language data removed. The lists are held inside FLD. */
5527
5528 static void
5529 add_tree_to_fld_list (tree t, struct free_lang_data_d *fld)
5530 {
5531 if (DECL_P (t))
5532 {
5533 fld->decls.safe_push (t);
5534 if (debug_info_level > DINFO_LEVEL_TERSE)
5535 save_debug_info_for_decl (t);
5536 }
5537 else if (TYPE_P (t))
5538 {
5539 fld->types.safe_push (t);
5540 if (debug_info_level > DINFO_LEVEL_TERSE)
5541 save_debug_info_for_type (t);
5542 }
5543 else
5544 gcc_unreachable ();
5545 }
5546
5547 /* Push tree node T into FLD->WORKLIST. */
5548
5549 static inline void
5550 fld_worklist_push (tree t, struct free_lang_data_d *fld)
5551 {
5552 if (t && !is_lang_specific (t) && !fld->pset.contains (t))
5553 fld->worklist.safe_push ((t));
5554 }
5555
5556
5557 /* Operand callback helper for free_lang_data_in_node. *TP is the
5558 subtree operand being considered. */
5559
5560 static tree
5561 find_decls_types_r (tree *tp, int *ws, void *data)
5562 {
5563 tree t = *tp;
5564 struct free_lang_data_d *fld = (struct free_lang_data_d *) data;
5565
5566 if (TREE_CODE (t) == TREE_LIST)
5567 return NULL_TREE;
5568
5569 /* Language specific nodes will be removed, so there is no need
5570 to gather anything under them. */
5571 if (is_lang_specific (t))
5572 {
5573 *ws = 0;
5574 return NULL_TREE;
5575 }
5576
5577 if (DECL_P (t))
5578 {
5579 /* Note that walk_tree does not traverse every possible field in
5580 decls, so we have to do our own traversals here. */
5581 add_tree_to_fld_list (t, fld);
5582
5583 fld_worklist_push (DECL_NAME (t), fld);
5584 fld_worklist_push (DECL_CONTEXT (t), fld);
5585 fld_worklist_push (DECL_SIZE (t), fld);
5586 fld_worklist_push (DECL_SIZE_UNIT (t), fld);
5587
5588 /* We are going to remove everything under DECL_INITIAL for
5589 TYPE_DECLs. No point walking them. */
5590 if (TREE_CODE (t) != TYPE_DECL)
5591 fld_worklist_push (DECL_INITIAL (t), fld);
5592
5593 fld_worklist_push (DECL_ATTRIBUTES (t), fld);
5594 fld_worklist_push (DECL_ABSTRACT_ORIGIN (t), fld);
5595
5596 if (TREE_CODE (t) == FUNCTION_DECL)
5597 {
5598 fld_worklist_push (DECL_ARGUMENTS (t), fld);
5599 fld_worklist_push (DECL_RESULT (t), fld);
5600 }
5601 else if (TREE_CODE (t) == TYPE_DECL)
5602 {
5603 fld_worklist_push (DECL_ORIGINAL_TYPE (t), fld);
5604 }
5605 else if (TREE_CODE (t) == FIELD_DECL)
5606 {
5607 fld_worklist_push (DECL_FIELD_OFFSET (t), fld);
5608 fld_worklist_push (DECL_BIT_FIELD_TYPE (t), fld);
5609 fld_worklist_push (DECL_FIELD_BIT_OFFSET (t), fld);
5610 fld_worklist_push (DECL_FCONTEXT (t), fld);
5611 }
5612
5613 if ((VAR_P (t) || TREE_CODE (t) == PARM_DECL)
5614 && DECL_HAS_VALUE_EXPR_P (t))
5615 fld_worklist_push (DECL_VALUE_EXPR (t), fld);
5616
5617 if (TREE_CODE (t) != FIELD_DECL
5618 && TREE_CODE (t) != TYPE_DECL)
5619 fld_worklist_push (TREE_CHAIN (t), fld);
5620 *ws = 0;
5621 }
5622 else if (TYPE_P (t))
5623 {
5624 /* Note that walk_tree does not traverse every possible field in
5625 types, so we have to do our own traversals here. */
5626 add_tree_to_fld_list (t, fld);
5627
5628 if (!RECORD_OR_UNION_TYPE_P (t))
5629 fld_worklist_push (TYPE_CACHED_VALUES (t), fld);
5630 fld_worklist_push (TYPE_SIZE (t), fld);
5631 fld_worklist_push (TYPE_SIZE_UNIT (t), fld);
5632 fld_worklist_push (TYPE_ATTRIBUTES (t), fld);
5633 fld_worklist_push (TYPE_POINTER_TO (t), fld);
5634 fld_worklist_push (TYPE_REFERENCE_TO (t), fld);
5635 fld_worklist_push (TYPE_NAME (t), fld);
5636 /* Do not walk TYPE_NEXT_PTR_TO or TYPE_NEXT_REF_TO. We do not stream
5637 them and thus do not and want not to reach unused pointer types
5638 this way. */
5639 if (!POINTER_TYPE_P (t))
5640 fld_worklist_push (TYPE_MINVAL (t), fld);
5641 if (!RECORD_OR_UNION_TYPE_P (t))
5642 fld_worklist_push (TYPE_MAXVAL (t), fld);
5643 fld_worklist_push (TYPE_MAIN_VARIANT (t), fld);
5644 /* Do not walk TYPE_NEXT_VARIANT. We do not stream it and thus
5645 do not and want not to reach unused variants this way. */
5646 if (TYPE_CONTEXT (t))
5647 {
5648 tree ctx = TYPE_CONTEXT (t);
5649 /* We adjust BLOCK TYPE_CONTEXTs to the innermost non-BLOCK one.
5650 So push that instead. */
5651 while (ctx && TREE_CODE (ctx) == BLOCK)
5652 ctx = BLOCK_SUPERCONTEXT (ctx);
5653 fld_worklist_push (ctx, fld);
5654 }
5655 /* Do not walk TYPE_CANONICAL. We do not stream it and thus do not
5656 and want not to reach unused types this way. */
5657
5658 if (RECORD_OR_UNION_TYPE_P (t) && TYPE_BINFO (t))
5659 {
5660 unsigned i;
5661 tree tem;
5662 FOR_EACH_VEC_ELT (*BINFO_BASE_BINFOS (TYPE_BINFO (t)), i, tem)
5663 fld_worklist_push (TREE_TYPE (tem), fld);
5664 tem = BINFO_VIRTUALS (TYPE_BINFO (t));
5665 if (tem
5666 /* The Java FE overloads BINFO_VIRTUALS for its own purpose. */
5667 && TREE_CODE (tem) == TREE_LIST)
5668 do
5669 {
5670 fld_worklist_push (TREE_VALUE (tem), fld);
5671 tem = TREE_CHAIN (tem);
5672 }
5673 while (tem);
5674 }
5675 if (RECORD_OR_UNION_TYPE_P (t))
5676 {
5677 tree tem;
5678 /* Push all TYPE_FIELDS - there can be interleaving interesting
5679 and non-interesting things. */
5680 tem = TYPE_FIELDS (t);
5681 while (tem)
5682 {
5683 if (TREE_CODE (tem) == FIELD_DECL
5684 || (TREE_CODE (tem) == TYPE_DECL
5685 && !DECL_IGNORED_P (tem)
5686 && debug_info_level > DINFO_LEVEL_TERSE
5687 && !is_redundant_typedef (tem)))
5688 fld_worklist_push (tem, fld);
5689 tem = TREE_CHAIN (tem);
5690 }
5691 }
5692
5693 fld_worklist_push (TYPE_STUB_DECL (t), fld);
5694 *ws = 0;
5695 }
5696 else if (TREE_CODE (t) == BLOCK)
5697 {
5698 tree tem;
5699 for (tem = BLOCK_VARS (t); tem; tem = TREE_CHAIN (tem))
5700 fld_worklist_push (tem, fld);
5701 for (tem = BLOCK_SUBBLOCKS (t); tem; tem = BLOCK_CHAIN (tem))
5702 fld_worklist_push (tem, fld);
5703 fld_worklist_push (BLOCK_ABSTRACT_ORIGIN (t), fld);
5704 }
5705
5706 if (TREE_CODE (t) != IDENTIFIER_NODE
5707 && CODE_CONTAINS_STRUCT (TREE_CODE (t), TS_TYPED))
5708 fld_worklist_push (TREE_TYPE (t), fld);
5709
5710 return NULL_TREE;
5711 }
5712
5713
5714 /* Find decls and types in T. */
5715
5716 static void
5717 find_decls_types (tree t, struct free_lang_data_d *fld)
5718 {
5719 while (1)
5720 {
5721 if (!fld->pset.contains (t))
5722 walk_tree (&t, find_decls_types_r, fld, &fld->pset);
5723 if (fld->worklist.is_empty ())
5724 break;
5725 t = fld->worklist.pop ();
5726 }
5727 }
5728
5729 /* Translate all the types in LIST with the corresponding runtime
5730 types. */
5731
5732 static tree
5733 get_eh_types_for_runtime (tree list)
5734 {
5735 tree head, prev;
5736
5737 if (list == NULL_TREE)
5738 return NULL_TREE;
5739
5740 head = build_tree_list (0, lookup_type_for_runtime (TREE_VALUE (list)));
5741 prev = head;
5742 list = TREE_CHAIN (list);
5743 while (list)
5744 {
5745 tree n = build_tree_list (0, lookup_type_for_runtime (TREE_VALUE (list)));
5746 TREE_CHAIN (prev) = n;
5747 prev = TREE_CHAIN (prev);
5748 list = TREE_CHAIN (list);
5749 }
5750
5751 return head;
5752 }
5753
5754
5755 /* Find decls and types referenced in EH region R and store them in
5756 FLD->DECLS and FLD->TYPES. */
5757
5758 static void
5759 find_decls_types_in_eh_region (eh_region r, struct free_lang_data_d *fld)
5760 {
5761 switch (r->type)
5762 {
5763 case ERT_CLEANUP:
5764 break;
5765
5766 case ERT_TRY:
5767 {
5768 eh_catch c;
5769
5770 /* The types referenced in each catch must first be changed to the
5771 EH types used at runtime. This removes references to FE types
5772 in the region. */
5773 for (c = r->u.eh_try.first_catch; c ; c = c->next_catch)
5774 {
5775 c->type_list = get_eh_types_for_runtime (c->type_list);
5776 walk_tree (&c->type_list, find_decls_types_r, fld, &fld->pset);
5777 }
5778 }
5779 break;
5780
5781 case ERT_ALLOWED_EXCEPTIONS:
5782 r->u.allowed.type_list
5783 = get_eh_types_for_runtime (r->u.allowed.type_list);
5784 walk_tree (&r->u.allowed.type_list, find_decls_types_r, fld, &fld->pset);
5785 break;
5786
5787 case ERT_MUST_NOT_THROW:
5788 walk_tree (&r->u.must_not_throw.failure_decl,
5789 find_decls_types_r, fld, &fld->pset);
5790 break;
5791 }
5792 }
5793
5794
5795 /* Find decls and types referenced in cgraph node N and store them in
5796 FLD->DECLS and FLD->TYPES. Unlike pass_referenced_vars, this will
5797 look for *every* kind of DECL and TYPE node reachable from N,
5798 including those embedded inside types and decls (i.e,, TYPE_DECLs,
5799 NAMESPACE_DECLs, etc). */
5800
5801 static void
5802 find_decls_types_in_node (struct cgraph_node *n, struct free_lang_data_d *fld)
5803 {
5804 basic_block bb;
5805 struct function *fn;
5806 unsigned ix;
5807 tree t;
5808
5809 find_decls_types (n->decl, fld);
5810
5811 if (!gimple_has_body_p (n->decl))
5812 return;
5813
5814 gcc_assert (current_function_decl == NULL_TREE && cfun == NULL);
5815
5816 fn = DECL_STRUCT_FUNCTION (n->decl);
5817
5818 /* Traverse locals. */
5819 FOR_EACH_LOCAL_DECL (fn, ix, t)
5820 find_decls_types (t, fld);
5821
5822 /* Traverse EH regions in FN. */
5823 {
5824 eh_region r;
5825 FOR_ALL_EH_REGION_FN (r, fn)
5826 find_decls_types_in_eh_region (r, fld);
5827 }
5828
5829 /* Traverse every statement in FN. */
5830 FOR_EACH_BB_FN (bb, fn)
5831 {
5832 gphi_iterator psi;
5833 gimple_stmt_iterator si;
5834 unsigned i;
5835
5836 for (psi = gsi_start_phis (bb); !gsi_end_p (psi); gsi_next (&psi))
5837 {
5838 gphi *phi = psi.phi ();
5839
5840 for (i = 0; i < gimple_phi_num_args (phi); i++)
5841 {
5842 tree *arg_p = gimple_phi_arg_def_ptr (phi, i);
5843 find_decls_types (*arg_p, fld);
5844 }
5845 }
5846
5847 for (si = gsi_start_bb (bb); !gsi_end_p (si); gsi_next (&si))
5848 {
5849 gimple *stmt = gsi_stmt (si);
5850
5851 if (is_gimple_call (stmt))
5852 find_decls_types (gimple_call_fntype (stmt), fld);
5853
5854 for (i = 0; i < gimple_num_ops (stmt); i++)
5855 {
5856 tree arg = gimple_op (stmt, i);
5857 find_decls_types (arg, fld);
5858 }
5859 }
5860 }
5861 }
5862
5863
5864 /* Find decls and types referenced in varpool node N and store them in
5865 FLD->DECLS and FLD->TYPES. Unlike pass_referenced_vars, this will
5866 look for *every* kind of DECL and TYPE node reachable from N,
5867 including those embedded inside types and decls (i.e,, TYPE_DECLs,
5868 NAMESPACE_DECLs, etc). */
5869
5870 static void
5871 find_decls_types_in_var (varpool_node *v, struct free_lang_data_d *fld)
5872 {
5873 find_decls_types (v->decl, fld);
5874 }
5875
5876 /* If T needs an assembler name, have one created for it. */
5877
5878 void
5879 assign_assembler_name_if_needed (tree t)
5880 {
5881 if (need_assembler_name_p (t))
5882 {
5883 /* When setting DECL_ASSEMBLER_NAME, the C++ mangler may emit
5884 diagnostics that use input_location to show locus
5885 information. The problem here is that, at this point,
5886 input_location is generally anchored to the end of the file
5887 (since the parser is long gone), so we don't have a good
5888 position to pin it to.
5889
5890 To alleviate this problem, this uses the location of T's
5891 declaration. Examples of this are
5892 testsuite/g++.dg/template/cond2.C and
5893 testsuite/g++.dg/template/pr35240.C. */
5894 location_t saved_location = input_location;
5895 input_location = DECL_SOURCE_LOCATION (t);
5896
5897 decl_assembler_name (t);
5898
5899 input_location = saved_location;
5900 }
5901 }
5902
5903
5904 /* Free language specific information for every operand and expression
5905 in every node of the call graph. This process operates in three stages:
5906
5907 1- Every callgraph node and varpool node is traversed looking for
5908 decls and types embedded in them. This is a more exhaustive
5909 search than that done by find_referenced_vars, because it will
5910 also collect individual fields, decls embedded in types, etc.
5911
5912 2- All the decls found are sent to free_lang_data_in_decl.
5913
5914 3- All the types found are sent to free_lang_data_in_type.
5915
5916 The ordering between decls and types is important because
5917 free_lang_data_in_decl sets assembler names, which includes
5918 mangling. So types cannot be freed up until assembler names have
5919 been set up. */
5920
5921 static void
5922 free_lang_data_in_cgraph (void)
5923 {
5924 struct cgraph_node *n;
5925 varpool_node *v;
5926 struct free_lang_data_d fld;
5927 tree t;
5928 unsigned i;
5929 alias_pair *p;
5930
5931 /* Find decls and types in the body of every function in the callgraph. */
5932 FOR_EACH_FUNCTION (n)
5933 find_decls_types_in_node (n, &fld);
5934
5935 FOR_EACH_VEC_SAFE_ELT (alias_pairs, i, p)
5936 find_decls_types (p->decl, &fld);
5937
5938 /* Find decls and types in every varpool symbol. */
5939 FOR_EACH_VARIABLE (v)
5940 find_decls_types_in_var (v, &fld);
5941
5942 /* Set the assembler name on every decl found. We need to do this
5943 now because free_lang_data_in_decl will invalidate data needed
5944 for mangling. This breaks mangling on interdependent decls. */
5945 FOR_EACH_VEC_ELT (fld.decls, i, t)
5946 assign_assembler_name_if_needed (t);
5947
5948 /* Traverse every decl found freeing its language data. */
5949 FOR_EACH_VEC_ELT (fld.decls, i, t)
5950 free_lang_data_in_decl (t);
5951
5952 /* Traverse every type found freeing its language data. */
5953 FOR_EACH_VEC_ELT (fld.types, i, t)
5954 free_lang_data_in_type (t);
5955 if (flag_checking)
5956 {
5957 FOR_EACH_VEC_ELT (fld.types, i, t)
5958 verify_type (t);
5959 }
5960 }
5961
5962
5963 /* Free resources that are used by FE but are not needed once they are done. */
5964
5965 static unsigned
5966 free_lang_data (void)
5967 {
5968 unsigned i;
5969
5970 /* If we are the LTO frontend we have freed lang-specific data already. */
5971 if (in_lto_p
5972 || (!flag_generate_lto && !flag_generate_offload))
5973 return 0;
5974
5975 /* Allocate and assign alias sets to the standard integer types
5976 while the slots are still in the way the frontends generated them. */
5977 for (i = 0; i < itk_none; ++i)
5978 if (integer_types[i])
5979 TYPE_ALIAS_SET (integer_types[i]) = get_alias_set (integer_types[i]);
5980
5981 /* Traverse the IL resetting language specific information for
5982 operands, expressions, etc. */
5983 free_lang_data_in_cgraph ();
5984
5985 /* Create gimple variants for common types. */
5986 fileptr_type_node = ptr_type_node;
5987 const_tm_ptr_type_node = const_ptr_type_node;
5988
5989 /* Reset some langhooks. Do not reset types_compatible_p, it may
5990 still be used indirectly via the get_alias_set langhook. */
5991 lang_hooks.dwarf_name = lhd_dwarf_name;
5992 lang_hooks.decl_printable_name = gimple_decl_printable_name;
5993 lang_hooks.gimplify_expr = lhd_gimplify_expr;
5994
5995 /* We do not want the default decl_assembler_name implementation,
5996 rather if we have fixed everything we want a wrapper around it
5997 asserting that all non-local symbols already got their assembler
5998 name and only produce assembler names for local symbols. Or rather
5999 make sure we never call decl_assembler_name on local symbols and
6000 devise a separate, middle-end private scheme for it. */
6001
6002 /* Reset diagnostic machinery. */
6003 tree_diagnostics_defaults (global_dc);
6004
6005 return 0;
6006 }
6007
6008
6009 namespace {
6010
6011 const pass_data pass_data_ipa_free_lang_data =
6012 {
6013 SIMPLE_IPA_PASS, /* type */
6014 "*free_lang_data", /* name */
6015 OPTGROUP_NONE, /* optinfo_flags */
6016 TV_IPA_FREE_LANG_DATA, /* tv_id */
6017 0, /* properties_required */
6018 0, /* properties_provided */
6019 0, /* properties_destroyed */
6020 0, /* todo_flags_start */
6021 0, /* todo_flags_finish */
6022 };
6023
6024 class pass_ipa_free_lang_data : public simple_ipa_opt_pass
6025 {
6026 public:
6027 pass_ipa_free_lang_data (gcc::context *ctxt)
6028 : simple_ipa_opt_pass (pass_data_ipa_free_lang_data, ctxt)
6029 {}
6030
6031 /* opt_pass methods: */
6032 virtual unsigned int execute (function *) { return free_lang_data (); }
6033
6034 }; // class pass_ipa_free_lang_data
6035
6036 } // anon namespace
6037
6038 simple_ipa_opt_pass *
6039 make_pass_ipa_free_lang_data (gcc::context *ctxt)
6040 {
6041 return new pass_ipa_free_lang_data (ctxt);
6042 }
6043
6044 /* The backbone of is_attribute_p(). ATTR_LEN is the string length of
6045 ATTR_NAME. Also used internally by remove_attribute(). */
6046 bool
6047 private_is_attribute_p (const char *attr_name, size_t attr_len, const_tree ident)
6048 {
6049 size_t ident_len = IDENTIFIER_LENGTH (ident);
6050
6051 if (ident_len == attr_len)
6052 {
6053 if (strcmp (attr_name, IDENTIFIER_POINTER (ident)) == 0)
6054 return true;
6055 }
6056 else if (ident_len == attr_len + 4)
6057 {
6058 /* There is the possibility that ATTR is 'text' and IDENT is
6059 '__text__'. */
6060 const char *p = IDENTIFIER_POINTER (ident);
6061 if (p[0] == '_' && p[1] == '_'
6062 && p[ident_len - 2] == '_' && p[ident_len - 1] == '_'
6063 && strncmp (attr_name, p + 2, attr_len) == 0)
6064 return true;
6065 }
6066
6067 return false;
6068 }
6069
6070 /* The backbone of lookup_attribute(). ATTR_LEN is the string length
6071 of ATTR_NAME, and LIST is not NULL_TREE. */
6072 tree
6073 private_lookup_attribute (const char *attr_name, size_t attr_len, tree list)
6074 {
6075 while (list)
6076 {
6077 size_t ident_len = IDENTIFIER_LENGTH (get_attribute_name (list));
6078
6079 if (ident_len == attr_len)
6080 {
6081 if (!strcmp (attr_name,
6082 IDENTIFIER_POINTER (get_attribute_name (list))))
6083 break;
6084 }
6085 /* TODO: If we made sure that attributes were stored in the
6086 canonical form without '__...__' (ie, as in 'text' as opposed
6087 to '__text__') then we could avoid the following case. */
6088 else if (ident_len == attr_len + 4)
6089 {
6090 const char *p = IDENTIFIER_POINTER (get_attribute_name (list));
6091 if (p[0] == '_' && p[1] == '_'
6092 && p[ident_len - 2] == '_' && p[ident_len - 1] == '_'
6093 && strncmp (attr_name, p + 2, attr_len) == 0)
6094 break;
6095 }
6096 list = TREE_CHAIN (list);
6097 }
6098
6099 return list;
6100 }
6101
6102 /* Given an attribute name ATTR_NAME and a list of attributes LIST,
6103 return a pointer to the attribute's list first element if the attribute
6104 starts with ATTR_NAME. ATTR_NAME must be in the form 'text' (not
6105 '__text__'). */
6106
6107 tree
6108 private_lookup_attribute_by_prefix (const char *attr_name, size_t attr_len,
6109 tree list)
6110 {
6111 while (list)
6112 {
6113 size_t ident_len = IDENTIFIER_LENGTH (get_attribute_name (list));
6114
6115 if (attr_len > ident_len)
6116 {
6117 list = TREE_CHAIN (list);
6118 continue;
6119 }
6120
6121 const char *p = IDENTIFIER_POINTER (get_attribute_name (list));
6122
6123 if (strncmp (attr_name, p, attr_len) == 0)
6124 break;
6125
6126 /* TODO: If we made sure that attributes were stored in the
6127 canonical form without '__...__' (ie, as in 'text' as opposed
6128 to '__text__') then we could avoid the following case. */
6129 if (p[0] == '_' && p[1] == '_' &&
6130 strncmp (attr_name, p + 2, attr_len) == 0)
6131 break;
6132
6133 list = TREE_CHAIN (list);
6134 }
6135
6136 return list;
6137 }
6138
6139
6140 /* A variant of lookup_attribute() that can be used with an identifier
6141 as the first argument, and where the identifier can be either
6142 'text' or '__text__'.
6143
6144 Given an attribute ATTR_IDENTIFIER, and a list of attributes LIST,
6145 return a pointer to the attribute's list element if the attribute
6146 is part of the list, or NULL_TREE if not found. If the attribute
6147 appears more than once, this only returns the first occurrence; the
6148 TREE_CHAIN of the return value should be passed back in if further
6149 occurrences are wanted. ATTR_IDENTIFIER must be an identifier but
6150 can be in the form 'text' or '__text__'. */
6151 static tree
6152 lookup_ident_attribute (tree attr_identifier, tree list)
6153 {
6154 gcc_checking_assert (TREE_CODE (attr_identifier) == IDENTIFIER_NODE);
6155
6156 while (list)
6157 {
6158 gcc_checking_assert (TREE_CODE (get_attribute_name (list))
6159 == IDENTIFIER_NODE);
6160
6161 if (cmp_attrib_identifiers (attr_identifier,
6162 get_attribute_name (list)))
6163 /* Found it. */
6164 break;
6165 list = TREE_CHAIN (list);
6166 }
6167
6168 return list;
6169 }
6170
6171 /* Remove any instances of attribute ATTR_NAME in LIST and return the
6172 modified list. */
6173
6174 tree
6175 remove_attribute (const char *attr_name, tree list)
6176 {
6177 tree *p;
6178 size_t attr_len = strlen (attr_name);
6179
6180 gcc_checking_assert (attr_name[0] != '_');
6181
6182 for (p = &list; *p; )
6183 {
6184 tree l = *p;
6185 /* TODO: If we were storing attributes in normalized form, here
6186 we could use a simple strcmp(). */
6187 if (private_is_attribute_p (attr_name, attr_len, get_attribute_name (l)))
6188 *p = TREE_CHAIN (l);
6189 else
6190 p = &TREE_CHAIN (l);
6191 }
6192
6193 return list;
6194 }
6195
6196 /* Return an attribute list that is the union of a1 and a2. */
6197
6198 tree
6199 merge_attributes (tree a1, tree a2)
6200 {
6201 tree attributes;
6202
6203 /* Either one unset? Take the set one. */
6204
6205 if ((attributes = a1) == 0)
6206 attributes = a2;
6207
6208 /* One that completely contains the other? Take it. */
6209
6210 else if (a2 != 0 && ! attribute_list_contained (a1, a2))
6211 {
6212 if (attribute_list_contained (a2, a1))
6213 attributes = a2;
6214 else
6215 {
6216 /* Pick the longest list, and hang on the other list. */
6217
6218 if (list_length (a1) < list_length (a2))
6219 attributes = a2, a2 = a1;
6220
6221 for (; a2 != 0; a2 = TREE_CHAIN (a2))
6222 {
6223 tree a;
6224 for (a = lookup_ident_attribute (get_attribute_name (a2),
6225 attributes);
6226 a != NULL_TREE && !attribute_value_equal (a, a2);
6227 a = lookup_ident_attribute (get_attribute_name (a2),
6228 TREE_CHAIN (a)))
6229 ;
6230 if (a == NULL_TREE)
6231 {
6232 a1 = copy_node (a2);
6233 TREE_CHAIN (a1) = attributes;
6234 attributes = a1;
6235 }
6236 }
6237 }
6238 }
6239 return attributes;
6240 }
6241
6242 /* Given types T1 and T2, merge their attributes and return
6243 the result. */
6244
6245 tree
6246 merge_type_attributes (tree t1, tree t2)
6247 {
6248 return merge_attributes (TYPE_ATTRIBUTES (t1),
6249 TYPE_ATTRIBUTES (t2));
6250 }
6251
6252 /* Given decls OLDDECL and NEWDECL, merge their attributes and return
6253 the result. */
6254
6255 tree
6256 merge_decl_attributes (tree olddecl, tree newdecl)
6257 {
6258 return merge_attributes (DECL_ATTRIBUTES (olddecl),
6259 DECL_ATTRIBUTES (newdecl));
6260 }
6261
6262 #if TARGET_DLLIMPORT_DECL_ATTRIBUTES
6263
6264 /* Specialization of merge_decl_attributes for various Windows targets.
6265
6266 This handles the following situation:
6267
6268 __declspec (dllimport) int foo;
6269 int foo;
6270
6271 The second instance of `foo' nullifies the dllimport. */
6272
6273 tree
6274 merge_dllimport_decl_attributes (tree old, tree new_tree)
6275 {
6276 tree a;
6277 int delete_dllimport_p = 1;
6278
6279 /* What we need to do here is remove from `old' dllimport if it doesn't
6280 appear in `new'. dllimport behaves like extern: if a declaration is
6281 marked dllimport and a definition appears later, then the object
6282 is not dllimport'd. We also remove a `new' dllimport if the old list
6283 contains dllexport: dllexport always overrides dllimport, regardless
6284 of the order of declaration. */
6285 if (!VAR_OR_FUNCTION_DECL_P (new_tree))
6286 delete_dllimport_p = 0;
6287 else if (DECL_DLLIMPORT_P (new_tree)
6288 && lookup_attribute ("dllexport", DECL_ATTRIBUTES (old)))
6289 {
6290 DECL_DLLIMPORT_P (new_tree) = 0;
6291 warning (OPT_Wattributes, "%q+D already declared with dllexport attribute: "
6292 "dllimport ignored", new_tree);
6293 }
6294 else if (DECL_DLLIMPORT_P (old) && !DECL_DLLIMPORT_P (new_tree))
6295 {
6296 /* Warn about overriding a symbol that has already been used, e.g.:
6297 extern int __attribute__ ((dllimport)) foo;
6298 int* bar () {return &foo;}
6299 int foo;
6300 */
6301 if (TREE_USED (old))
6302 {
6303 warning (0, "%q+D redeclared without dllimport attribute "
6304 "after being referenced with dll linkage", new_tree);
6305 /* If we have used a variable's address with dllimport linkage,
6306 keep the old DECL_DLLIMPORT_P flag: the ADDR_EXPR using the
6307 decl may already have had TREE_CONSTANT computed.
6308 We still remove the attribute so that assembler code refers
6309 to '&foo rather than '_imp__foo'. */
6310 if (VAR_P (old) && TREE_ADDRESSABLE (old))
6311 DECL_DLLIMPORT_P (new_tree) = 1;
6312 }
6313
6314 /* Let an inline definition silently override the external reference,
6315 but otherwise warn about attribute inconsistency. */
6316 else if (VAR_P (new_tree) || !DECL_DECLARED_INLINE_P (new_tree))
6317 warning (OPT_Wattributes, "%q+D redeclared without dllimport attribute: "
6318 "previous dllimport ignored", new_tree);
6319 }
6320 else
6321 delete_dllimport_p = 0;
6322
6323 a = merge_attributes (DECL_ATTRIBUTES (old), DECL_ATTRIBUTES (new_tree));
6324
6325 if (delete_dllimport_p)
6326 a = remove_attribute ("dllimport", a);
6327
6328 return a;
6329 }
6330
6331 /* Handle a "dllimport" or "dllexport" attribute; arguments as in
6332 struct attribute_spec.handler. */
6333
6334 tree
6335 handle_dll_attribute (tree * pnode, tree name, tree args, int flags,
6336 bool *no_add_attrs)
6337 {
6338 tree node = *pnode;
6339 bool is_dllimport;
6340
6341 /* These attributes may apply to structure and union types being created,
6342 but otherwise should pass to the declaration involved. */
6343 if (!DECL_P (node))
6344 {
6345 if (flags & ((int) ATTR_FLAG_DECL_NEXT | (int) ATTR_FLAG_FUNCTION_NEXT
6346 | (int) ATTR_FLAG_ARRAY_NEXT))
6347 {
6348 *no_add_attrs = true;
6349 return tree_cons (name, args, NULL_TREE);
6350 }
6351 if (TREE_CODE (node) == RECORD_TYPE
6352 || TREE_CODE (node) == UNION_TYPE)
6353 {
6354 node = TYPE_NAME (node);
6355 if (!node)
6356 return NULL_TREE;
6357 }
6358 else
6359 {
6360 warning (OPT_Wattributes, "%qE attribute ignored",
6361 name);
6362 *no_add_attrs = true;
6363 return NULL_TREE;
6364 }
6365 }
6366
6367 if (!VAR_OR_FUNCTION_DECL_P (node) && TREE_CODE (node) != TYPE_DECL)
6368 {
6369 *no_add_attrs = true;
6370 warning (OPT_Wattributes, "%qE attribute ignored",
6371 name);
6372 return NULL_TREE;
6373 }
6374
6375 if (TREE_CODE (node) == TYPE_DECL
6376 && TREE_CODE (TREE_TYPE (node)) != RECORD_TYPE
6377 && TREE_CODE (TREE_TYPE (node)) != UNION_TYPE)
6378 {
6379 *no_add_attrs = true;
6380 warning (OPT_Wattributes, "%qE attribute ignored",
6381 name);
6382 return NULL_TREE;
6383 }
6384
6385 is_dllimport = is_attribute_p ("dllimport", name);
6386
6387 /* Report error on dllimport ambiguities seen now before they cause
6388 any damage. */
6389 if (is_dllimport)
6390 {
6391 /* Honor any target-specific overrides. */
6392 if (!targetm.valid_dllimport_attribute_p (node))
6393 *no_add_attrs = true;
6394
6395 else if (TREE_CODE (node) == FUNCTION_DECL
6396 && DECL_DECLARED_INLINE_P (node))
6397 {
6398 warning (OPT_Wattributes, "inline function %q+D declared as "
6399 " dllimport: attribute ignored", node);
6400 *no_add_attrs = true;
6401 }
6402 /* Like MS, treat definition of dllimported variables and
6403 non-inlined functions on declaration as syntax errors. */
6404 else if (TREE_CODE (node) == FUNCTION_DECL && DECL_INITIAL (node))
6405 {
6406 error ("function %q+D definition is marked dllimport", node);
6407 *no_add_attrs = true;
6408 }
6409
6410 else if (VAR_P (node))
6411 {
6412 if (DECL_INITIAL (node))
6413 {
6414 error ("variable %q+D definition is marked dllimport",
6415 node);
6416 *no_add_attrs = true;
6417 }
6418
6419 /* `extern' needn't be specified with dllimport.
6420 Specify `extern' now and hope for the best. Sigh. */
6421 DECL_EXTERNAL (node) = 1;
6422 /* Also, implicitly give dllimport'd variables declared within
6423 a function global scope, unless declared static. */
6424 if (current_function_decl != NULL_TREE && !TREE_STATIC (node))
6425 TREE_PUBLIC (node) = 1;
6426 }
6427
6428 if (*no_add_attrs == false)
6429 DECL_DLLIMPORT_P (node) = 1;
6430 }
6431 else if (TREE_CODE (node) == FUNCTION_DECL
6432 && DECL_DECLARED_INLINE_P (node)
6433 && flag_keep_inline_dllexport)
6434 /* An exported function, even if inline, must be emitted. */
6435 DECL_EXTERNAL (node) = 0;
6436
6437 /* Report error if symbol is not accessible at global scope. */
6438 if (!TREE_PUBLIC (node) && VAR_OR_FUNCTION_DECL_P (node))
6439 {
6440 error ("external linkage required for symbol %q+D because of "
6441 "%qE attribute", node, name);
6442 *no_add_attrs = true;
6443 }
6444
6445 /* A dllexport'd entity must have default visibility so that other
6446 program units (shared libraries or the main executable) can see
6447 it. A dllimport'd entity must have default visibility so that
6448 the linker knows that undefined references within this program
6449 unit can be resolved by the dynamic linker. */
6450 if (!*no_add_attrs)
6451 {
6452 if (DECL_VISIBILITY_SPECIFIED (node)
6453 && DECL_VISIBILITY (node) != VISIBILITY_DEFAULT)
6454 error ("%qE implies default visibility, but %qD has already "
6455 "been declared with a different visibility",
6456 name, node);
6457 DECL_VISIBILITY (node) = VISIBILITY_DEFAULT;
6458 DECL_VISIBILITY_SPECIFIED (node) = 1;
6459 }
6460
6461 return NULL_TREE;
6462 }
6463
6464 #endif /* TARGET_DLLIMPORT_DECL_ATTRIBUTES */
6465 \f
6466 /* Set the type qualifiers for TYPE to TYPE_QUALS, which is a bitmask
6467 of the various TYPE_QUAL values. */
6468
6469 static void
6470 set_type_quals (tree type, int type_quals)
6471 {
6472 TYPE_READONLY (type) = (type_quals & TYPE_QUAL_CONST) != 0;
6473 TYPE_VOLATILE (type) = (type_quals & TYPE_QUAL_VOLATILE) != 0;
6474 TYPE_RESTRICT (type) = (type_quals & TYPE_QUAL_RESTRICT) != 0;
6475 TYPE_ATOMIC (type) = (type_quals & TYPE_QUAL_ATOMIC) != 0;
6476 TYPE_ADDR_SPACE (type) = DECODE_QUAL_ADDR_SPACE (type_quals);
6477 }
6478
6479 /* Returns true iff CAND and BASE have equivalent language-specific
6480 qualifiers. */
6481
6482 bool
6483 check_lang_type (const_tree cand, const_tree base)
6484 {
6485 if (lang_hooks.types.type_hash_eq == NULL)
6486 return true;
6487 /* type_hash_eq currently only applies to these types. */
6488 if (TREE_CODE (cand) != FUNCTION_TYPE
6489 && TREE_CODE (cand) != METHOD_TYPE)
6490 return true;
6491 return lang_hooks.types.type_hash_eq (cand, base);
6492 }
6493
6494 /* Returns true iff unqualified CAND and BASE are equivalent. */
6495
6496 bool
6497 check_base_type (const_tree cand, const_tree base)
6498 {
6499 return (TYPE_NAME (cand) == TYPE_NAME (base)
6500 /* Apparently this is needed for Objective-C. */
6501 && TYPE_CONTEXT (cand) == TYPE_CONTEXT (base)
6502 /* Check alignment. */
6503 && TYPE_ALIGN (cand) == TYPE_ALIGN (base)
6504 && attribute_list_equal (TYPE_ATTRIBUTES (cand),
6505 TYPE_ATTRIBUTES (base)));
6506 }
6507
6508 /* Returns true iff CAND is equivalent to BASE with TYPE_QUALS. */
6509
6510 bool
6511 check_qualified_type (const_tree cand, const_tree base, int type_quals)
6512 {
6513 return (TYPE_QUALS (cand) == type_quals
6514 && check_base_type (cand, base)
6515 && check_lang_type (cand, base));
6516 }
6517
6518 /* Returns true iff CAND is equivalent to BASE with ALIGN. */
6519
6520 static bool
6521 check_aligned_type (const_tree cand, const_tree base, unsigned int align)
6522 {
6523 return (TYPE_QUALS (cand) == TYPE_QUALS (base)
6524 && TYPE_NAME (cand) == TYPE_NAME (base)
6525 /* Apparently this is needed for Objective-C. */
6526 && TYPE_CONTEXT (cand) == TYPE_CONTEXT (base)
6527 /* Check alignment. */
6528 && TYPE_ALIGN (cand) == align
6529 && attribute_list_equal (TYPE_ATTRIBUTES (cand),
6530 TYPE_ATTRIBUTES (base))
6531 && check_lang_type (cand, base));
6532 }
6533
6534 /* This function checks to see if TYPE matches the size one of the built-in
6535 atomic types, and returns that core atomic type. */
6536
6537 static tree
6538 find_atomic_core_type (tree type)
6539 {
6540 tree base_atomic_type;
6541
6542 /* Only handle complete types. */
6543 if (TYPE_SIZE (type) == NULL_TREE)
6544 return NULL_TREE;
6545
6546 HOST_WIDE_INT type_size = tree_to_uhwi (TYPE_SIZE (type));
6547 switch (type_size)
6548 {
6549 case 8:
6550 base_atomic_type = atomicQI_type_node;
6551 break;
6552
6553 case 16:
6554 base_atomic_type = atomicHI_type_node;
6555 break;
6556
6557 case 32:
6558 base_atomic_type = atomicSI_type_node;
6559 break;
6560
6561 case 64:
6562 base_atomic_type = atomicDI_type_node;
6563 break;
6564
6565 case 128:
6566 base_atomic_type = atomicTI_type_node;
6567 break;
6568
6569 default:
6570 base_atomic_type = NULL_TREE;
6571 }
6572
6573 return base_atomic_type;
6574 }
6575
6576 /* Return a version of the TYPE, qualified as indicated by the
6577 TYPE_QUALS, if one exists. If no qualified version exists yet,
6578 return NULL_TREE. */
6579
6580 tree
6581 get_qualified_type (tree type, int type_quals)
6582 {
6583 tree t;
6584
6585 if (TYPE_QUALS (type) == type_quals)
6586 return type;
6587
6588 /* Search the chain of variants to see if there is already one there just
6589 like the one we need to have. If so, use that existing one. We must
6590 preserve the TYPE_NAME, since there is code that depends on this. */
6591 for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
6592 if (check_qualified_type (t, type, type_quals))
6593 return t;
6594
6595 return NULL_TREE;
6596 }
6597
6598 /* Like get_qualified_type, but creates the type if it does not
6599 exist. This function never returns NULL_TREE. */
6600
6601 tree
6602 build_qualified_type (tree type, int type_quals MEM_STAT_DECL)
6603 {
6604 tree t;
6605
6606 /* See if we already have the appropriate qualified variant. */
6607 t = get_qualified_type (type, type_quals);
6608
6609 /* If not, build it. */
6610 if (!t)
6611 {
6612 t = build_variant_type_copy (type PASS_MEM_STAT);
6613 set_type_quals (t, type_quals);
6614
6615 if (((type_quals & TYPE_QUAL_ATOMIC) == TYPE_QUAL_ATOMIC))
6616 {
6617 /* See if this object can map to a basic atomic type. */
6618 tree atomic_type = find_atomic_core_type (type);
6619 if (atomic_type)
6620 {
6621 /* Ensure the alignment of this type is compatible with
6622 the required alignment of the atomic type. */
6623 if (TYPE_ALIGN (atomic_type) > TYPE_ALIGN (t))
6624 SET_TYPE_ALIGN (t, TYPE_ALIGN (atomic_type));
6625 }
6626 }
6627
6628 if (TYPE_STRUCTURAL_EQUALITY_P (type))
6629 /* Propagate structural equality. */
6630 SET_TYPE_STRUCTURAL_EQUALITY (t);
6631 else if (TYPE_CANONICAL (type) != type)
6632 /* Build the underlying canonical type, since it is different
6633 from TYPE. */
6634 {
6635 tree c = build_qualified_type (TYPE_CANONICAL (type), type_quals);
6636 TYPE_CANONICAL (t) = TYPE_CANONICAL (c);
6637 }
6638 else
6639 /* T is its own canonical type. */
6640 TYPE_CANONICAL (t) = t;
6641
6642 }
6643
6644 return t;
6645 }
6646
6647 /* Create a variant of type T with alignment ALIGN. */
6648
6649 tree
6650 build_aligned_type (tree type, unsigned int align)
6651 {
6652 tree t;
6653
6654 if (TYPE_PACKED (type)
6655 || TYPE_ALIGN (type) == align)
6656 return type;
6657
6658 for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
6659 if (check_aligned_type (t, type, align))
6660 return t;
6661
6662 t = build_variant_type_copy (type);
6663 SET_TYPE_ALIGN (t, align);
6664 TYPE_USER_ALIGN (t) = 1;
6665
6666 return t;
6667 }
6668
6669 /* Create a new distinct copy of TYPE. The new type is made its own
6670 MAIN_VARIANT. If TYPE requires structural equality checks, the
6671 resulting type requires structural equality checks; otherwise, its
6672 TYPE_CANONICAL points to itself. */
6673
6674 tree
6675 build_distinct_type_copy (tree type MEM_STAT_DECL)
6676 {
6677 tree t = copy_node_stat (type PASS_MEM_STAT);
6678
6679 TYPE_POINTER_TO (t) = 0;
6680 TYPE_REFERENCE_TO (t) = 0;
6681
6682 /* Set the canonical type either to a new equivalence class, or
6683 propagate the need for structural equality checks. */
6684 if (TYPE_STRUCTURAL_EQUALITY_P (type))
6685 SET_TYPE_STRUCTURAL_EQUALITY (t);
6686 else
6687 TYPE_CANONICAL (t) = t;
6688
6689 /* Make it its own variant. */
6690 TYPE_MAIN_VARIANT (t) = t;
6691 TYPE_NEXT_VARIANT (t) = 0;
6692
6693 /* We do not record methods in type copies nor variants
6694 so we do not need to keep them up to date when new method
6695 is inserted. */
6696 if (RECORD_OR_UNION_TYPE_P (t))
6697 TYPE_METHODS (t) = NULL_TREE;
6698
6699 /* Note that it is now possible for TYPE_MIN_VALUE to be a value
6700 whose TREE_TYPE is not t. This can also happen in the Ada
6701 frontend when using subtypes. */
6702
6703 return t;
6704 }
6705
6706 /* Create a new variant of TYPE, equivalent but distinct. This is so
6707 the caller can modify it. TYPE_CANONICAL for the return type will
6708 be equivalent to TYPE_CANONICAL of TYPE, indicating that the types
6709 are considered equal by the language itself (or that both types
6710 require structural equality checks). */
6711
6712 tree
6713 build_variant_type_copy (tree type MEM_STAT_DECL)
6714 {
6715 tree t, m = TYPE_MAIN_VARIANT (type);
6716
6717 t = build_distinct_type_copy (type PASS_MEM_STAT);
6718
6719 /* Since we're building a variant, assume that it is a non-semantic
6720 variant. This also propagates TYPE_STRUCTURAL_EQUALITY_P. */
6721 TYPE_CANONICAL (t) = TYPE_CANONICAL (type);
6722 /* Type variants have no alias set defined. */
6723 TYPE_ALIAS_SET (t) = -1;
6724
6725 /* Add the new type to the chain of variants of TYPE. */
6726 TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (m);
6727 TYPE_NEXT_VARIANT (m) = t;
6728 TYPE_MAIN_VARIANT (t) = m;
6729
6730 return t;
6731 }
6732 \f
6733 /* Return true if the from tree in both tree maps are equal. */
6734
6735 int
6736 tree_map_base_eq (const void *va, const void *vb)
6737 {
6738 const struct tree_map_base *const a = (const struct tree_map_base *) va,
6739 *const b = (const struct tree_map_base *) vb;
6740 return (a->from == b->from);
6741 }
6742
6743 /* Hash a from tree in a tree_base_map. */
6744
6745 unsigned int
6746 tree_map_base_hash (const void *item)
6747 {
6748 return htab_hash_pointer (((const struct tree_map_base *)item)->from);
6749 }
6750
6751 /* Return true if this tree map structure is marked for garbage collection
6752 purposes. We simply return true if the from tree is marked, so that this
6753 structure goes away when the from tree goes away. */
6754
6755 int
6756 tree_map_base_marked_p (const void *p)
6757 {
6758 return ggc_marked_p (((const struct tree_map_base *) p)->from);
6759 }
6760
6761 /* Hash a from tree in a tree_map. */
6762
6763 unsigned int
6764 tree_map_hash (const void *item)
6765 {
6766 return (((const struct tree_map *) item)->hash);
6767 }
6768
6769 /* Hash a from tree in a tree_decl_map. */
6770
6771 unsigned int
6772 tree_decl_map_hash (const void *item)
6773 {
6774 return DECL_UID (((const struct tree_decl_map *) item)->base.from);
6775 }
6776
6777 /* Return the initialization priority for DECL. */
6778
6779 priority_type
6780 decl_init_priority_lookup (tree decl)
6781 {
6782 symtab_node *snode = symtab_node::get (decl);
6783
6784 if (!snode)
6785 return DEFAULT_INIT_PRIORITY;
6786 return
6787 snode->get_init_priority ();
6788 }
6789
6790 /* Return the finalization priority for DECL. */
6791
6792 priority_type
6793 decl_fini_priority_lookup (tree decl)
6794 {
6795 cgraph_node *node = cgraph_node::get (decl);
6796
6797 if (!node)
6798 return DEFAULT_INIT_PRIORITY;
6799 return
6800 node->get_fini_priority ();
6801 }
6802
6803 /* Set the initialization priority for DECL to PRIORITY. */
6804
6805 void
6806 decl_init_priority_insert (tree decl, priority_type priority)
6807 {
6808 struct symtab_node *snode;
6809
6810 if (priority == DEFAULT_INIT_PRIORITY)
6811 {
6812 snode = symtab_node::get (decl);
6813 if (!snode)
6814 return;
6815 }
6816 else if (VAR_P (decl))
6817 snode = varpool_node::get_create (decl);
6818 else
6819 snode = cgraph_node::get_create (decl);
6820 snode->set_init_priority (priority);
6821 }
6822
6823 /* Set the finalization priority for DECL to PRIORITY. */
6824
6825 void
6826 decl_fini_priority_insert (tree decl, priority_type priority)
6827 {
6828 struct cgraph_node *node;
6829
6830 if (priority == DEFAULT_INIT_PRIORITY)
6831 {
6832 node = cgraph_node::get (decl);
6833 if (!node)
6834 return;
6835 }
6836 else
6837 node = cgraph_node::get_create (decl);
6838 node->set_fini_priority (priority);
6839 }
6840
6841 /* Print out the statistics for the DECL_DEBUG_EXPR hash table. */
6842
6843 static void
6844 print_debug_expr_statistics (void)
6845 {
6846 fprintf (stderr, "DECL_DEBUG_EXPR hash: size %ld, %ld elements, %f collisions\n",
6847 (long) debug_expr_for_decl->size (),
6848 (long) debug_expr_for_decl->elements (),
6849 debug_expr_for_decl->collisions ());
6850 }
6851
6852 /* Print out the statistics for the DECL_VALUE_EXPR hash table. */
6853
6854 static void
6855 print_value_expr_statistics (void)
6856 {
6857 fprintf (stderr, "DECL_VALUE_EXPR hash: size %ld, %ld elements, %f collisions\n",
6858 (long) value_expr_for_decl->size (),
6859 (long) value_expr_for_decl->elements (),
6860 value_expr_for_decl->collisions ());
6861 }
6862
6863 /* Lookup a debug expression for FROM, and return it if we find one. */
6864
6865 tree
6866 decl_debug_expr_lookup (tree from)
6867 {
6868 struct tree_decl_map *h, in;
6869 in.base.from = from;
6870
6871 h = debug_expr_for_decl->find_with_hash (&in, DECL_UID (from));
6872 if (h)
6873 return h->to;
6874 return NULL_TREE;
6875 }
6876
6877 /* Insert a mapping FROM->TO in the debug expression hashtable. */
6878
6879 void
6880 decl_debug_expr_insert (tree from, tree to)
6881 {
6882 struct tree_decl_map *h;
6883
6884 h = ggc_alloc<tree_decl_map> ();
6885 h->base.from = from;
6886 h->to = to;
6887 *debug_expr_for_decl->find_slot_with_hash (h, DECL_UID (from), INSERT) = h;
6888 }
6889
6890 /* Lookup a value expression for FROM, and return it if we find one. */
6891
6892 tree
6893 decl_value_expr_lookup (tree from)
6894 {
6895 struct tree_decl_map *h, in;
6896 in.base.from = from;
6897
6898 h = value_expr_for_decl->find_with_hash (&in, DECL_UID (from));
6899 if (h)
6900 return h->to;
6901 return NULL_TREE;
6902 }
6903
6904 /* Insert a mapping FROM->TO in the value expression hashtable. */
6905
6906 void
6907 decl_value_expr_insert (tree from, tree to)
6908 {
6909 struct tree_decl_map *h;
6910
6911 h = ggc_alloc<tree_decl_map> ();
6912 h->base.from = from;
6913 h->to = to;
6914 *value_expr_for_decl->find_slot_with_hash (h, DECL_UID (from), INSERT) = h;
6915 }
6916
6917 /* Lookup a vector of debug arguments for FROM, and return it if we
6918 find one. */
6919
6920 vec<tree, va_gc> **
6921 decl_debug_args_lookup (tree from)
6922 {
6923 struct tree_vec_map *h, in;
6924
6925 if (!DECL_HAS_DEBUG_ARGS_P (from))
6926 return NULL;
6927 gcc_checking_assert (debug_args_for_decl != NULL);
6928 in.base.from = from;
6929 h = debug_args_for_decl->find_with_hash (&in, DECL_UID (from));
6930 if (h)
6931 return &h->to;
6932 return NULL;
6933 }
6934
6935 /* Insert a mapping FROM->empty vector of debug arguments in the value
6936 expression hashtable. */
6937
6938 vec<tree, va_gc> **
6939 decl_debug_args_insert (tree from)
6940 {
6941 struct tree_vec_map *h;
6942 tree_vec_map **loc;
6943
6944 if (DECL_HAS_DEBUG_ARGS_P (from))
6945 return decl_debug_args_lookup (from);
6946 if (debug_args_for_decl == NULL)
6947 debug_args_for_decl = hash_table<tree_vec_map_cache_hasher>::create_ggc (64);
6948 h = ggc_alloc<tree_vec_map> ();
6949 h->base.from = from;
6950 h->to = NULL;
6951 loc = debug_args_for_decl->find_slot_with_hash (h, DECL_UID (from), INSERT);
6952 *loc = h;
6953 DECL_HAS_DEBUG_ARGS_P (from) = 1;
6954 return &h->to;
6955 }
6956
6957 /* Hashing of types so that we don't make duplicates.
6958 The entry point is `type_hash_canon'. */
6959
6960 /* Generate the default hash code for TYPE. This is designed for
6961 speed, rather than maximum entropy. */
6962
6963 hashval_t
6964 type_hash_canon_hash (tree type)
6965 {
6966 inchash::hash hstate;
6967
6968 hstate.add_int (TREE_CODE (type));
6969
6970 if (TREE_TYPE (type))
6971 hstate.add_object (TYPE_HASH (TREE_TYPE (type)));
6972
6973 for (tree t = TYPE_ATTRIBUTES (type); t; t = TREE_CHAIN (t))
6974 /* Just the identifier is adequate to distinguish. */
6975 hstate.add_object (IDENTIFIER_HASH_VALUE (get_attribute_name (t)));
6976
6977 switch (TREE_CODE (type))
6978 {
6979 case METHOD_TYPE:
6980 hstate.add_object (TYPE_HASH (TYPE_METHOD_BASETYPE (type)));
6981 /* FALLTHROUGH. */
6982 case FUNCTION_TYPE:
6983 for (tree t = TYPE_ARG_TYPES (type); t; t = TREE_CHAIN (t))
6984 if (TREE_VALUE (t) != error_mark_node)
6985 hstate.add_object (TYPE_HASH (TREE_VALUE (t)));
6986 break;
6987
6988 case OFFSET_TYPE:
6989 hstate.add_object (TYPE_HASH (TYPE_OFFSET_BASETYPE (type)));
6990 break;
6991
6992 case ARRAY_TYPE:
6993 {
6994 if (TYPE_DOMAIN (type))
6995 hstate.add_object (TYPE_HASH (TYPE_DOMAIN (type)));
6996 if (!AGGREGATE_TYPE_P (TREE_TYPE (type)))
6997 {
6998 unsigned typeless = TYPE_TYPELESS_STORAGE (type);
6999 hstate.add_object (typeless);
7000 }
7001 }
7002 break;
7003
7004 case INTEGER_TYPE:
7005 {
7006 tree t = TYPE_MAX_VALUE (type);
7007 if (!t)
7008 t = TYPE_MIN_VALUE (type);
7009 for (int i = 0; i < TREE_INT_CST_NUNITS (t); i++)
7010 hstate.add_object (TREE_INT_CST_ELT (t, i));
7011 break;
7012 }
7013
7014 case REAL_TYPE:
7015 case FIXED_POINT_TYPE:
7016 {
7017 unsigned prec = TYPE_PRECISION (type);
7018 hstate.add_object (prec);
7019 break;
7020 }
7021
7022 case VECTOR_TYPE:
7023 {
7024 unsigned nunits = TYPE_VECTOR_SUBPARTS (type);
7025 hstate.add_object (nunits);
7026 break;
7027 }
7028
7029 default:
7030 break;
7031 }
7032
7033 return hstate.end ();
7034 }
7035
7036 /* These are the Hashtable callback functions. */
7037
7038 /* Returns true iff the types are equivalent. */
7039
7040 bool
7041 type_cache_hasher::equal (type_hash *a, type_hash *b)
7042 {
7043 /* First test the things that are the same for all types. */
7044 if (a->hash != b->hash
7045 || TREE_CODE (a->type) != TREE_CODE (b->type)
7046 || TREE_TYPE (a->type) != TREE_TYPE (b->type)
7047 || !attribute_list_equal (TYPE_ATTRIBUTES (a->type),
7048 TYPE_ATTRIBUTES (b->type))
7049 || (TREE_CODE (a->type) != COMPLEX_TYPE
7050 && TYPE_NAME (a->type) != TYPE_NAME (b->type)))
7051 return 0;
7052
7053 /* Be careful about comparing arrays before and after the element type
7054 has been completed; don't compare TYPE_ALIGN unless both types are
7055 complete. */
7056 if (COMPLETE_TYPE_P (a->type) && COMPLETE_TYPE_P (b->type)
7057 && (TYPE_ALIGN (a->type) != TYPE_ALIGN (b->type)
7058 || TYPE_MODE (a->type) != TYPE_MODE (b->type)))
7059 return 0;
7060
7061 switch (TREE_CODE (a->type))
7062 {
7063 case VOID_TYPE:
7064 case COMPLEX_TYPE:
7065 case POINTER_TYPE:
7066 case REFERENCE_TYPE:
7067 case NULLPTR_TYPE:
7068 return 1;
7069
7070 case VECTOR_TYPE:
7071 return TYPE_VECTOR_SUBPARTS (a->type) == TYPE_VECTOR_SUBPARTS (b->type);
7072
7073 case ENUMERAL_TYPE:
7074 if (TYPE_VALUES (a->type) != TYPE_VALUES (b->type)
7075 && !(TYPE_VALUES (a->type)
7076 && TREE_CODE (TYPE_VALUES (a->type)) == TREE_LIST
7077 && TYPE_VALUES (b->type)
7078 && TREE_CODE (TYPE_VALUES (b->type)) == TREE_LIST
7079 && type_list_equal (TYPE_VALUES (a->type),
7080 TYPE_VALUES (b->type))))
7081 return 0;
7082
7083 /* fall through */
7084
7085 case INTEGER_TYPE:
7086 case REAL_TYPE:
7087 case BOOLEAN_TYPE:
7088 if (TYPE_PRECISION (a->type) != TYPE_PRECISION (b->type))
7089 return false;
7090 return ((TYPE_MAX_VALUE (a->type) == TYPE_MAX_VALUE (b->type)
7091 || tree_int_cst_equal (TYPE_MAX_VALUE (a->type),
7092 TYPE_MAX_VALUE (b->type)))
7093 && (TYPE_MIN_VALUE (a->type) == TYPE_MIN_VALUE (b->type)
7094 || tree_int_cst_equal (TYPE_MIN_VALUE (a->type),
7095 TYPE_MIN_VALUE (b->type))));
7096
7097 case FIXED_POINT_TYPE:
7098 return TYPE_SATURATING (a->type) == TYPE_SATURATING (b->type);
7099
7100 case OFFSET_TYPE:
7101 return TYPE_OFFSET_BASETYPE (a->type) == TYPE_OFFSET_BASETYPE (b->type);
7102
7103 case METHOD_TYPE:
7104 if (TYPE_METHOD_BASETYPE (a->type) == TYPE_METHOD_BASETYPE (b->type)
7105 && (TYPE_ARG_TYPES (a->type) == TYPE_ARG_TYPES (b->type)
7106 || (TYPE_ARG_TYPES (a->type)
7107 && TREE_CODE (TYPE_ARG_TYPES (a->type)) == TREE_LIST
7108 && TYPE_ARG_TYPES (b->type)
7109 && TREE_CODE (TYPE_ARG_TYPES (b->type)) == TREE_LIST
7110 && type_list_equal (TYPE_ARG_TYPES (a->type),
7111 TYPE_ARG_TYPES (b->type)))))
7112 break;
7113 return 0;
7114 case ARRAY_TYPE:
7115 /* Don't compare TYPE_TYPELESS_STORAGE flag on aggregates,
7116 where the flag should be inherited from the element type
7117 and can change after ARRAY_TYPEs are created; on non-aggregates
7118 compare it and hash it, scalars will never have that flag set
7119 and we need to differentiate between arrays created by different
7120 front-ends or middle-end created arrays. */
7121 return (TYPE_DOMAIN (a->type) == TYPE_DOMAIN (b->type)
7122 && (AGGREGATE_TYPE_P (TREE_TYPE (a->type))
7123 || (TYPE_TYPELESS_STORAGE (a->type)
7124 == TYPE_TYPELESS_STORAGE (b->type))));
7125
7126 case RECORD_TYPE:
7127 case UNION_TYPE:
7128 case QUAL_UNION_TYPE:
7129 return (TYPE_FIELDS (a->type) == TYPE_FIELDS (b->type)
7130 || (TYPE_FIELDS (a->type)
7131 && TREE_CODE (TYPE_FIELDS (a->type)) == TREE_LIST
7132 && TYPE_FIELDS (b->type)
7133 && TREE_CODE (TYPE_FIELDS (b->type)) == TREE_LIST
7134 && type_list_equal (TYPE_FIELDS (a->type),
7135 TYPE_FIELDS (b->type))));
7136
7137 case FUNCTION_TYPE:
7138 if (TYPE_ARG_TYPES (a->type) == TYPE_ARG_TYPES (b->type)
7139 || (TYPE_ARG_TYPES (a->type)
7140 && TREE_CODE (TYPE_ARG_TYPES (a->type)) == TREE_LIST
7141 && TYPE_ARG_TYPES (b->type)
7142 && TREE_CODE (TYPE_ARG_TYPES (b->type)) == TREE_LIST
7143 && type_list_equal (TYPE_ARG_TYPES (a->type),
7144 TYPE_ARG_TYPES (b->type))))
7145 break;
7146 return 0;
7147
7148 default:
7149 return 0;
7150 }
7151
7152 if (lang_hooks.types.type_hash_eq != NULL)
7153 return lang_hooks.types.type_hash_eq (a->type, b->type);
7154
7155 return 1;
7156 }
7157
7158 /* Given TYPE, and HASHCODE its hash code, return the canonical
7159 object for an identical type if one already exists.
7160 Otherwise, return TYPE, and record it as the canonical object.
7161
7162 To use this function, first create a type of the sort you want.
7163 Then compute its hash code from the fields of the type that
7164 make it different from other similar types.
7165 Then call this function and use the value. */
7166
7167 tree
7168 type_hash_canon (unsigned int hashcode, tree type)
7169 {
7170 type_hash in;
7171 type_hash **loc;
7172
7173 /* The hash table only contains main variants, so ensure that's what we're
7174 being passed. */
7175 gcc_assert (TYPE_MAIN_VARIANT (type) == type);
7176
7177 /* The TYPE_ALIGN field of a type is set by layout_type(), so we
7178 must call that routine before comparing TYPE_ALIGNs. */
7179 layout_type (type);
7180
7181 in.hash = hashcode;
7182 in.type = type;
7183
7184 loc = type_hash_table->find_slot_with_hash (&in, hashcode, INSERT);
7185 if (*loc)
7186 {
7187 tree t1 = ((type_hash *) *loc)->type;
7188 gcc_assert (TYPE_MAIN_VARIANT (t1) == t1);
7189 if (TYPE_UID (type) + 1 == next_type_uid)
7190 --next_type_uid;
7191 /* Free also min/max values and the cache for integer
7192 types. This can't be done in free_node, as LTO frees
7193 those on its own. */
7194 if (TREE_CODE (type) == INTEGER_TYPE)
7195 {
7196 if (TYPE_MIN_VALUE (type)
7197 && TREE_TYPE (TYPE_MIN_VALUE (type)) == type)
7198 ggc_free (TYPE_MIN_VALUE (type));
7199 if (TYPE_MAX_VALUE (type)
7200 && TREE_TYPE (TYPE_MAX_VALUE (type)) == type)
7201 ggc_free (TYPE_MAX_VALUE (type));
7202 if (TYPE_CACHED_VALUES_P (type))
7203 ggc_free (TYPE_CACHED_VALUES (type));
7204 }
7205 free_node (type);
7206 return t1;
7207 }
7208 else
7209 {
7210 struct type_hash *h;
7211
7212 h = ggc_alloc<type_hash> ();
7213 h->hash = hashcode;
7214 h->type = type;
7215 *loc = h;
7216
7217 return type;
7218 }
7219 }
7220
7221 static void
7222 print_type_hash_statistics (void)
7223 {
7224 fprintf (stderr, "Type hash: size %ld, %ld elements, %f collisions\n",
7225 (long) type_hash_table->size (),
7226 (long) type_hash_table->elements (),
7227 type_hash_table->collisions ());
7228 }
7229
7230 /* Given two lists of attributes, return true if list l2 is
7231 equivalent to l1. */
7232
7233 int
7234 attribute_list_equal (const_tree l1, const_tree l2)
7235 {
7236 if (l1 == l2)
7237 return 1;
7238
7239 return attribute_list_contained (l1, l2)
7240 && attribute_list_contained (l2, l1);
7241 }
7242
7243 /* Given two lists of attributes, return true if list L2 is
7244 completely contained within L1. */
7245 /* ??? This would be faster if attribute names were stored in a canonicalized
7246 form. Otherwise, if L1 uses `foo' and L2 uses `__foo__', the long method
7247 must be used to show these elements are equivalent (which they are). */
7248 /* ??? It's not clear that attributes with arguments will always be handled
7249 correctly. */
7250
7251 int
7252 attribute_list_contained (const_tree l1, const_tree l2)
7253 {
7254 const_tree t1, t2;
7255
7256 /* First check the obvious, maybe the lists are identical. */
7257 if (l1 == l2)
7258 return 1;
7259
7260 /* Maybe the lists are similar. */
7261 for (t1 = l1, t2 = l2;
7262 t1 != 0 && t2 != 0
7263 && get_attribute_name (t1) == get_attribute_name (t2)
7264 && TREE_VALUE (t1) == TREE_VALUE (t2);
7265 t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2))
7266 ;
7267
7268 /* Maybe the lists are equal. */
7269 if (t1 == 0 && t2 == 0)
7270 return 1;
7271
7272 for (; t2 != 0; t2 = TREE_CHAIN (t2))
7273 {
7274 const_tree attr;
7275 /* This CONST_CAST is okay because lookup_attribute does not
7276 modify its argument and the return value is assigned to a
7277 const_tree. */
7278 for (attr = lookup_ident_attribute (get_attribute_name (t2),
7279 CONST_CAST_TREE (l1));
7280 attr != NULL_TREE && !attribute_value_equal (t2, attr);
7281 attr = lookup_ident_attribute (get_attribute_name (t2),
7282 TREE_CHAIN (attr)))
7283 ;
7284
7285 if (attr == NULL_TREE)
7286 return 0;
7287 }
7288
7289 return 1;
7290 }
7291
7292 /* Given two lists of types
7293 (chains of TREE_LIST nodes with types in the TREE_VALUE slots)
7294 return 1 if the lists contain the same types in the same order.
7295 Also, the TREE_PURPOSEs must match. */
7296
7297 int
7298 type_list_equal (const_tree l1, const_tree l2)
7299 {
7300 const_tree t1, t2;
7301
7302 for (t1 = l1, t2 = l2; t1 && t2; t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2))
7303 if (TREE_VALUE (t1) != TREE_VALUE (t2)
7304 || (TREE_PURPOSE (t1) != TREE_PURPOSE (t2)
7305 && ! (1 == simple_cst_equal (TREE_PURPOSE (t1), TREE_PURPOSE (t2))
7306 && (TREE_TYPE (TREE_PURPOSE (t1))
7307 == TREE_TYPE (TREE_PURPOSE (t2))))))
7308 return 0;
7309
7310 return t1 == t2;
7311 }
7312
7313 /* Returns the number of arguments to the FUNCTION_TYPE or METHOD_TYPE
7314 given by TYPE. If the argument list accepts variable arguments,
7315 then this function counts only the ordinary arguments. */
7316
7317 int
7318 type_num_arguments (const_tree type)
7319 {
7320 int i = 0;
7321 tree t;
7322
7323 for (t = TYPE_ARG_TYPES (type); t; t = TREE_CHAIN (t))
7324 /* If the function does not take a variable number of arguments,
7325 the last element in the list will have type `void'. */
7326 if (VOID_TYPE_P (TREE_VALUE (t)))
7327 break;
7328 else
7329 ++i;
7330
7331 return i;
7332 }
7333
7334 /* Nonzero if integer constants T1 and T2
7335 represent the same constant value. */
7336
7337 int
7338 tree_int_cst_equal (const_tree t1, const_tree t2)
7339 {
7340 if (t1 == t2)
7341 return 1;
7342
7343 if (t1 == 0 || t2 == 0)
7344 return 0;
7345
7346 if (TREE_CODE (t1) == INTEGER_CST
7347 && TREE_CODE (t2) == INTEGER_CST
7348 && wi::to_widest (t1) == wi::to_widest (t2))
7349 return 1;
7350
7351 return 0;
7352 }
7353
7354 /* Return true if T is an INTEGER_CST whose numerical value (extended
7355 according to TYPE_UNSIGNED) fits in a signed HOST_WIDE_INT. */
7356
7357 bool
7358 tree_fits_shwi_p (const_tree t)
7359 {
7360 return (t != NULL_TREE
7361 && TREE_CODE (t) == INTEGER_CST
7362 && wi::fits_shwi_p (wi::to_widest (t)));
7363 }
7364
7365 /* Return true if T is an INTEGER_CST whose numerical value (extended
7366 according to TYPE_UNSIGNED) fits in an unsigned HOST_WIDE_INT. */
7367
7368 bool
7369 tree_fits_uhwi_p (const_tree t)
7370 {
7371 return (t != NULL_TREE
7372 && TREE_CODE (t) == INTEGER_CST
7373 && wi::fits_uhwi_p (wi::to_widest (t)));
7374 }
7375
7376 /* T is an INTEGER_CST whose numerical value (extended according to
7377 TYPE_UNSIGNED) fits in a signed HOST_WIDE_INT. Return that
7378 HOST_WIDE_INT. */
7379
7380 HOST_WIDE_INT
7381 tree_to_shwi (const_tree t)
7382 {
7383 gcc_assert (tree_fits_shwi_p (t));
7384 return TREE_INT_CST_LOW (t);
7385 }
7386
7387 /* T is an INTEGER_CST whose numerical value (extended according to
7388 TYPE_UNSIGNED) fits in an unsigned HOST_WIDE_INT. Return that
7389 HOST_WIDE_INT. */
7390
7391 unsigned HOST_WIDE_INT
7392 tree_to_uhwi (const_tree t)
7393 {
7394 gcc_assert (tree_fits_uhwi_p (t));
7395 return TREE_INT_CST_LOW (t);
7396 }
7397
7398 /* Return the most significant (sign) bit of T. */
7399
7400 int
7401 tree_int_cst_sign_bit (const_tree t)
7402 {
7403 unsigned bitno = TYPE_PRECISION (TREE_TYPE (t)) - 1;
7404
7405 return wi::extract_uhwi (t, bitno, 1);
7406 }
7407
7408 /* Return an indication of the sign of the integer constant T.
7409 The return value is -1 if T < 0, 0 if T == 0, and 1 if T > 0.
7410 Note that -1 will never be returned if T's type is unsigned. */
7411
7412 int
7413 tree_int_cst_sgn (const_tree t)
7414 {
7415 if (wi::eq_p (t, 0))
7416 return 0;
7417 else if (TYPE_UNSIGNED (TREE_TYPE (t)))
7418 return 1;
7419 else if (wi::neg_p (t))
7420 return -1;
7421 else
7422 return 1;
7423 }
7424
7425 /* Return the minimum number of bits needed to represent VALUE in a
7426 signed or unsigned type, UNSIGNEDP says which. */
7427
7428 unsigned int
7429 tree_int_cst_min_precision (tree value, signop sgn)
7430 {
7431 /* If the value is negative, compute its negative minus 1. The latter
7432 adjustment is because the absolute value of the largest negative value
7433 is one larger than the largest positive value. This is equivalent to
7434 a bit-wise negation, so use that operation instead. */
7435
7436 if (tree_int_cst_sgn (value) < 0)
7437 value = fold_build1 (BIT_NOT_EXPR, TREE_TYPE (value), value);
7438
7439 /* Return the number of bits needed, taking into account the fact
7440 that we need one more bit for a signed than unsigned type.
7441 If value is 0 or -1, the minimum precision is 1 no matter
7442 whether unsignedp is true or false. */
7443
7444 if (integer_zerop (value))
7445 return 1;
7446 else
7447 return tree_floor_log2 (value) + 1 + (sgn == SIGNED ? 1 : 0) ;
7448 }
7449
7450 /* Return truthvalue of whether T1 is the same tree structure as T2.
7451 Return 1 if they are the same.
7452 Return 0 if they are understandably different.
7453 Return -1 if either contains tree structure not understood by
7454 this function. */
7455
7456 int
7457 simple_cst_equal (const_tree t1, const_tree t2)
7458 {
7459 enum tree_code code1, code2;
7460 int cmp;
7461 int i;
7462
7463 if (t1 == t2)
7464 return 1;
7465 if (t1 == 0 || t2 == 0)
7466 return 0;
7467
7468 code1 = TREE_CODE (t1);
7469 code2 = TREE_CODE (t2);
7470
7471 if (CONVERT_EXPR_CODE_P (code1) || code1 == NON_LVALUE_EXPR)
7472 {
7473 if (CONVERT_EXPR_CODE_P (code2)
7474 || code2 == NON_LVALUE_EXPR)
7475 return simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
7476 else
7477 return simple_cst_equal (TREE_OPERAND (t1, 0), t2);
7478 }
7479
7480 else if (CONVERT_EXPR_CODE_P (code2)
7481 || code2 == NON_LVALUE_EXPR)
7482 return simple_cst_equal (t1, TREE_OPERAND (t2, 0));
7483
7484 if (code1 != code2)
7485 return 0;
7486
7487 switch (code1)
7488 {
7489 case INTEGER_CST:
7490 return wi::to_widest (t1) == wi::to_widest (t2);
7491
7492 case REAL_CST:
7493 return real_identical (&TREE_REAL_CST (t1), &TREE_REAL_CST (t2));
7494
7495 case FIXED_CST:
7496 return FIXED_VALUES_IDENTICAL (TREE_FIXED_CST (t1), TREE_FIXED_CST (t2));
7497
7498 case STRING_CST:
7499 return (TREE_STRING_LENGTH (t1) == TREE_STRING_LENGTH (t2)
7500 && ! memcmp (TREE_STRING_POINTER (t1), TREE_STRING_POINTER (t2),
7501 TREE_STRING_LENGTH (t1)));
7502
7503 case CONSTRUCTOR:
7504 {
7505 unsigned HOST_WIDE_INT idx;
7506 vec<constructor_elt, va_gc> *v1 = CONSTRUCTOR_ELTS (t1);
7507 vec<constructor_elt, va_gc> *v2 = CONSTRUCTOR_ELTS (t2);
7508
7509 if (vec_safe_length (v1) != vec_safe_length (v2))
7510 return false;
7511
7512 for (idx = 0; idx < vec_safe_length (v1); ++idx)
7513 /* ??? Should we handle also fields here? */
7514 if (!simple_cst_equal ((*v1)[idx].value, (*v2)[idx].value))
7515 return false;
7516 return true;
7517 }
7518
7519 case SAVE_EXPR:
7520 return simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
7521
7522 case CALL_EXPR:
7523 cmp = simple_cst_equal (CALL_EXPR_FN (t1), CALL_EXPR_FN (t2));
7524 if (cmp <= 0)
7525 return cmp;
7526 if (call_expr_nargs (t1) != call_expr_nargs (t2))
7527 return 0;
7528 {
7529 const_tree arg1, arg2;
7530 const_call_expr_arg_iterator iter1, iter2;
7531 for (arg1 = first_const_call_expr_arg (t1, &iter1),
7532 arg2 = first_const_call_expr_arg (t2, &iter2);
7533 arg1 && arg2;
7534 arg1 = next_const_call_expr_arg (&iter1),
7535 arg2 = next_const_call_expr_arg (&iter2))
7536 {
7537 cmp = simple_cst_equal (arg1, arg2);
7538 if (cmp <= 0)
7539 return cmp;
7540 }
7541 return arg1 == arg2;
7542 }
7543
7544 case TARGET_EXPR:
7545 /* Special case: if either target is an unallocated VAR_DECL,
7546 it means that it's going to be unified with whatever the
7547 TARGET_EXPR is really supposed to initialize, so treat it
7548 as being equivalent to anything. */
7549 if ((TREE_CODE (TREE_OPERAND (t1, 0)) == VAR_DECL
7550 && DECL_NAME (TREE_OPERAND (t1, 0)) == NULL_TREE
7551 && !DECL_RTL_SET_P (TREE_OPERAND (t1, 0)))
7552 || (TREE_CODE (TREE_OPERAND (t2, 0)) == VAR_DECL
7553 && DECL_NAME (TREE_OPERAND (t2, 0)) == NULL_TREE
7554 && !DECL_RTL_SET_P (TREE_OPERAND (t2, 0))))
7555 cmp = 1;
7556 else
7557 cmp = simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
7558
7559 if (cmp <= 0)
7560 return cmp;
7561
7562 return simple_cst_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1));
7563
7564 case WITH_CLEANUP_EXPR:
7565 cmp = simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
7566 if (cmp <= 0)
7567 return cmp;
7568
7569 return simple_cst_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t1, 1));
7570
7571 case COMPONENT_REF:
7572 if (TREE_OPERAND (t1, 1) == TREE_OPERAND (t2, 1))
7573 return simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
7574
7575 return 0;
7576
7577 case VAR_DECL:
7578 case PARM_DECL:
7579 case CONST_DECL:
7580 case FUNCTION_DECL:
7581 return 0;
7582
7583 default:
7584 break;
7585 }
7586
7587 /* This general rule works for most tree codes. All exceptions should be
7588 handled above. If this is a language-specific tree code, we can't
7589 trust what might be in the operand, so say we don't know
7590 the situation. */
7591 if ((int) code1 >= (int) LAST_AND_UNUSED_TREE_CODE)
7592 return -1;
7593
7594 switch (TREE_CODE_CLASS (code1))
7595 {
7596 case tcc_unary:
7597 case tcc_binary:
7598 case tcc_comparison:
7599 case tcc_expression:
7600 case tcc_reference:
7601 case tcc_statement:
7602 cmp = 1;
7603 for (i = 0; i < TREE_CODE_LENGTH (code1); i++)
7604 {
7605 cmp = simple_cst_equal (TREE_OPERAND (t1, i), TREE_OPERAND (t2, i));
7606 if (cmp <= 0)
7607 return cmp;
7608 }
7609
7610 return cmp;
7611
7612 default:
7613 return -1;
7614 }
7615 }
7616
7617 /* Compare the value of T, an INTEGER_CST, with U, an unsigned integer value.
7618 Return -1, 0, or 1 if the value of T is less than, equal to, or greater
7619 than U, respectively. */
7620
7621 int
7622 compare_tree_int (const_tree t, unsigned HOST_WIDE_INT u)
7623 {
7624 if (tree_int_cst_sgn (t) < 0)
7625 return -1;
7626 else if (!tree_fits_uhwi_p (t))
7627 return 1;
7628 else if (TREE_INT_CST_LOW (t) == u)
7629 return 0;
7630 else if (TREE_INT_CST_LOW (t) < u)
7631 return -1;
7632 else
7633 return 1;
7634 }
7635
7636 /* Return true if SIZE represents a constant size that is in bounds of
7637 what the middle-end and the backend accepts (covering not more than
7638 half of the address-space). */
7639
7640 bool
7641 valid_constant_size_p (const_tree size)
7642 {
7643 if (! tree_fits_uhwi_p (size)
7644 || TREE_OVERFLOW (size)
7645 || tree_int_cst_sign_bit (size) != 0)
7646 return false;
7647 return true;
7648 }
7649
7650 /* Return the precision of the type, or for a complex or vector type the
7651 precision of the type of its elements. */
7652
7653 unsigned int
7654 element_precision (const_tree type)
7655 {
7656 if (!TYPE_P (type))
7657 type = TREE_TYPE (type);
7658 enum tree_code code = TREE_CODE (type);
7659 if (code == COMPLEX_TYPE || code == VECTOR_TYPE)
7660 type = TREE_TYPE (type);
7661
7662 return TYPE_PRECISION (type);
7663 }
7664
7665 /* Return true if CODE represents an associative tree code. Otherwise
7666 return false. */
7667 bool
7668 associative_tree_code (enum tree_code code)
7669 {
7670 switch (code)
7671 {
7672 case BIT_IOR_EXPR:
7673 case BIT_AND_EXPR:
7674 case BIT_XOR_EXPR:
7675 case PLUS_EXPR:
7676 case MULT_EXPR:
7677 case MIN_EXPR:
7678 case MAX_EXPR:
7679 return true;
7680
7681 default:
7682 break;
7683 }
7684 return false;
7685 }
7686
7687 /* Return true if CODE represents a commutative tree code. Otherwise
7688 return false. */
7689 bool
7690 commutative_tree_code (enum tree_code code)
7691 {
7692 switch (code)
7693 {
7694 case PLUS_EXPR:
7695 case MULT_EXPR:
7696 case MULT_HIGHPART_EXPR:
7697 case MIN_EXPR:
7698 case MAX_EXPR:
7699 case BIT_IOR_EXPR:
7700 case BIT_XOR_EXPR:
7701 case BIT_AND_EXPR:
7702 case NE_EXPR:
7703 case EQ_EXPR:
7704 case UNORDERED_EXPR:
7705 case ORDERED_EXPR:
7706 case UNEQ_EXPR:
7707 case LTGT_EXPR:
7708 case TRUTH_AND_EXPR:
7709 case TRUTH_XOR_EXPR:
7710 case TRUTH_OR_EXPR:
7711 case WIDEN_MULT_EXPR:
7712 case VEC_WIDEN_MULT_HI_EXPR:
7713 case VEC_WIDEN_MULT_LO_EXPR:
7714 case VEC_WIDEN_MULT_EVEN_EXPR:
7715 case VEC_WIDEN_MULT_ODD_EXPR:
7716 return true;
7717
7718 default:
7719 break;
7720 }
7721 return false;
7722 }
7723
7724 /* Return true if CODE represents a ternary tree code for which the
7725 first two operands are commutative. Otherwise return false. */
7726 bool
7727 commutative_ternary_tree_code (enum tree_code code)
7728 {
7729 switch (code)
7730 {
7731 case WIDEN_MULT_PLUS_EXPR:
7732 case WIDEN_MULT_MINUS_EXPR:
7733 case DOT_PROD_EXPR:
7734 case FMA_EXPR:
7735 return true;
7736
7737 default:
7738 break;
7739 }
7740 return false;
7741 }
7742
7743 /* Returns true if CODE can overflow. */
7744
7745 bool
7746 operation_can_overflow (enum tree_code code)
7747 {
7748 switch (code)
7749 {
7750 case PLUS_EXPR:
7751 case MINUS_EXPR:
7752 case MULT_EXPR:
7753 case LSHIFT_EXPR:
7754 /* Can overflow in various ways. */
7755 return true;
7756 case TRUNC_DIV_EXPR:
7757 case EXACT_DIV_EXPR:
7758 case FLOOR_DIV_EXPR:
7759 case CEIL_DIV_EXPR:
7760 /* For INT_MIN / -1. */
7761 return true;
7762 case NEGATE_EXPR:
7763 case ABS_EXPR:
7764 /* For -INT_MIN. */
7765 return true;
7766 default:
7767 /* These operators cannot overflow. */
7768 return false;
7769 }
7770 }
7771
7772 /* Returns true if CODE operating on operands of type TYPE doesn't overflow, or
7773 ftrapv doesn't generate trapping insns for CODE. */
7774
7775 bool
7776 operation_no_trapping_overflow (tree type, enum tree_code code)
7777 {
7778 gcc_checking_assert (ANY_INTEGRAL_TYPE_P (type));
7779
7780 /* We don't generate instructions that trap on overflow for complex or vector
7781 types. */
7782 if (!INTEGRAL_TYPE_P (type))
7783 return true;
7784
7785 if (!TYPE_OVERFLOW_TRAPS (type))
7786 return true;
7787
7788 switch (code)
7789 {
7790 case PLUS_EXPR:
7791 case MINUS_EXPR:
7792 case MULT_EXPR:
7793 case NEGATE_EXPR:
7794 case ABS_EXPR:
7795 /* These operators can overflow, and -ftrapv generates trapping code for
7796 these. */
7797 return false;
7798 case TRUNC_DIV_EXPR:
7799 case EXACT_DIV_EXPR:
7800 case FLOOR_DIV_EXPR:
7801 case CEIL_DIV_EXPR:
7802 case LSHIFT_EXPR:
7803 /* These operators can overflow, but -ftrapv does not generate trapping
7804 code for these. */
7805 return true;
7806 default:
7807 /* These operators cannot overflow. */
7808 return true;
7809 }
7810 }
7811
7812 namespace inchash
7813 {
7814
7815 /* Generate a hash value for an expression. This can be used iteratively
7816 by passing a previous result as the HSTATE argument.
7817
7818 This function is intended to produce the same hash for expressions which
7819 would compare equal using operand_equal_p. */
7820 void
7821 add_expr (const_tree t, inchash::hash &hstate, unsigned int flags)
7822 {
7823 int i;
7824 enum tree_code code;
7825 enum tree_code_class tclass;
7826
7827 if (t == NULL_TREE || t == error_mark_node)
7828 {
7829 hstate.merge_hash (0);
7830 return;
7831 }
7832
7833 if (!(flags & OEP_ADDRESS_OF))
7834 STRIP_NOPS (t);
7835
7836 code = TREE_CODE (t);
7837
7838 switch (code)
7839 {
7840 /* Alas, constants aren't shared, so we can't rely on pointer
7841 identity. */
7842 case VOID_CST:
7843 hstate.merge_hash (0);
7844 return;
7845 case INTEGER_CST:
7846 gcc_checking_assert (!(flags & OEP_ADDRESS_OF));
7847 for (i = 0; i < TREE_INT_CST_EXT_NUNITS (t); i++)
7848 hstate.add_wide_int (TREE_INT_CST_ELT (t, i));
7849 return;
7850 case REAL_CST:
7851 {
7852 unsigned int val2;
7853 if (!HONOR_SIGNED_ZEROS (t) && real_zerop (t))
7854 val2 = rvc_zero;
7855 else
7856 val2 = real_hash (TREE_REAL_CST_PTR (t));
7857 hstate.merge_hash (val2);
7858 return;
7859 }
7860 case FIXED_CST:
7861 {
7862 unsigned int val2 = fixed_hash (TREE_FIXED_CST_PTR (t));
7863 hstate.merge_hash (val2);
7864 return;
7865 }
7866 case STRING_CST:
7867 hstate.add ((const void *) TREE_STRING_POINTER (t),
7868 TREE_STRING_LENGTH (t));
7869 return;
7870 case COMPLEX_CST:
7871 inchash::add_expr (TREE_REALPART (t), hstate, flags);
7872 inchash::add_expr (TREE_IMAGPART (t), hstate, flags);
7873 return;
7874 case VECTOR_CST:
7875 {
7876 unsigned i;
7877 for (i = 0; i < VECTOR_CST_NELTS (t); ++i)
7878 inchash::add_expr (VECTOR_CST_ELT (t, i), hstate, flags);
7879 return;
7880 }
7881 case SSA_NAME:
7882 /* We can just compare by pointer. */
7883 hstate.add_wide_int (SSA_NAME_VERSION (t));
7884 return;
7885 case PLACEHOLDER_EXPR:
7886 /* The node itself doesn't matter. */
7887 return;
7888 case BLOCK:
7889 case OMP_CLAUSE:
7890 /* Ignore. */
7891 return;
7892 case TREE_LIST:
7893 /* A list of expressions, for a CALL_EXPR or as the elements of a
7894 VECTOR_CST. */
7895 for (; t; t = TREE_CHAIN (t))
7896 inchash::add_expr (TREE_VALUE (t), hstate, flags);
7897 return;
7898 case CONSTRUCTOR:
7899 {
7900 unsigned HOST_WIDE_INT idx;
7901 tree field, value;
7902 flags &= ~OEP_ADDRESS_OF;
7903 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t), idx, field, value)
7904 {
7905 inchash::add_expr (field, hstate, flags);
7906 inchash::add_expr (value, hstate, flags);
7907 }
7908 return;
7909 }
7910 case STATEMENT_LIST:
7911 {
7912 tree_stmt_iterator i;
7913 for (i = tsi_start (CONST_CAST_TREE (t));
7914 !tsi_end_p (i); tsi_next (&i))
7915 inchash::add_expr (tsi_stmt (i), hstate, flags);
7916 return;
7917 }
7918 case TREE_VEC:
7919 for (i = 0; i < TREE_VEC_LENGTH (t); ++i)
7920 inchash::add_expr (TREE_VEC_ELT (t, i), hstate, flags);
7921 return;
7922 case FUNCTION_DECL:
7923 /* When referring to a built-in FUNCTION_DECL, use the __builtin__ form.
7924 Otherwise nodes that compare equal according to operand_equal_p might
7925 get different hash codes. However, don't do this for machine specific
7926 or front end builtins, since the function code is overloaded in those
7927 cases. */
7928 if (DECL_BUILT_IN_CLASS (t) == BUILT_IN_NORMAL
7929 && builtin_decl_explicit_p (DECL_FUNCTION_CODE (t)))
7930 {
7931 t = builtin_decl_explicit (DECL_FUNCTION_CODE (t));
7932 code = TREE_CODE (t);
7933 }
7934 /* FALL THROUGH */
7935 default:
7936 tclass = TREE_CODE_CLASS (code);
7937
7938 if (tclass == tcc_declaration)
7939 {
7940 /* DECL's have a unique ID */
7941 hstate.add_wide_int (DECL_UID (t));
7942 }
7943 else if (tclass == tcc_comparison && !commutative_tree_code (code))
7944 {
7945 /* For comparisons that can be swapped, use the lower
7946 tree code. */
7947 enum tree_code ccode = swap_tree_comparison (code);
7948 if (code < ccode)
7949 ccode = code;
7950 hstate.add_object (ccode);
7951 inchash::add_expr (TREE_OPERAND (t, ccode != code), hstate, flags);
7952 inchash::add_expr (TREE_OPERAND (t, ccode == code), hstate, flags);
7953 }
7954 else if (CONVERT_EXPR_CODE_P (code))
7955 {
7956 /* NOP_EXPR and CONVERT_EXPR are considered equal by
7957 operand_equal_p. */
7958 enum tree_code ccode = NOP_EXPR;
7959 hstate.add_object (ccode);
7960
7961 /* Don't hash the type, that can lead to having nodes which
7962 compare equal according to operand_equal_p, but which
7963 have different hash codes. Make sure to include signedness
7964 in the hash computation. */
7965 hstate.add_int (TYPE_UNSIGNED (TREE_TYPE (t)));
7966 inchash::add_expr (TREE_OPERAND (t, 0), hstate, flags);
7967 }
7968 /* For OEP_ADDRESS_OF, hash MEM_EXPR[&decl, 0] the same as decl. */
7969 else if (code == MEM_REF
7970 && (flags & OEP_ADDRESS_OF) != 0
7971 && TREE_CODE (TREE_OPERAND (t, 0)) == ADDR_EXPR
7972 && DECL_P (TREE_OPERAND (TREE_OPERAND (t, 0), 0))
7973 && integer_zerop (TREE_OPERAND (t, 1)))
7974 inchash::add_expr (TREE_OPERAND (TREE_OPERAND (t, 0), 0),
7975 hstate, flags);
7976 /* Don't ICE on FE specific trees, or their arguments etc.
7977 during operand_equal_p hash verification. */
7978 else if (!IS_EXPR_CODE_CLASS (tclass))
7979 gcc_assert (flags & OEP_HASH_CHECK);
7980 else
7981 {
7982 unsigned int sflags = flags;
7983
7984 hstate.add_object (code);
7985
7986 switch (code)
7987 {
7988 case ADDR_EXPR:
7989 gcc_checking_assert (!(flags & OEP_ADDRESS_OF));
7990 flags |= OEP_ADDRESS_OF;
7991 sflags = flags;
7992 break;
7993
7994 case INDIRECT_REF:
7995 case MEM_REF:
7996 case TARGET_MEM_REF:
7997 flags &= ~OEP_ADDRESS_OF;
7998 sflags = flags;
7999 break;
8000
8001 case ARRAY_REF:
8002 case ARRAY_RANGE_REF:
8003 case COMPONENT_REF:
8004 case BIT_FIELD_REF:
8005 sflags &= ~OEP_ADDRESS_OF;
8006 break;
8007
8008 case COND_EXPR:
8009 flags &= ~OEP_ADDRESS_OF;
8010 break;
8011
8012 case FMA_EXPR:
8013 case WIDEN_MULT_PLUS_EXPR:
8014 case WIDEN_MULT_MINUS_EXPR:
8015 {
8016 /* The multiplication operands are commutative. */
8017 inchash::hash one, two;
8018 inchash::add_expr (TREE_OPERAND (t, 0), one, flags);
8019 inchash::add_expr (TREE_OPERAND (t, 1), two, flags);
8020 hstate.add_commutative (one, two);
8021 inchash::add_expr (TREE_OPERAND (t, 2), two, flags);
8022 return;
8023 }
8024
8025 case CALL_EXPR:
8026 if (CALL_EXPR_FN (t) == NULL_TREE)
8027 hstate.add_int (CALL_EXPR_IFN (t));
8028 break;
8029
8030 case TARGET_EXPR:
8031 /* For TARGET_EXPR, just hash on the TARGET_EXPR_SLOT.
8032 Usually different TARGET_EXPRs just should use
8033 different temporaries in their slots. */
8034 inchash::add_expr (TARGET_EXPR_SLOT (t), hstate, flags);
8035 return;
8036
8037 default:
8038 break;
8039 }
8040
8041 /* Don't hash the type, that can lead to having nodes which
8042 compare equal according to operand_equal_p, but which
8043 have different hash codes. */
8044 if (code == NON_LVALUE_EXPR)
8045 {
8046 /* Make sure to include signness in the hash computation. */
8047 hstate.add_int (TYPE_UNSIGNED (TREE_TYPE (t)));
8048 inchash::add_expr (TREE_OPERAND (t, 0), hstate, flags);
8049 }
8050
8051 else if (commutative_tree_code (code))
8052 {
8053 /* It's a commutative expression. We want to hash it the same
8054 however it appears. We do this by first hashing both operands
8055 and then rehashing based on the order of their independent
8056 hashes. */
8057 inchash::hash one, two;
8058 inchash::add_expr (TREE_OPERAND (t, 0), one, flags);
8059 inchash::add_expr (TREE_OPERAND (t, 1), two, flags);
8060 hstate.add_commutative (one, two);
8061 }
8062 else
8063 for (i = TREE_OPERAND_LENGTH (t) - 1; i >= 0; --i)
8064 inchash::add_expr (TREE_OPERAND (t, i), hstate,
8065 i == 0 ? flags : sflags);
8066 }
8067 return;
8068 }
8069 }
8070
8071 }
8072
8073 /* Constructors for pointer, array and function types.
8074 (RECORD_TYPE, UNION_TYPE and ENUMERAL_TYPE nodes are
8075 constructed by language-dependent code, not here.) */
8076
8077 /* Construct, lay out and return the type of pointers to TO_TYPE with
8078 mode MODE. If CAN_ALIAS_ALL is TRUE, indicate this type can
8079 reference all of memory. If such a type has already been
8080 constructed, reuse it. */
8081
8082 tree
8083 build_pointer_type_for_mode (tree to_type, machine_mode mode,
8084 bool can_alias_all)
8085 {
8086 tree t;
8087 bool could_alias = can_alias_all;
8088
8089 if (to_type == error_mark_node)
8090 return error_mark_node;
8091
8092 /* If the pointed-to type has the may_alias attribute set, force
8093 a TYPE_REF_CAN_ALIAS_ALL pointer to be generated. */
8094 if (lookup_attribute ("may_alias", TYPE_ATTRIBUTES (to_type)))
8095 can_alias_all = true;
8096
8097 /* In some cases, languages will have things that aren't a POINTER_TYPE
8098 (such as a RECORD_TYPE for fat pointers in Ada) as TYPE_POINTER_TO.
8099 In that case, return that type without regard to the rest of our
8100 operands.
8101
8102 ??? This is a kludge, but consistent with the way this function has
8103 always operated and there doesn't seem to be a good way to avoid this
8104 at the moment. */
8105 if (TYPE_POINTER_TO (to_type) != 0
8106 && TREE_CODE (TYPE_POINTER_TO (to_type)) != POINTER_TYPE)
8107 return TYPE_POINTER_TO (to_type);
8108
8109 /* First, if we already have a type for pointers to TO_TYPE and it's
8110 the proper mode, use it. */
8111 for (t = TYPE_POINTER_TO (to_type); t; t = TYPE_NEXT_PTR_TO (t))
8112 if (TYPE_MODE (t) == mode && TYPE_REF_CAN_ALIAS_ALL (t) == can_alias_all)
8113 return t;
8114
8115 t = make_node (POINTER_TYPE);
8116
8117 TREE_TYPE (t) = to_type;
8118 SET_TYPE_MODE (t, mode);
8119 TYPE_REF_CAN_ALIAS_ALL (t) = can_alias_all;
8120 TYPE_NEXT_PTR_TO (t) = TYPE_POINTER_TO (to_type);
8121 TYPE_POINTER_TO (to_type) = t;
8122
8123 /* During LTO we do not set TYPE_CANONICAL of pointers and references. */
8124 if (TYPE_STRUCTURAL_EQUALITY_P (to_type) || in_lto_p)
8125 SET_TYPE_STRUCTURAL_EQUALITY (t);
8126 else if (TYPE_CANONICAL (to_type) != to_type || could_alias)
8127 TYPE_CANONICAL (t)
8128 = build_pointer_type_for_mode (TYPE_CANONICAL (to_type),
8129 mode, false);
8130
8131 /* Lay out the type. This function has many callers that are concerned
8132 with expression-construction, and this simplifies them all. */
8133 layout_type (t);
8134
8135 return t;
8136 }
8137
8138 /* By default build pointers in ptr_mode. */
8139
8140 tree
8141 build_pointer_type (tree to_type)
8142 {
8143 addr_space_t as = to_type == error_mark_node? ADDR_SPACE_GENERIC
8144 : TYPE_ADDR_SPACE (to_type);
8145 machine_mode pointer_mode = targetm.addr_space.pointer_mode (as);
8146 return build_pointer_type_for_mode (to_type, pointer_mode, false);
8147 }
8148
8149 /* Same as build_pointer_type_for_mode, but for REFERENCE_TYPE. */
8150
8151 tree
8152 build_reference_type_for_mode (tree to_type, machine_mode mode,
8153 bool can_alias_all)
8154 {
8155 tree t;
8156 bool could_alias = can_alias_all;
8157
8158 if (to_type == error_mark_node)
8159 return error_mark_node;
8160
8161 /* If the pointed-to type has the may_alias attribute set, force
8162 a TYPE_REF_CAN_ALIAS_ALL pointer to be generated. */
8163 if (lookup_attribute ("may_alias", TYPE_ATTRIBUTES (to_type)))
8164 can_alias_all = true;
8165
8166 /* In some cases, languages will have things that aren't a REFERENCE_TYPE
8167 (such as a RECORD_TYPE for fat pointers in Ada) as TYPE_REFERENCE_TO.
8168 In that case, return that type without regard to the rest of our
8169 operands.
8170
8171 ??? This is a kludge, but consistent with the way this function has
8172 always operated and there doesn't seem to be a good way to avoid this
8173 at the moment. */
8174 if (TYPE_REFERENCE_TO (to_type) != 0
8175 && TREE_CODE (TYPE_REFERENCE_TO (to_type)) != REFERENCE_TYPE)
8176 return TYPE_REFERENCE_TO (to_type);
8177
8178 /* First, if we already have a type for pointers to TO_TYPE and it's
8179 the proper mode, use it. */
8180 for (t = TYPE_REFERENCE_TO (to_type); t; t = TYPE_NEXT_REF_TO (t))
8181 if (TYPE_MODE (t) == mode && TYPE_REF_CAN_ALIAS_ALL (t) == can_alias_all)
8182 return t;
8183
8184 t = make_node (REFERENCE_TYPE);
8185
8186 TREE_TYPE (t) = to_type;
8187 SET_TYPE_MODE (t, mode);
8188 TYPE_REF_CAN_ALIAS_ALL (t) = can_alias_all;
8189 TYPE_NEXT_REF_TO (t) = TYPE_REFERENCE_TO (to_type);
8190 TYPE_REFERENCE_TO (to_type) = t;
8191
8192 /* During LTO we do not set TYPE_CANONICAL of pointers and references. */
8193 if (TYPE_STRUCTURAL_EQUALITY_P (to_type) || in_lto_p)
8194 SET_TYPE_STRUCTURAL_EQUALITY (t);
8195 else if (TYPE_CANONICAL (to_type) != to_type || could_alias)
8196 TYPE_CANONICAL (t)
8197 = build_reference_type_for_mode (TYPE_CANONICAL (to_type),
8198 mode, false);
8199
8200 layout_type (t);
8201
8202 return t;
8203 }
8204
8205
8206 /* Build the node for the type of references-to-TO_TYPE by default
8207 in ptr_mode. */
8208
8209 tree
8210 build_reference_type (tree to_type)
8211 {
8212 addr_space_t as = to_type == error_mark_node? ADDR_SPACE_GENERIC
8213 : TYPE_ADDR_SPACE (to_type);
8214 machine_mode pointer_mode = targetm.addr_space.pointer_mode (as);
8215 return build_reference_type_for_mode (to_type, pointer_mode, false);
8216 }
8217
8218 #define MAX_INT_CACHED_PREC \
8219 (HOST_BITS_PER_WIDE_INT > 64 ? HOST_BITS_PER_WIDE_INT : 64)
8220 static GTY(()) tree nonstandard_integer_type_cache[2 * MAX_INT_CACHED_PREC + 2];
8221
8222 /* Builds a signed or unsigned integer type of precision PRECISION.
8223 Used for C bitfields whose precision does not match that of
8224 built-in target types. */
8225 tree
8226 build_nonstandard_integer_type (unsigned HOST_WIDE_INT precision,
8227 int unsignedp)
8228 {
8229 tree itype, ret;
8230
8231 if (unsignedp)
8232 unsignedp = MAX_INT_CACHED_PREC + 1;
8233
8234 if (precision <= MAX_INT_CACHED_PREC)
8235 {
8236 itype = nonstandard_integer_type_cache[precision + unsignedp];
8237 if (itype)
8238 return itype;
8239 }
8240
8241 itype = make_node (INTEGER_TYPE);
8242 TYPE_PRECISION (itype) = precision;
8243
8244 if (unsignedp)
8245 fixup_unsigned_type (itype);
8246 else
8247 fixup_signed_type (itype);
8248
8249 ret = itype;
8250 if (tree_fits_uhwi_p (TYPE_MAX_VALUE (itype)))
8251 ret = type_hash_canon (tree_to_uhwi (TYPE_MAX_VALUE (itype)), itype);
8252 if (precision <= MAX_INT_CACHED_PREC)
8253 nonstandard_integer_type_cache[precision + unsignedp] = ret;
8254
8255 return ret;
8256 }
8257
8258 #define MAX_BOOL_CACHED_PREC \
8259 (HOST_BITS_PER_WIDE_INT > 64 ? HOST_BITS_PER_WIDE_INT : 64)
8260 static GTY(()) tree nonstandard_boolean_type_cache[MAX_BOOL_CACHED_PREC + 1];
8261
8262 /* Builds a boolean type of precision PRECISION.
8263 Used for boolean vectors to choose proper vector element size. */
8264 tree
8265 build_nonstandard_boolean_type (unsigned HOST_WIDE_INT precision)
8266 {
8267 tree type;
8268
8269 if (precision <= MAX_BOOL_CACHED_PREC)
8270 {
8271 type = nonstandard_boolean_type_cache[precision];
8272 if (type)
8273 return type;
8274 }
8275
8276 type = make_node (BOOLEAN_TYPE);
8277 TYPE_PRECISION (type) = precision;
8278 fixup_signed_type (type);
8279
8280 if (precision <= MAX_INT_CACHED_PREC)
8281 nonstandard_boolean_type_cache[precision] = type;
8282
8283 return type;
8284 }
8285
8286 /* Create a range of some discrete type TYPE (an INTEGER_TYPE, ENUMERAL_TYPE
8287 or BOOLEAN_TYPE) with low bound LOWVAL and high bound HIGHVAL. If SHARED
8288 is true, reuse such a type that has already been constructed. */
8289
8290 static tree
8291 build_range_type_1 (tree type, tree lowval, tree highval, bool shared)
8292 {
8293 tree itype = make_node (INTEGER_TYPE);
8294
8295 TREE_TYPE (itype) = type;
8296
8297 TYPE_MIN_VALUE (itype) = fold_convert (type, lowval);
8298 TYPE_MAX_VALUE (itype) = highval ? fold_convert (type, highval) : NULL;
8299
8300 TYPE_PRECISION (itype) = TYPE_PRECISION (type);
8301 SET_TYPE_MODE (itype, TYPE_MODE (type));
8302 TYPE_SIZE (itype) = TYPE_SIZE (type);
8303 TYPE_SIZE_UNIT (itype) = TYPE_SIZE_UNIT (type);
8304 SET_TYPE_ALIGN (itype, TYPE_ALIGN (type));
8305 TYPE_USER_ALIGN (itype) = TYPE_USER_ALIGN (type);
8306
8307 if (!shared)
8308 return itype;
8309
8310 if ((TYPE_MIN_VALUE (itype)
8311 && TREE_CODE (TYPE_MIN_VALUE (itype)) != INTEGER_CST)
8312 || (TYPE_MAX_VALUE (itype)
8313 && TREE_CODE (TYPE_MAX_VALUE (itype)) != INTEGER_CST))
8314 {
8315 /* Since we cannot reliably merge this type, we need to compare it using
8316 structural equality checks. */
8317 SET_TYPE_STRUCTURAL_EQUALITY (itype);
8318 return itype;
8319 }
8320
8321 hashval_t hash = type_hash_canon_hash (itype);
8322 itype = type_hash_canon (hash, itype);
8323
8324 return itype;
8325 }
8326
8327 /* Wrapper around build_range_type_1 with SHARED set to true. */
8328
8329 tree
8330 build_range_type (tree type, tree lowval, tree highval)
8331 {
8332 return build_range_type_1 (type, lowval, highval, true);
8333 }
8334
8335 /* Wrapper around build_range_type_1 with SHARED set to false. */
8336
8337 tree
8338 build_nonshared_range_type (tree type, tree lowval, tree highval)
8339 {
8340 return build_range_type_1 (type, lowval, highval, false);
8341 }
8342
8343 /* Create a type of integers to be the TYPE_DOMAIN of an ARRAY_TYPE.
8344 MAXVAL should be the maximum value in the domain
8345 (one less than the length of the array).
8346
8347 The maximum value that MAXVAL can have is INT_MAX for a HOST_WIDE_INT.
8348 We don't enforce this limit, that is up to caller (e.g. language front end).
8349 The limit exists because the result is a signed type and we don't handle
8350 sizes that use more than one HOST_WIDE_INT. */
8351
8352 tree
8353 build_index_type (tree maxval)
8354 {
8355 return build_range_type (sizetype, size_zero_node, maxval);
8356 }
8357
8358 /* Return true if the debug information for TYPE, a subtype, should be emitted
8359 as a subrange type. If so, set LOWVAL to the low bound and HIGHVAL to the
8360 high bound, respectively. Sometimes doing so unnecessarily obfuscates the
8361 debug info and doesn't reflect the source code. */
8362
8363 bool
8364 subrange_type_for_debug_p (const_tree type, tree *lowval, tree *highval)
8365 {
8366 tree base_type = TREE_TYPE (type), low, high;
8367
8368 /* Subrange types have a base type which is an integral type. */
8369 if (!INTEGRAL_TYPE_P (base_type))
8370 return false;
8371
8372 /* Get the real bounds of the subtype. */
8373 if (lang_hooks.types.get_subrange_bounds)
8374 lang_hooks.types.get_subrange_bounds (type, &low, &high);
8375 else
8376 {
8377 low = TYPE_MIN_VALUE (type);
8378 high = TYPE_MAX_VALUE (type);
8379 }
8380
8381 /* If the type and its base type have the same representation and the same
8382 name, then the type is not a subrange but a copy of the base type. */
8383 if ((TREE_CODE (base_type) == INTEGER_TYPE
8384 || TREE_CODE (base_type) == BOOLEAN_TYPE)
8385 && int_size_in_bytes (type) == int_size_in_bytes (base_type)
8386 && tree_int_cst_equal (low, TYPE_MIN_VALUE (base_type))
8387 && tree_int_cst_equal (high, TYPE_MAX_VALUE (base_type))
8388 && TYPE_IDENTIFIER (type) == TYPE_IDENTIFIER (base_type))
8389 return false;
8390
8391 if (lowval)
8392 *lowval = low;
8393 if (highval)
8394 *highval = high;
8395 return true;
8396 }
8397
8398 /* Construct, lay out and return the type of arrays of elements with ELT_TYPE
8399 and number of elements specified by the range of values of INDEX_TYPE.
8400 If TYPELESS_STORAGE is true, TYPE_TYPELESS_STORAGE flag is set on the type.
8401 If SHARED is true, reuse such a type that has already been constructed. */
8402
8403 static tree
8404 build_array_type_1 (tree elt_type, tree index_type, bool typeless_storage,
8405 bool shared)
8406 {
8407 tree t;
8408
8409 if (TREE_CODE (elt_type) == FUNCTION_TYPE)
8410 {
8411 error ("arrays of functions are not meaningful");
8412 elt_type = integer_type_node;
8413 }
8414
8415 t = make_node (ARRAY_TYPE);
8416 TREE_TYPE (t) = elt_type;
8417 TYPE_DOMAIN (t) = index_type;
8418 TYPE_ADDR_SPACE (t) = TYPE_ADDR_SPACE (elt_type);
8419 TYPE_TYPELESS_STORAGE (t) = typeless_storage;
8420 layout_type (t);
8421
8422 /* If the element type is incomplete at this point we get marked for
8423 structural equality. Do not record these types in the canonical
8424 type hashtable. */
8425 if (TYPE_STRUCTURAL_EQUALITY_P (t))
8426 return t;
8427
8428 if (shared)
8429 {
8430 hashval_t hash = type_hash_canon_hash (t);
8431 t = type_hash_canon (hash, t);
8432 }
8433
8434 if (TYPE_CANONICAL (t) == t)
8435 {
8436 if (TYPE_STRUCTURAL_EQUALITY_P (elt_type)
8437 || (index_type && TYPE_STRUCTURAL_EQUALITY_P (index_type))
8438 || in_lto_p)
8439 SET_TYPE_STRUCTURAL_EQUALITY (t);
8440 else if (TYPE_CANONICAL (elt_type) != elt_type
8441 || (index_type && TYPE_CANONICAL (index_type) != index_type))
8442 TYPE_CANONICAL (t)
8443 = build_array_type_1 (TYPE_CANONICAL (elt_type),
8444 index_type
8445 ? TYPE_CANONICAL (index_type) : NULL_TREE,
8446 typeless_storage, shared);
8447 }
8448
8449 return t;
8450 }
8451
8452 /* Wrapper around build_array_type_1 with SHARED set to true. */
8453
8454 tree
8455 build_array_type (tree elt_type, tree index_type, bool typeless_storage)
8456 {
8457 return build_array_type_1 (elt_type, index_type, typeless_storage, true);
8458 }
8459
8460 /* Wrapper around build_array_type_1 with SHARED set to false. */
8461
8462 tree
8463 build_nonshared_array_type (tree elt_type, tree index_type)
8464 {
8465 return build_array_type_1 (elt_type, index_type, false, false);
8466 }
8467
8468 /* Return a representation of ELT_TYPE[NELTS], using indices of type
8469 sizetype. */
8470
8471 tree
8472 build_array_type_nelts (tree elt_type, unsigned HOST_WIDE_INT nelts)
8473 {
8474 return build_array_type (elt_type, build_index_type (size_int (nelts - 1)));
8475 }
8476
8477 /* Recursively examines the array elements of TYPE, until a non-array
8478 element type is found. */
8479
8480 tree
8481 strip_array_types (tree type)
8482 {
8483 while (TREE_CODE (type) == ARRAY_TYPE)
8484 type = TREE_TYPE (type);
8485
8486 return type;
8487 }
8488
8489 /* Computes the canonical argument types from the argument type list
8490 ARGTYPES.
8491
8492 Upon return, *ANY_STRUCTURAL_P will be true iff either it was true
8493 on entry to this function, or if any of the ARGTYPES are
8494 structural.
8495
8496 Upon return, *ANY_NONCANONICAL_P will be true iff either it was
8497 true on entry to this function, or if any of the ARGTYPES are
8498 non-canonical.
8499
8500 Returns a canonical argument list, which may be ARGTYPES when the
8501 canonical argument list is unneeded (i.e., *ANY_STRUCTURAL_P is
8502 true) or would not differ from ARGTYPES. */
8503
8504 static tree
8505 maybe_canonicalize_argtypes (tree argtypes,
8506 bool *any_structural_p,
8507 bool *any_noncanonical_p)
8508 {
8509 tree arg;
8510 bool any_noncanonical_argtypes_p = false;
8511
8512 for (arg = argtypes; arg && !(*any_structural_p); arg = TREE_CHAIN (arg))
8513 {
8514 if (!TREE_VALUE (arg) || TREE_VALUE (arg) == error_mark_node)
8515 /* Fail gracefully by stating that the type is structural. */
8516 *any_structural_p = true;
8517 else if (TYPE_STRUCTURAL_EQUALITY_P (TREE_VALUE (arg)))
8518 *any_structural_p = true;
8519 else if (TYPE_CANONICAL (TREE_VALUE (arg)) != TREE_VALUE (arg)
8520 || TREE_PURPOSE (arg))
8521 /* If the argument has a default argument, we consider it
8522 non-canonical even though the type itself is canonical.
8523 That way, different variants of function and method types
8524 with default arguments will all point to the variant with
8525 no defaults as their canonical type. */
8526 any_noncanonical_argtypes_p = true;
8527 }
8528
8529 if (*any_structural_p)
8530 return argtypes;
8531
8532 if (any_noncanonical_argtypes_p)
8533 {
8534 /* Build the canonical list of argument types. */
8535 tree canon_argtypes = NULL_TREE;
8536 bool is_void = false;
8537
8538 for (arg = argtypes; arg; arg = TREE_CHAIN (arg))
8539 {
8540 if (arg == void_list_node)
8541 is_void = true;
8542 else
8543 canon_argtypes = tree_cons (NULL_TREE,
8544 TYPE_CANONICAL (TREE_VALUE (arg)),
8545 canon_argtypes);
8546 }
8547
8548 canon_argtypes = nreverse (canon_argtypes);
8549 if (is_void)
8550 canon_argtypes = chainon (canon_argtypes, void_list_node);
8551
8552 /* There is a non-canonical type. */
8553 *any_noncanonical_p = true;
8554 return canon_argtypes;
8555 }
8556
8557 /* The canonical argument types are the same as ARGTYPES. */
8558 return argtypes;
8559 }
8560
8561 /* Construct, lay out and return
8562 the type of functions returning type VALUE_TYPE
8563 given arguments of types ARG_TYPES.
8564 ARG_TYPES is a chain of TREE_LIST nodes whose TREE_VALUEs
8565 are data type nodes for the arguments of the function.
8566 If such a type has already been constructed, reuse it. */
8567
8568 tree
8569 build_function_type (tree value_type, tree arg_types)
8570 {
8571 tree t;
8572 inchash::hash hstate;
8573 bool any_structural_p, any_noncanonical_p;
8574 tree canon_argtypes;
8575
8576 if (TREE_CODE (value_type) == FUNCTION_TYPE)
8577 {
8578 error ("function return type cannot be function");
8579 value_type = integer_type_node;
8580 }
8581
8582 /* Make a node of the sort we want. */
8583 t = make_node (FUNCTION_TYPE);
8584 TREE_TYPE (t) = value_type;
8585 TYPE_ARG_TYPES (t) = arg_types;
8586
8587 /* If we already have such a type, use the old one. */
8588 hashval_t hash = type_hash_canon_hash (t);
8589 t = type_hash_canon (hash, t);
8590
8591 /* Set up the canonical type. */
8592 any_structural_p = TYPE_STRUCTURAL_EQUALITY_P (value_type);
8593 any_noncanonical_p = TYPE_CANONICAL (value_type) != value_type;
8594 canon_argtypes = maybe_canonicalize_argtypes (arg_types,
8595 &any_structural_p,
8596 &any_noncanonical_p);
8597 if (any_structural_p)
8598 SET_TYPE_STRUCTURAL_EQUALITY (t);
8599 else if (any_noncanonical_p)
8600 TYPE_CANONICAL (t) = build_function_type (TYPE_CANONICAL (value_type),
8601 canon_argtypes);
8602
8603 if (!COMPLETE_TYPE_P (t))
8604 layout_type (t);
8605 return t;
8606 }
8607
8608 /* Build a function type. The RETURN_TYPE is the type returned by the
8609 function. If VAARGS is set, no void_type_node is appended to the
8610 list. ARGP must be always be terminated be a NULL_TREE. */
8611
8612 static tree
8613 build_function_type_list_1 (bool vaargs, tree return_type, va_list argp)
8614 {
8615 tree t, args, last;
8616
8617 t = va_arg (argp, tree);
8618 for (args = NULL_TREE; t != NULL_TREE; t = va_arg (argp, tree))
8619 args = tree_cons (NULL_TREE, t, args);
8620
8621 if (vaargs)
8622 {
8623 last = args;
8624 if (args != NULL_TREE)
8625 args = nreverse (args);
8626 gcc_assert (last != void_list_node);
8627 }
8628 else if (args == NULL_TREE)
8629 args = void_list_node;
8630 else
8631 {
8632 last = args;
8633 args = nreverse (args);
8634 TREE_CHAIN (last) = void_list_node;
8635 }
8636 args = build_function_type (return_type, args);
8637
8638 return args;
8639 }
8640
8641 /* Build a function type. The RETURN_TYPE is the type returned by the
8642 function. If additional arguments are provided, they are
8643 additional argument types. The list of argument types must always
8644 be terminated by NULL_TREE. */
8645
8646 tree
8647 build_function_type_list (tree return_type, ...)
8648 {
8649 tree args;
8650 va_list p;
8651
8652 va_start (p, return_type);
8653 args = build_function_type_list_1 (false, return_type, p);
8654 va_end (p);
8655 return args;
8656 }
8657
8658 /* Build a variable argument function type. The RETURN_TYPE is the
8659 type returned by the function. If additional arguments are provided,
8660 they are additional argument types. The list of argument types must
8661 always be terminated by NULL_TREE. */
8662
8663 tree
8664 build_varargs_function_type_list (tree return_type, ...)
8665 {
8666 tree args;
8667 va_list p;
8668
8669 va_start (p, return_type);
8670 args = build_function_type_list_1 (true, return_type, p);
8671 va_end (p);
8672
8673 return args;
8674 }
8675
8676 /* Build a function type. RETURN_TYPE is the type returned by the
8677 function; VAARGS indicates whether the function takes varargs. The
8678 function takes N named arguments, the types of which are provided in
8679 ARG_TYPES. */
8680
8681 static tree
8682 build_function_type_array_1 (bool vaargs, tree return_type, int n,
8683 tree *arg_types)
8684 {
8685 int i;
8686 tree t = vaargs ? NULL_TREE : void_list_node;
8687
8688 for (i = n - 1; i >= 0; i--)
8689 t = tree_cons (NULL_TREE, arg_types[i], t);
8690
8691 return build_function_type (return_type, t);
8692 }
8693
8694 /* Build a function type. RETURN_TYPE is the type returned by the
8695 function. The function takes N named arguments, the types of which
8696 are provided in ARG_TYPES. */
8697
8698 tree
8699 build_function_type_array (tree return_type, int n, tree *arg_types)
8700 {
8701 return build_function_type_array_1 (false, return_type, n, arg_types);
8702 }
8703
8704 /* Build a variable argument function type. RETURN_TYPE is the type
8705 returned by the function. The function takes N named arguments, the
8706 types of which are provided in ARG_TYPES. */
8707
8708 tree
8709 build_varargs_function_type_array (tree return_type, int n, tree *arg_types)
8710 {
8711 return build_function_type_array_1 (true, return_type, n, arg_types);
8712 }
8713
8714 /* Build a METHOD_TYPE for a member of BASETYPE. The RETTYPE (a TYPE)
8715 and ARGTYPES (a TREE_LIST) are the return type and arguments types
8716 for the method. An implicit additional parameter (of type
8717 pointer-to-BASETYPE) is added to the ARGTYPES. */
8718
8719 tree
8720 build_method_type_directly (tree basetype,
8721 tree rettype,
8722 tree argtypes)
8723 {
8724 tree t;
8725 tree ptype;
8726 bool any_structural_p, any_noncanonical_p;
8727 tree canon_argtypes;
8728
8729 /* Make a node of the sort we want. */
8730 t = make_node (METHOD_TYPE);
8731
8732 TYPE_METHOD_BASETYPE (t) = TYPE_MAIN_VARIANT (basetype);
8733 TREE_TYPE (t) = rettype;
8734 ptype = build_pointer_type (basetype);
8735
8736 /* The actual arglist for this function includes a "hidden" argument
8737 which is "this". Put it into the list of argument types. */
8738 argtypes = tree_cons (NULL_TREE, ptype, argtypes);
8739 TYPE_ARG_TYPES (t) = argtypes;
8740
8741 /* If we already have such a type, use the old one. */
8742 hashval_t hash = type_hash_canon_hash (t);
8743 t = type_hash_canon (hash, t);
8744
8745 /* Set up the canonical type. */
8746 any_structural_p
8747 = (TYPE_STRUCTURAL_EQUALITY_P (basetype)
8748 || TYPE_STRUCTURAL_EQUALITY_P (rettype));
8749 any_noncanonical_p
8750 = (TYPE_CANONICAL (basetype) != basetype
8751 || TYPE_CANONICAL (rettype) != rettype);
8752 canon_argtypes = maybe_canonicalize_argtypes (TREE_CHAIN (argtypes),
8753 &any_structural_p,
8754 &any_noncanonical_p);
8755 if (any_structural_p)
8756 SET_TYPE_STRUCTURAL_EQUALITY (t);
8757 else if (any_noncanonical_p)
8758 TYPE_CANONICAL (t)
8759 = build_method_type_directly (TYPE_CANONICAL (basetype),
8760 TYPE_CANONICAL (rettype),
8761 canon_argtypes);
8762 if (!COMPLETE_TYPE_P (t))
8763 layout_type (t);
8764
8765 return t;
8766 }
8767
8768 /* Construct, lay out and return the type of methods belonging to class
8769 BASETYPE and whose arguments and values are described by TYPE.
8770 If that type exists already, reuse it.
8771 TYPE must be a FUNCTION_TYPE node. */
8772
8773 tree
8774 build_method_type (tree basetype, tree type)
8775 {
8776 gcc_assert (TREE_CODE (type) == FUNCTION_TYPE);
8777
8778 return build_method_type_directly (basetype,
8779 TREE_TYPE (type),
8780 TYPE_ARG_TYPES (type));
8781 }
8782
8783 /* Construct, lay out and return the type of offsets to a value
8784 of type TYPE, within an object of type BASETYPE.
8785 If a suitable offset type exists already, reuse it. */
8786
8787 tree
8788 build_offset_type (tree basetype, tree type)
8789 {
8790 tree t;
8791
8792 /* Make a node of the sort we want. */
8793 t = make_node (OFFSET_TYPE);
8794
8795 TYPE_OFFSET_BASETYPE (t) = TYPE_MAIN_VARIANT (basetype);
8796 TREE_TYPE (t) = type;
8797
8798 /* If we already have such a type, use the old one. */
8799 hashval_t hash = type_hash_canon_hash (t);
8800 t = type_hash_canon (hash, t);
8801
8802 if (!COMPLETE_TYPE_P (t))
8803 layout_type (t);
8804
8805 if (TYPE_CANONICAL (t) == t)
8806 {
8807 if (TYPE_STRUCTURAL_EQUALITY_P (basetype)
8808 || TYPE_STRUCTURAL_EQUALITY_P (type))
8809 SET_TYPE_STRUCTURAL_EQUALITY (t);
8810 else if (TYPE_CANONICAL (TYPE_MAIN_VARIANT (basetype)) != basetype
8811 || TYPE_CANONICAL (type) != type)
8812 TYPE_CANONICAL (t)
8813 = build_offset_type (TYPE_CANONICAL (TYPE_MAIN_VARIANT (basetype)),
8814 TYPE_CANONICAL (type));
8815 }
8816
8817 return t;
8818 }
8819
8820 /* Create a complex type whose components are COMPONENT_TYPE.
8821
8822 If NAMED is true, the type is given a TYPE_NAME. We do not always
8823 do so because this creates a DECL node and thus make the DECL_UIDs
8824 dependent on the type canonicalization hashtable, which is GC-ed,
8825 so the DECL_UIDs would not be stable wrt garbage collection. */
8826
8827 tree
8828 build_complex_type (tree component_type, bool named)
8829 {
8830 tree t;
8831
8832 gcc_assert (INTEGRAL_TYPE_P (component_type)
8833 || SCALAR_FLOAT_TYPE_P (component_type)
8834 || FIXED_POINT_TYPE_P (component_type));
8835
8836 /* Make a node of the sort we want. */
8837 t = make_node (COMPLEX_TYPE);
8838
8839 TREE_TYPE (t) = TYPE_MAIN_VARIANT (component_type);
8840
8841 /* If we already have such a type, use the old one. */
8842 hashval_t hash = type_hash_canon_hash (t);
8843 t = type_hash_canon (hash, t);
8844
8845 if (!COMPLETE_TYPE_P (t))
8846 layout_type (t);
8847
8848 if (TYPE_CANONICAL (t) == t)
8849 {
8850 if (TYPE_STRUCTURAL_EQUALITY_P (component_type))
8851 SET_TYPE_STRUCTURAL_EQUALITY (t);
8852 else if (TYPE_CANONICAL (component_type) != component_type)
8853 TYPE_CANONICAL (t)
8854 = build_complex_type (TYPE_CANONICAL (component_type), named);
8855 }
8856
8857 /* We need to create a name, since complex is a fundamental type. */
8858 if (!TYPE_NAME (t) && named)
8859 {
8860 const char *name;
8861 if (component_type == char_type_node)
8862 name = "complex char";
8863 else if (component_type == signed_char_type_node)
8864 name = "complex signed char";
8865 else if (component_type == unsigned_char_type_node)
8866 name = "complex unsigned char";
8867 else if (component_type == short_integer_type_node)
8868 name = "complex short int";
8869 else if (component_type == short_unsigned_type_node)
8870 name = "complex short unsigned int";
8871 else if (component_type == integer_type_node)
8872 name = "complex int";
8873 else if (component_type == unsigned_type_node)
8874 name = "complex unsigned int";
8875 else if (component_type == long_integer_type_node)
8876 name = "complex long int";
8877 else if (component_type == long_unsigned_type_node)
8878 name = "complex long unsigned int";
8879 else if (component_type == long_long_integer_type_node)
8880 name = "complex long long int";
8881 else if (component_type == long_long_unsigned_type_node)
8882 name = "complex long long unsigned int";
8883 else
8884 name = 0;
8885
8886 if (name != 0)
8887 TYPE_NAME (t) = build_decl (UNKNOWN_LOCATION, TYPE_DECL,
8888 get_identifier (name), t);
8889 }
8890
8891 return build_qualified_type (t, TYPE_QUALS (component_type));
8892 }
8893
8894 /* If TYPE is a real or complex floating-point type and the target
8895 does not directly support arithmetic on TYPE then return the wider
8896 type to be used for arithmetic on TYPE. Otherwise, return
8897 NULL_TREE. */
8898
8899 tree
8900 excess_precision_type (tree type)
8901 {
8902 /* The target can give two different responses to the question of
8903 which excess precision mode it would like depending on whether we
8904 are in -fexcess-precision=standard or -fexcess-precision=fast. */
8905
8906 enum excess_precision_type requested_type
8907 = (flag_excess_precision == EXCESS_PRECISION_FAST
8908 ? EXCESS_PRECISION_TYPE_FAST
8909 : EXCESS_PRECISION_TYPE_STANDARD);
8910
8911 enum flt_eval_method target_flt_eval_method
8912 = targetm.c.excess_precision (requested_type);
8913
8914 /* The target should not ask for unpredictable float evaluation (though
8915 it might advertise that implicitly the evaluation is unpredictable,
8916 but we don't care about that here, it will have been reported
8917 elsewhere). If it does ask for unpredictable evaluation, we have
8918 nothing to do here. */
8919 gcc_assert (target_flt_eval_method != FLT_EVAL_METHOD_UNPREDICTABLE);
8920
8921 /* Nothing to do. The target has asked for all types we know about
8922 to be computed with their native precision and range. */
8923 if (target_flt_eval_method == FLT_EVAL_METHOD_PROMOTE_TO_FLOAT16)
8924 return NULL_TREE;
8925
8926 /* The target will promote this type in a target-dependent way, so excess
8927 precision ought to leave it alone. */
8928 if (targetm.promoted_type (type) != NULL_TREE)
8929 return NULL_TREE;
8930
8931 machine_mode float16_type_mode = (float16_type_node
8932 ? TYPE_MODE (float16_type_node)
8933 : VOIDmode);
8934 machine_mode float_type_mode = TYPE_MODE (float_type_node);
8935 machine_mode double_type_mode = TYPE_MODE (double_type_node);
8936
8937 switch (TREE_CODE (type))
8938 {
8939 case REAL_TYPE:
8940 {
8941 machine_mode type_mode = TYPE_MODE (type);
8942 switch (target_flt_eval_method)
8943 {
8944 case FLT_EVAL_METHOD_PROMOTE_TO_FLOAT:
8945 if (type_mode == float16_type_mode)
8946 return float_type_node;
8947 break;
8948 case FLT_EVAL_METHOD_PROMOTE_TO_DOUBLE:
8949 if (type_mode == float16_type_mode
8950 || type_mode == float_type_mode)
8951 return double_type_node;
8952 break;
8953 case FLT_EVAL_METHOD_PROMOTE_TO_LONG_DOUBLE:
8954 if (type_mode == float16_type_mode
8955 || type_mode == float_type_mode
8956 || type_mode == double_type_mode)
8957 return long_double_type_node;
8958 break;
8959 default:
8960 gcc_unreachable ();
8961 }
8962 break;
8963 }
8964 case COMPLEX_TYPE:
8965 {
8966 if (TREE_CODE (TREE_TYPE (type)) != REAL_TYPE)
8967 return NULL_TREE;
8968 machine_mode type_mode = TYPE_MODE (TREE_TYPE (type));
8969 switch (target_flt_eval_method)
8970 {
8971 case FLT_EVAL_METHOD_PROMOTE_TO_FLOAT:
8972 if (type_mode == float16_type_mode)
8973 return complex_float_type_node;
8974 break;
8975 case FLT_EVAL_METHOD_PROMOTE_TO_DOUBLE:
8976 if (type_mode == float16_type_mode
8977 || type_mode == float_type_mode)
8978 return complex_double_type_node;
8979 break;
8980 case FLT_EVAL_METHOD_PROMOTE_TO_LONG_DOUBLE:
8981 if (type_mode == float16_type_mode
8982 || type_mode == float_type_mode
8983 || type_mode == double_type_mode)
8984 return complex_long_double_type_node;
8985 break;
8986 default:
8987 gcc_unreachable ();
8988 }
8989 break;
8990 }
8991 default:
8992 break;
8993 }
8994
8995 return NULL_TREE;
8996 }
8997 \f
8998 /* Return OP, stripped of any conversions to wider types as much as is safe.
8999 Converting the value back to OP's type makes a value equivalent to OP.
9000
9001 If FOR_TYPE is nonzero, we return a value which, if converted to
9002 type FOR_TYPE, would be equivalent to converting OP to type FOR_TYPE.
9003
9004 OP must have integer, real or enumeral type. Pointers are not allowed!
9005
9006 There are some cases where the obvious value we could return
9007 would regenerate to OP if converted to OP's type,
9008 but would not extend like OP to wider types.
9009 If FOR_TYPE indicates such extension is contemplated, we eschew such values.
9010 For example, if OP is (unsigned short)(signed char)-1,
9011 we avoid returning (signed char)-1 if FOR_TYPE is int,
9012 even though extending that to an unsigned short would regenerate OP,
9013 since the result of extending (signed char)-1 to (int)
9014 is different from (int) OP. */
9015
9016 tree
9017 get_unwidened (tree op, tree for_type)
9018 {
9019 /* Set UNS initially if converting OP to FOR_TYPE is a zero-extension. */
9020 tree type = TREE_TYPE (op);
9021 unsigned final_prec
9022 = TYPE_PRECISION (for_type != 0 ? for_type : type);
9023 int uns
9024 = (for_type != 0 && for_type != type
9025 && final_prec > TYPE_PRECISION (type)
9026 && TYPE_UNSIGNED (type));
9027 tree win = op;
9028
9029 while (CONVERT_EXPR_P (op))
9030 {
9031 int bitschange;
9032
9033 /* TYPE_PRECISION on vector types has different meaning
9034 (TYPE_VECTOR_SUBPARTS) and casts from vectors are view conversions,
9035 so avoid them here. */
9036 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (op, 0))) == VECTOR_TYPE)
9037 break;
9038
9039 bitschange = TYPE_PRECISION (TREE_TYPE (op))
9040 - TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op, 0)));
9041
9042 /* Truncations are many-one so cannot be removed.
9043 Unless we are later going to truncate down even farther. */
9044 if (bitschange < 0
9045 && final_prec > TYPE_PRECISION (TREE_TYPE (op)))
9046 break;
9047
9048 /* See what's inside this conversion. If we decide to strip it,
9049 we will set WIN. */
9050 op = TREE_OPERAND (op, 0);
9051
9052 /* If we have not stripped any zero-extensions (uns is 0),
9053 we can strip any kind of extension.
9054 If we have previously stripped a zero-extension,
9055 only zero-extensions can safely be stripped.
9056 Any extension can be stripped if the bits it would produce
9057 are all going to be discarded later by truncating to FOR_TYPE. */
9058
9059 if (bitschange > 0)
9060 {
9061 if (! uns || final_prec <= TYPE_PRECISION (TREE_TYPE (op)))
9062 win = op;
9063 /* TYPE_UNSIGNED says whether this is a zero-extension.
9064 Let's avoid computing it if it does not affect WIN
9065 and if UNS will not be needed again. */
9066 if ((uns
9067 || CONVERT_EXPR_P (op))
9068 && TYPE_UNSIGNED (TREE_TYPE (op)))
9069 {
9070 uns = 1;
9071 win = op;
9072 }
9073 }
9074 }
9075
9076 /* If we finally reach a constant see if it fits in sth smaller and
9077 in that case convert it. */
9078 if (TREE_CODE (win) == INTEGER_CST)
9079 {
9080 tree wtype = TREE_TYPE (win);
9081 unsigned prec = wi::min_precision (win, TYPE_SIGN (wtype));
9082 if (for_type)
9083 prec = MAX (prec, final_prec);
9084 if (prec < TYPE_PRECISION (wtype))
9085 {
9086 tree t = lang_hooks.types.type_for_size (prec, TYPE_UNSIGNED (wtype));
9087 if (t && TYPE_PRECISION (t) < TYPE_PRECISION (wtype))
9088 win = fold_convert (t, win);
9089 }
9090 }
9091
9092 return win;
9093 }
9094 \f
9095 /* Return OP or a simpler expression for a narrower value
9096 which can be sign-extended or zero-extended to give back OP.
9097 Store in *UNSIGNEDP_PTR either 1 if the value should be zero-extended
9098 or 0 if the value should be sign-extended. */
9099
9100 tree
9101 get_narrower (tree op, int *unsignedp_ptr)
9102 {
9103 int uns = 0;
9104 int first = 1;
9105 tree win = op;
9106 bool integral_p = INTEGRAL_TYPE_P (TREE_TYPE (op));
9107
9108 while (TREE_CODE (op) == NOP_EXPR)
9109 {
9110 int bitschange
9111 = (TYPE_PRECISION (TREE_TYPE (op))
9112 - TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op, 0))));
9113
9114 /* Truncations are many-one so cannot be removed. */
9115 if (bitschange < 0)
9116 break;
9117
9118 /* See what's inside this conversion. If we decide to strip it,
9119 we will set WIN. */
9120
9121 if (bitschange > 0)
9122 {
9123 op = TREE_OPERAND (op, 0);
9124 /* An extension: the outermost one can be stripped,
9125 but remember whether it is zero or sign extension. */
9126 if (first)
9127 uns = TYPE_UNSIGNED (TREE_TYPE (op));
9128 /* Otherwise, if a sign extension has been stripped,
9129 only sign extensions can now be stripped;
9130 if a zero extension has been stripped, only zero-extensions. */
9131 else if (uns != TYPE_UNSIGNED (TREE_TYPE (op)))
9132 break;
9133 first = 0;
9134 }
9135 else /* bitschange == 0 */
9136 {
9137 /* A change in nominal type can always be stripped, but we must
9138 preserve the unsignedness. */
9139 if (first)
9140 uns = TYPE_UNSIGNED (TREE_TYPE (op));
9141 first = 0;
9142 op = TREE_OPERAND (op, 0);
9143 /* Keep trying to narrow, but don't assign op to win if it
9144 would turn an integral type into something else. */
9145 if (INTEGRAL_TYPE_P (TREE_TYPE (op)) != integral_p)
9146 continue;
9147 }
9148
9149 win = op;
9150 }
9151
9152 if (TREE_CODE (op) == COMPONENT_REF
9153 /* Since type_for_size always gives an integer type. */
9154 && TREE_CODE (TREE_TYPE (op)) != REAL_TYPE
9155 && TREE_CODE (TREE_TYPE (op)) != FIXED_POINT_TYPE
9156 /* Ensure field is laid out already. */
9157 && DECL_SIZE (TREE_OPERAND (op, 1)) != 0
9158 && tree_fits_uhwi_p (DECL_SIZE (TREE_OPERAND (op, 1))))
9159 {
9160 unsigned HOST_WIDE_INT innerprec
9161 = tree_to_uhwi (DECL_SIZE (TREE_OPERAND (op, 1)));
9162 int unsignedp = (DECL_UNSIGNED (TREE_OPERAND (op, 1))
9163 || TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op, 1))));
9164 tree type = lang_hooks.types.type_for_size (innerprec, unsignedp);
9165
9166 /* We can get this structure field in a narrower type that fits it,
9167 but the resulting extension to its nominal type (a fullword type)
9168 must satisfy the same conditions as for other extensions.
9169
9170 Do this only for fields that are aligned (not bit-fields),
9171 because when bit-field insns will be used there is no
9172 advantage in doing this. */
9173
9174 if (innerprec < TYPE_PRECISION (TREE_TYPE (op))
9175 && ! DECL_BIT_FIELD (TREE_OPERAND (op, 1))
9176 && (first || uns == DECL_UNSIGNED (TREE_OPERAND (op, 1)))
9177 && type != 0)
9178 {
9179 if (first)
9180 uns = DECL_UNSIGNED (TREE_OPERAND (op, 1));
9181 win = fold_convert (type, op);
9182 }
9183 }
9184
9185 *unsignedp_ptr = uns;
9186 return win;
9187 }
9188 \f
9189 /* Return true if integer constant C has a value that is permissible
9190 for TYPE, an integral type. */
9191
9192 bool
9193 int_fits_type_p (const_tree c, const_tree type)
9194 {
9195 tree type_low_bound, type_high_bound;
9196 bool ok_for_low_bound, ok_for_high_bound;
9197 signop sgn_c = TYPE_SIGN (TREE_TYPE (c));
9198
9199 /* Non-standard boolean types can have arbitrary precision but various
9200 transformations assume that they can only take values 0 and +/-1. */
9201 if (TREE_CODE (type) == BOOLEAN_TYPE)
9202 return wi::fits_to_boolean_p (c, type);
9203
9204 retry:
9205 type_low_bound = TYPE_MIN_VALUE (type);
9206 type_high_bound = TYPE_MAX_VALUE (type);
9207
9208 /* If at least one bound of the type is a constant integer, we can check
9209 ourselves and maybe make a decision. If no such decision is possible, but
9210 this type is a subtype, try checking against that. Otherwise, use
9211 fits_to_tree_p, which checks against the precision.
9212
9213 Compute the status for each possibly constant bound, and return if we see
9214 one does not match. Use ok_for_xxx_bound for this purpose, assigning -1
9215 for "unknown if constant fits", 0 for "constant known *not* to fit" and 1
9216 for "constant known to fit". */
9217
9218 /* Check if c >= type_low_bound. */
9219 if (type_low_bound && TREE_CODE (type_low_bound) == INTEGER_CST)
9220 {
9221 if (tree_int_cst_lt (c, type_low_bound))
9222 return false;
9223 ok_for_low_bound = true;
9224 }
9225 else
9226 ok_for_low_bound = false;
9227
9228 /* Check if c <= type_high_bound. */
9229 if (type_high_bound && TREE_CODE (type_high_bound) == INTEGER_CST)
9230 {
9231 if (tree_int_cst_lt (type_high_bound, c))
9232 return false;
9233 ok_for_high_bound = true;
9234 }
9235 else
9236 ok_for_high_bound = false;
9237
9238 /* If the constant fits both bounds, the result is known. */
9239 if (ok_for_low_bound && ok_for_high_bound)
9240 return true;
9241
9242 /* Perform some generic filtering which may allow making a decision
9243 even if the bounds are not constant. First, negative integers
9244 never fit in unsigned types, */
9245 if (TYPE_UNSIGNED (type) && sgn_c == SIGNED && wi::neg_p (c))
9246 return false;
9247
9248 /* Second, narrower types always fit in wider ones. */
9249 if (TYPE_PRECISION (type) > TYPE_PRECISION (TREE_TYPE (c)))
9250 return true;
9251
9252 /* Third, unsigned integers with top bit set never fit signed types. */
9253 if (!TYPE_UNSIGNED (type) && sgn_c == UNSIGNED)
9254 {
9255 int prec = GET_MODE_PRECISION (TYPE_MODE (TREE_TYPE (c))) - 1;
9256 if (prec < TYPE_PRECISION (TREE_TYPE (c)))
9257 {
9258 /* When a tree_cst is converted to a wide-int, the precision
9259 is taken from the type. However, if the precision of the
9260 mode underneath the type is smaller than that, it is
9261 possible that the value will not fit. The test below
9262 fails if any bit is set between the sign bit of the
9263 underlying mode and the top bit of the type. */
9264 if (wi::ne_p (wi::zext (c, prec - 1), c))
9265 return false;
9266 }
9267 else if (wi::neg_p (c))
9268 return false;
9269 }
9270
9271 /* If we haven't been able to decide at this point, there nothing more we
9272 can check ourselves here. Look at the base type if we have one and it
9273 has the same precision. */
9274 if (TREE_CODE (type) == INTEGER_TYPE
9275 && TREE_TYPE (type) != 0
9276 && TYPE_PRECISION (type) == TYPE_PRECISION (TREE_TYPE (type)))
9277 {
9278 type = TREE_TYPE (type);
9279 goto retry;
9280 }
9281
9282 /* Or to fits_to_tree_p, if nothing else. */
9283 return wi::fits_to_tree_p (c, type);
9284 }
9285
9286 /* Stores bounds of an integer TYPE in MIN and MAX. If TYPE has non-constant
9287 bounds or is a POINTER_TYPE, the maximum and/or minimum values that can be
9288 represented (assuming two's-complement arithmetic) within the bit
9289 precision of the type are returned instead. */
9290
9291 void
9292 get_type_static_bounds (const_tree type, mpz_t min, mpz_t max)
9293 {
9294 if (!POINTER_TYPE_P (type) && TYPE_MIN_VALUE (type)
9295 && TREE_CODE (TYPE_MIN_VALUE (type)) == INTEGER_CST)
9296 wi::to_mpz (TYPE_MIN_VALUE (type), min, TYPE_SIGN (type));
9297 else
9298 {
9299 if (TYPE_UNSIGNED (type))
9300 mpz_set_ui (min, 0);
9301 else
9302 {
9303 wide_int mn = wi::min_value (TYPE_PRECISION (type), SIGNED);
9304 wi::to_mpz (mn, min, SIGNED);
9305 }
9306 }
9307
9308 if (!POINTER_TYPE_P (type) && TYPE_MAX_VALUE (type)
9309 && TREE_CODE (TYPE_MAX_VALUE (type)) == INTEGER_CST)
9310 wi::to_mpz (TYPE_MAX_VALUE (type), max, TYPE_SIGN (type));
9311 else
9312 {
9313 wide_int mn = wi::max_value (TYPE_PRECISION (type), TYPE_SIGN (type));
9314 wi::to_mpz (mn, max, TYPE_SIGN (type));
9315 }
9316 }
9317
9318 /* Return true if VAR is an automatic variable defined in function FN. */
9319
9320 bool
9321 auto_var_in_fn_p (const_tree var, const_tree fn)
9322 {
9323 return (DECL_P (var) && DECL_CONTEXT (var) == fn
9324 && ((((VAR_P (var) && ! DECL_EXTERNAL (var))
9325 || TREE_CODE (var) == PARM_DECL)
9326 && ! TREE_STATIC (var))
9327 || TREE_CODE (var) == LABEL_DECL
9328 || TREE_CODE (var) == RESULT_DECL));
9329 }
9330
9331 /* Subprogram of following function. Called by walk_tree.
9332
9333 Return *TP if it is an automatic variable or parameter of the
9334 function passed in as DATA. */
9335
9336 static tree
9337 find_var_from_fn (tree *tp, int *walk_subtrees, void *data)
9338 {
9339 tree fn = (tree) data;
9340
9341 if (TYPE_P (*tp))
9342 *walk_subtrees = 0;
9343
9344 else if (DECL_P (*tp)
9345 && auto_var_in_fn_p (*tp, fn))
9346 return *tp;
9347
9348 return NULL_TREE;
9349 }
9350
9351 /* Returns true if T is, contains, or refers to a type with variable
9352 size. For METHOD_TYPEs and FUNCTION_TYPEs we exclude the
9353 arguments, but not the return type. If FN is nonzero, only return
9354 true if a modifier of the type or position of FN is a variable or
9355 parameter inside FN.
9356
9357 This concept is more general than that of C99 'variably modified types':
9358 in C99, a struct type is never variably modified because a VLA may not
9359 appear as a structure member. However, in GNU C code like:
9360
9361 struct S { int i[f()]; };
9362
9363 is valid, and other languages may define similar constructs. */
9364
9365 bool
9366 variably_modified_type_p (tree type, tree fn)
9367 {
9368 tree t;
9369
9370 /* Test if T is either variable (if FN is zero) or an expression containing
9371 a variable in FN. If TYPE isn't gimplified, return true also if
9372 gimplify_one_sizepos would gimplify the expression into a local
9373 variable. */
9374 #define RETURN_TRUE_IF_VAR(T) \
9375 do { tree _t = (T); \
9376 if (_t != NULL_TREE \
9377 && _t != error_mark_node \
9378 && TREE_CODE (_t) != INTEGER_CST \
9379 && TREE_CODE (_t) != PLACEHOLDER_EXPR \
9380 && (!fn \
9381 || (!TYPE_SIZES_GIMPLIFIED (type) \
9382 && !is_gimple_sizepos (_t)) \
9383 || walk_tree (&_t, find_var_from_fn, fn, NULL))) \
9384 return true; } while (0)
9385
9386 if (type == error_mark_node)
9387 return false;
9388
9389 /* If TYPE itself has variable size, it is variably modified. */
9390 RETURN_TRUE_IF_VAR (TYPE_SIZE (type));
9391 RETURN_TRUE_IF_VAR (TYPE_SIZE_UNIT (type));
9392
9393 switch (TREE_CODE (type))
9394 {
9395 case POINTER_TYPE:
9396 case REFERENCE_TYPE:
9397 case VECTOR_TYPE:
9398 if (variably_modified_type_p (TREE_TYPE (type), fn))
9399 return true;
9400 break;
9401
9402 case FUNCTION_TYPE:
9403 case METHOD_TYPE:
9404 /* If TYPE is a function type, it is variably modified if the
9405 return type is variably modified. */
9406 if (variably_modified_type_p (TREE_TYPE (type), fn))
9407 return true;
9408 break;
9409
9410 case INTEGER_TYPE:
9411 case REAL_TYPE:
9412 case FIXED_POINT_TYPE:
9413 case ENUMERAL_TYPE:
9414 case BOOLEAN_TYPE:
9415 /* Scalar types are variably modified if their end points
9416 aren't constant. */
9417 RETURN_TRUE_IF_VAR (TYPE_MIN_VALUE (type));
9418 RETURN_TRUE_IF_VAR (TYPE_MAX_VALUE (type));
9419 break;
9420
9421 case RECORD_TYPE:
9422 case UNION_TYPE:
9423 case QUAL_UNION_TYPE:
9424 /* We can't see if any of the fields are variably-modified by the
9425 definition we normally use, since that would produce infinite
9426 recursion via pointers. */
9427 /* This is variably modified if some field's type is. */
9428 for (t = TYPE_FIELDS (type); t; t = DECL_CHAIN (t))
9429 if (TREE_CODE (t) == FIELD_DECL)
9430 {
9431 RETURN_TRUE_IF_VAR (DECL_FIELD_OFFSET (t));
9432 RETURN_TRUE_IF_VAR (DECL_SIZE (t));
9433 RETURN_TRUE_IF_VAR (DECL_SIZE_UNIT (t));
9434
9435 if (TREE_CODE (type) == QUAL_UNION_TYPE)
9436 RETURN_TRUE_IF_VAR (DECL_QUALIFIER (t));
9437 }
9438 break;
9439
9440 case ARRAY_TYPE:
9441 /* Do not call ourselves to avoid infinite recursion. This is
9442 variably modified if the element type is. */
9443 RETURN_TRUE_IF_VAR (TYPE_SIZE (TREE_TYPE (type)));
9444 RETURN_TRUE_IF_VAR (TYPE_SIZE_UNIT (TREE_TYPE (type)));
9445 break;
9446
9447 default:
9448 break;
9449 }
9450
9451 /* The current language may have other cases to check, but in general,
9452 all other types are not variably modified. */
9453 return lang_hooks.tree_inlining.var_mod_type_p (type, fn);
9454
9455 #undef RETURN_TRUE_IF_VAR
9456 }
9457
9458 /* Given a DECL or TYPE, return the scope in which it was declared, or
9459 NULL_TREE if there is no containing scope. */
9460
9461 tree
9462 get_containing_scope (const_tree t)
9463 {
9464 return (TYPE_P (t) ? TYPE_CONTEXT (t) : DECL_CONTEXT (t));
9465 }
9466
9467 /* Return the innermost context enclosing DECL that is
9468 a FUNCTION_DECL, or zero if none. */
9469
9470 tree
9471 decl_function_context (const_tree decl)
9472 {
9473 tree context;
9474
9475 if (TREE_CODE (decl) == ERROR_MARK)
9476 return 0;
9477
9478 /* C++ virtual functions use DECL_CONTEXT for the class of the vtable
9479 where we look up the function at runtime. Such functions always take
9480 a first argument of type 'pointer to real context'.
9481
9482 C++ should really be fixed to use DECL_CONTEXT for the real context,
9483 and use something else for the "virtual context". */
9484 else if (TREE_CODE (decl) == FUNCTION_DECL && DECL_VINDEX (decl))
9485 context
9486 = TYPE_MAIN_VARIANT
9487 (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl)))));
9488 else
9489 context = DECL_CONTEXT (decl);
9490
9491 while (context && TREE_CODE (context) != FUNCTION_DECL)
9492 {
9493 if (TREE_CODE (context) == BLOCK)
9494 context = BLOCK_SUPERCONTEXT (context);
9495 else
9496 context = get_containing_scope (context);
9497 }
9498
9499 return context;
9500 }
9501
9502 /* Return the innermost context enclosing DECL that is
9503 a RECORD_TYPE, UNION_TYPE or QUAL_UNION_TYPE, or zero if none.
9504 TYPE_DECLs and FUNCTION_DECLs are transparent to this function. */
9505
9506 tree
9507 decl_type_context (const_tree decl)
9508 {
9509 tree context = DECL_CONTEXT (decl);
9510
9511 while (context)
9512 switch (TREE_CODE (context))
9513 {
9514 case NAMESPACE_DECL:
9515 case TRANSLATION_UNIT_DECL:
9516 return NULL_TREE;
9517
9518 case RECORD_TYPE:
9519 case UNION_TYPE:
9520 case QUAL_UNION_TYPE:
9521 return context;
9522
9523 case TYPE_DECL:
9524 case FUNCTION_DECL:
9525 context = DECL_CONTEXT (context);
9526 break;
9527
9528 case BLOCK:
9529 context = BLOCK_SUPERCONTEXT (context);
9530 break;
9531
9532 default:
9533 gcc_unreachable ();
9534 }
9535
9536 return NULL_TREE;
9537 }
9538
9539 /* CALL is a CALL_EXPR. Return the declaration for the function
9540 called, or NULL_TREE if the called function cannot be
9541 determined. */
9542
9543 tree
9544 get_callee_fndecl (const_tree call)
9545 {
9546 tree addr;
9547
9548 if (call == error_mark_node)
9549 return error_mark_node;
9550
9551 /* It's invalid to call this function with anything but a
9552 CALL_EXPR. */
9553 gcc_assert (TREE_CODE (call) == CALL_EXPR);
9554
9555 /* The first operand to the CALL is the address of the function
9556 called. */
9557 addr = CALL_EXPR_FN (call);
9558
9559 /* If there is no function, return early. */
9560 if (addr == NULL_TREE)
9561 return NULL_TREE;
9562
9563 STRIP_NOPS (addr);
9564
9565 /* If this is a readonly function pointer, extract its initial value. */
9566 if (DECL_P (addr) && TREE_CODE (addr) != FUNCTION_DECL
9567 && TREE_READONLY (addr) && ! TREE_THIS_VOLATILE (addr)
9568 && DECL_INITIAL (addr))
9569 addr = DECL_INITIAL (addr);
9570
9571 /* If the address is just `&f' for some function `f', then we know
9572 that `f' is being called. */
9573 if (TREE_CODE (addr) == ADDR_EXPR
9574 && TREE_CODE (TREE_OPERAND (addr, 0)) == FUNCTION_DECL)
9575 return TREE_OPERAND (addr, 0);
9576
9577 /* We couldn't figure out what was being called. */
9578 return NULL_TREE;
9579 }
9580
9581 /* If CALL_EXPR CALL calls a normal built-in function or an internal function,
9582 return the associated function code, otherwise return CFN_LAST. */
9583
9584 combined_fn
9585 get_call_combined_fn (const_tree call)
9586 {
9587 /* It's invalid to call this function with anything but a CALL_EXPR. */
9588 gcc_assert (TREE_CODE (call) == CALL_EXPR);
9589
9590 if (!CALL_EXPR_FN (call))
9591 return as_combined_fn (CALL_EXPR_IFN (call));
9592
9593 tree fndecl = get_callee_fndecl (call);
9594 if (fndecl && DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL)
9595 return as_combined_fn (DECL_FUNCTION_CODE (fndecl));
9596
9597 return CFN_LAST;
9598 }
9599
9600 #define TREE_MEM_USAGE_SPACES 40
9601
9602 /* Print debugging information about tree nodes generated during the compile,
9603 and any language-specific information. */
9604
9605 void
9606 dump_tree_statistics (void)
9607 {
9608 if (GATHER_STATISTICS)
9609 {
9610 int i;
9611 int total_nodes, total_bytes;
9612 fprintf (stderr, "\nKind Nodes Bytes\n");
9613 mem_usage::print_dash_line (TREE_MEM_USAGE_SPACES);
9614 total_nodes = total_bytes = 0;
9615 for (i = 0; i < (int) all_kinds; i++)
9616 {
9617 fprintf (stderr, "%-20s %7d %10d\n", tree_node_kind_names[i],
9618 tree_node_counts[i], tree_node_sizes[i]);
9619 total_nodes += tree_node_counts[i];
9620 total_bytes += tree_node_sizes[i];
9621 }
9622 mem_usage::print_dash_line (TREE_MEM_USAGE_SPACES);
9623 fprintf (stderr, "%-20s %7d %10d\n", "Total", total_nodes, total_bytes);
9624 mem_usage::print_dash_line (TREE_MEM_USAGE_SPACES);
9625 fprintf (stderr, "Code Nodes\n");
9626 mem_usage::print_dash_line (TREE_MEM_USAGE_SPACES);
9627 for (i = 0; i < (int) MAX_TREE_CODES; i++)
9628 fprintf (stderr, "%-32s %7d\n", get_tree_code_name ((enum tree_code) i),
9629 tree_code_counts[i]);
9630 mem_usage::print_dash_line (TREE_MEM_USAGE_SPACES);
9631 fprintf (stderr, "\n");
9632 ssanames_print_statistics ();
9633 fprintf (stderr, "\n");
9634 phinodes_print_statistics ();
9635 fprintf (stderr, "\n");
9636 }
9637 else
9638 fprintf (stderr, "(No per-node statistics)\n");
9639
9640 print_type_hash_statistics ();
9641 print_debug_expr_statistics ();
9642 print_value_expr_statistics ();
9643 lang_hooks.print_statistics ();
9644 }
9645 \f
9646 #define FILE_FUNCTION_FORMAT "_GLOBAL__%s_%s"
9647
9648 /* Generate a crc32 of the low BYTES bytes of VALUE. */
9649
9650 unsigned
9651 crc32_unsigned_n (unsigned chksum, unsigned value, unsigned bytes)
9652 {
9653 /* This relies on the raw feedback's top 4 bits being zero. */
9654 #define FEEDBACK(X) ((X) * 0x04c11db7)
9655 #define SYNDROME(X) (FEEDBACK ((X) & 1) ^ FEEDBACK ((X) & 2) \
9656 ^ FEEDBACK ((X) & 4) ^ FEEDBACK ((X) & 8))
9657 static const unsigned syndromes[16] =
9658 {
9659 SYNDROME(0x0), SYNDROME(0x1), SYNDROME(0x2), SYNDROME(0x3),
9660 SYNDROME(0x4), SYNDROME(0x5), SYNDROME(0x6), SYNDROME(0x7),
9661 SYNDROME(0x8), SYNDROME(0x9), SYNDROME(0xa), SYNDROME(0xb),
9662 SYNDROME(0xc), SYNDROME(0xd), SYNDROME(0xe), SYNDROME(0xf),
9663 };
9664 #undef FEEDBACK
9665 #undef SYNDROME
9666
9667 value <<= (32 - bytes * 8);
9668 for (unsigned ix = bytes * 2; ix--; value <<= 4)
9669 {
9670 unsigned feedback = syndromes[((value ^ chksum) >> 28) & 0xf];
9671
9672 chksum = (chksum << 4) ^ feedback;
9673 }
9674
9675 return chksum;
9676 }
9677
9678 /* Generate a crc32 of a string. */
9679
9680 unsigned
9681 crc32_string (unsigned chksum, const char *string)
9682 {
9683 do
9684 chksum = crc32_byte (chksum, *string);
9685 while (*string++);
9686 return chksum;
9687 }
9688
9689 /* P is a string that will be used in a symbol. Mask out any characters
9690 that are not valid in that context. */
9691
9692 void
9693 clean_symbol_name (char *p)
9694 {
9695 for (; *p; p++)
9696 if (! (ISALNUM (*p)
9697 #ifndef NO_DOLLAR_IN_LABEL /* this for `$'; unlikely, but... -- kr */
9698 || *p == '$'
9699 #endif
9700 #ifndef NO_DOT_IN_LABEL /* this for `.'; unlikely, but... */
9701 || *p == '.'
9702 #endif
9703 ))
9704 *p = '_';
9705 }
9706
9707 /* For anonymous aggregate types, we need some sort of name to
9708 hold on to. In practice, this should not appear, but it should
9709 not be harmful if it does. */
9710 bool
9711 anon_aggrname_p(const_tree id_node)
9712 {
9713 #ifndef NO_DOT_IN_LABEL
9714 return (IDENTIFIER_POINTER (id_node)[0] == '.'
9715 && IDENTIFIER_POINTER (id_node)[1] == '_');
9716 #else /* NO_DOT_IN_LABEL */
9717 #ifndef NO_DOLLAR_IN_LABEL
9718 return (IDENTIFIER_POINTER (id_node)[0] == '$' \
9719 && IDENTIFIER_POINTER (id_node)[1] == '_');
9720 #else /* NO_DOLLAR_IN_LABEL */
9721 #define ANON_AGGRNAME_PREFIX "__anon_"
9722 return (!strncmp (IDENTIFIER_POINTER (id_node), ANON_AGGRNAME_PREFIX,
9723 sizeof (ANON_AGGRNAME_PREFIX) - 1));
9724 #endif /* NO_DOLLAR_IN_LABEL */
9725 #endif /* NO_DOT_IN_LABEL */
9726 }
9727
9728 /* Return a format for an anonymous aggregate name. */
9729 const char *
9730 anon_aggrname_format()
9731 {
9732 #ifndef NO_DOT_IN_LABEL
9733 return "._%d";
9734 #else /* NO_DOT_IN_LABEL */
9735 #ifndef NO_DOLLAR_IN_LABEL
9736 return "$_%d";
9737 #else /* NO_DOLLAR_IN_LABEL */
9738 return "__anon_%d";
9739 #endif /* NO_DOLLAR_IN_LABEL */
9740 #endif /* NO_DOT_IN_LABEL */
9741 }
9742
9743 /* Generate a name for a special-purpose function.
9744 The generated name may need to be unique across the whole link.
9745 Changes to this function may also require corresponding changes to
9746 xstrdup_mask_random.
9747 TYPE is some string to identify the purpose of this function to the
9748 linker or collect2; it must start with an uppercase letter,
9749 one of:
9750 I - for constructors
9751 D - for destructors
9752 N - for C++ anonymous namespaces
9753 F - for DWARF unwind frame information. */
9754
9755 tree
9756 get_file_function_name (const char *type)
9757 {
9758 char *buf;
9759 const char *p;
9760 char *q;
9761
9762 /* If we already have a name we know to be unique, just use that. */
9763 if (first_global_object_name)
9764 p = q = ASTRDUP (first_global_object_name);
9765 /* If the target is handling the constructors/destructors, they
9766 will be local to this file and the name is only necessary for
9767 debugging purposes.
9768 We also assign sub_I and sub_D sufixes to constructors called from
9769 the global static constructors. These are always local. */
9770 else if (((type[0] == 'I' || type[0] == 'D') && targetm.have_ctors_dtors)
9771 || (strncmp (type, "sub_", 4) == 0
9772 && (type[4] == 'I' || type[4] == 'D')))
9773 {
9774 const char *file = main_input_filename;
9775 if (! file)
9776 file = LOCATION_FILE (input_location);
9777 /* Just use the file's basename, because the full pathname
9778 might be quite long. */
9779 p = q = ASTRDUP (lbasename (file));
9780 }
9781 else
9782 {
9783 /* Otherwise, the name must be unique across the entire link.
9784 We don't have anything that we know to be unique to this translation
9785 unit, so use what we do have and throw in some randomness. */
9786 unsigned len;
9787 const char *name = weak_global_object_name;
9788 const char *file = main_input_filename;
9789
9790 if (! name)
9791 name = "";
9792 if (! file)
9793 file = LOCATION_FILE (input_location);
9794
9795 len = strlen (file);
9796 q = (char *) alloca (9 + 19 + len + 1);
9797 memcpy (q, file, len + 1);
9798
9799 snprintf (q + len, 9 + 19 + 1, "_%08X_" HOST_WIDE_INT_PRINT_HEX,
9800 crc32_string (0, name), get_random_seed (false));
9801
9802 p = q;
9803 }
9804
9805 clean_symbol_name (q);
9806 buf = (char *) alloca (sizeof (FILE_FUNCTION_FORMAT) + strlen (p)
9807 + strlen (type));
9808
9809 /* Set up the name of the file-level functions we may need.
9810 Use a global object (which is already required to be unique over
9811 the program) rather than the file name (which imposes extra
9812 constraints). */
9813 sprintf (buf, FILE_FUNCTION_FORMAT, type, p);
9814
9815 return get_identifier (buf);
9816 }
9817 \f
9818 #if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
9819
9820 /* Complain that the tree code of NODE does not match the expected 0
9821 terminated list of trailing codes. The trailing code list can be
9822 empty, for a more vague error message. FILE, LINE, and FUNCTION
9823 are of the caller. */
9824
9825 void
9826 tree_check_failed (const_tree node, const char *file,
9827 int line, const char *function, ...)
9828 {
9829 va_list args;
9830 const char *buffer;
9831 unsigned length = 0;
9832 enum tree_code code;
9833
9834 va_start (args, function);
9835 while ((code = (enum tree_code) va_arg (args, int)))
9836 length += 4 + strlen (get_tree_code_name (code));
9837 va_end (args);
9838 if (length)
9839 {
9840 char *tmp;
9841 va_start (args, function);
9842 length += strlen ("expected ");
9843 buffer = tmp = (char *) alloca (length);
9844 length = 0;
9845 while ((code = (enum tree_code) va_arg (args, int)))
9846 {
9847 const char *prefix = length ? " or " : "expected ";
9848
9849 strcpy (tmp + length, prefix);
9850 length += strlen (prefix);
9851 strcpy (tmp + length, get_tree_code_name (code));
9852 length += strlen (get_tree_code_name (code));
9853 }
9854 va_end (args);
9855 }
9856 else
9857 buffer = "unexpected node";
9858
9859 internal_error ("tree check: %s, have %s in %s, at %s:%d",
9860 buffer, get_tree_code_name (TREE_CODE (node)),
9861 function, trim_filename (file), line);
9862 }
9863
9864 /* Complain that the tree code of NODE does match the expected 0
9865 terminated list of trailing codes. FILE, LINE, and FUNCTION are of
9866 the caller. */
9867
9868 void
9869 tree_not_check_failed (const_tree node, const char *file,
9870 int line, const char *function, ...)
9871 {
9872 va_list args;
9873 char *buffer;
9874 unsigned length = 0;
9875 enum tree_code code;
9876
9877 va_start (args, function);
9878 while ((code = (enum tree_code) va_arg (args, int)))
9879 length += 4 + strlen (get_tree_code_name (code));
9880 va_end (args);
9881 va_start (args, function);
9882 buffer = (char *) alloca (length);
9883 length = 0;
9884 while ((code = (enum tree_code) va_arg (args, int)))
9885 {
9886 if (length)
9887 {
9888 strcpy (buffer + length, " or ");
9889 length += 4;
9890 }
9891 strcpy (buffer + length, get_tree_code_name (code));
9892 length += strlen (get_tree_code_name (code));
9893 }
9894 va_end (args);
9895
9896 internal_error ("tree check: expected none of %s, have %s in %s, at %s:%d",
9897 buffer, get_tree_code_name (TREE_CODE (node)),
9898 function, trim_filename (file), line);
9899 }
9900
9901 /* Similar to tree_check_failed, except that we check for a class of tree
9902 code, given in CL. */
9903
9904 void
9905 tree_class_check_failed (const_tree node, const enum tree_code_class cl,
9906 const char *file, int line, const char *function)
9907 {
9908 internal_error
9909 ("tree check: expected class %qs, have %qs (%s) in %s, at %s:%d",
9910 TREE_CODE_CLASS_STRING (cl),
9911 TREE_CODE_CLASS_STRING (TREE_CODE_CLASS (TREE_CODE (node))),
9912 get_tree_code_name (TREE_CODE (node)), function, trim_filename (file), line);
9913 }
9914
9915 /* Similar to tree_check_failed, except that instead of specifying a
9916 dozen codes, use the knowledge that they're all sequential. */
9917
9918 void
9919 tree_range_check_failed (const_tree node, const char *file, int line,
9920 const char *function, enum tree_code c1,
9921 enum tree_code c2)
9922 {
9923 char *buffer;
9924 unsigned length = 0;
9925 unsigned int c;
9926
9927 for (c = c1; c <= c2; ++c)
9928 length += 4 + strlen (get_tree_code_name ((enum tree_code) c));
9929
9930 length += strlen ("expected ");
9931 buffer = (char *) alloca (length);
9932 length = 0;
9933
9934 for (c = c1; c <= c2; ++c)
9935 {
9936 const char *prefix = length ? " or " : "expected ";
9937
9938 strcpy (buffer + length, prefix);
9939 length += strlen (prefix);
9940 strcpy (buffer + length, get_tree_code_name ((enum tree_code) c));
9941 length += strlen (get_tree_code_name ((enum tree_code) c));
9942 }
9943
9944 internal_error ("tree check: %s, have %s in %s, at %s:%d",
9945 buffer, get_tree_code_name (TREE_CODE (node)),
9946 function, trim_filename (file), line);
9947 }
9948
9949
9950 /* Similar to tree_check_failed, except that we check that a tree does
9951 not have the specified code, given in CL. */
9952
9953 void
9954 tree_not_class_check_failed (const_tree node, const enum tree_code_class cl,
9955 const char *file, int line, const char *function)
9956 {
9957 internal_error
9958 ("tree check: did not expect class %qs, have %qs (%s) in %s, at %s:%d",
9959 TREE_CODE_CLASS_STRING (cl),
9960 TREE_CODE_CLASS_STRING (TREE_CODE_CLASS (TREE_CODE (node))),
9961 get_tree_code_name (TREE_CODE (node)), function, trim_filename (file), line);
9962 }
9963
9964
9965 /* Similar to tree_check_failed but applied to OMP_CLAUSE codes. */
9966
9967 void
9968 omp_clause_check_failed (const_tree node, const char *file, int line,
9969 const char *function, enum omp_clause_code code)
9970 {
9971 internal_error ("tree check: expected omp_clause %s, have %s in %s, at %s:%d",
9972 omp_clause_code_name[code], get_tree_code_name (TREE_CODE (node)),
9973 function, trim_filename (file), line);
9974 }
9975
9976
9977 /* Similar to tree_range_check_failed but applied to OMP_CLAUSE codes. */
9978
9979 void
9980 omp_clause_range_check_failed (const_tree node, const char *file, int line,
9981 const char *function, enum omp_clause_code c1,
9982 enum omp_clause_code c2)
9983 {
9984 char *buffer;
9985 unsigned length = 0;
9986 unsigned int c;
9987
9988 for (c = c1; c <= c2; ++c)
9989 length += 4 + strlen (omp_clause_code_name[c]);
9990
9991 length += strlen ("expected ");
9992 buffer = (char *) alloca (length);
9993 length = 0;
9994
9995 for (c = c1; c <= c2; ++c)
9996 {
9997 const char *prefix = length ? " or " : "expected ";
9998
9999 strcpy (buffer + length, prefix);
10000 length += strlen (prefix);
10001 strcpy (buffer + length, omp_clause_code_name[c]);
10002 length += strlen (omp_clause_code_name[c]);
10003 }
10004
10005 internal_error ("tree check: %s, have %s in %s, at %s:%d",
10006 buffer, omp_clause_code_name[TREE_CODE (node)],
10007 function, trim_filename (file), line);
10008 }
10009
10010
10011 #undef DEFTREESTRUCT
10012 #define DEFTREESTRUCT(VAL, NAME) NAME,
10013
10014 static const char *ts_enum_names[] = {
10015 #include "treestruct.def"
10016 };
10017 #undef DEFTREESTRUCT
10018
10019 #define TS_ENUM_NAME(EN) (ts_enum_names[(EN)])
10020
10021 /* Similar to tree_class_check_failed, except that we check for
10022 whether CODE contains the tree structure identified by EN. */
10023
10024 void
10025 tree_contains_struct_check_failed (const_tree node,
10026 const enum tree_node_structure_enum en,
10027 const char *file, int line,
10028 const char *function)
10029 {
10030 internal_error
10031 ("tree check: expected tree that contains %qs structure, have %qs in %s, at %s:%d",
10032 TS_ENUM_NAME (en),
10033 get_tree_code_name (TREE_CODE (node)), function, trim_filename (file), line);
10034 }
10035
10036
10037 /* Similar to above, except that the check is for the bounds of a TREE_VEC's
10038 (dynamically sized) vector. */
10039
10040 void
10041 tree_int_cst_elt_check_failed (int idx, int len, const char *file, int line,
10042 const char *function)
10043 {
10044 internal_error
10045 ("tree check: accessed elt %d of tree_int_cst with %d elts in %s, at %s:%d",
10046 idx + 1, len, function, trim_filename (file), line);
10047 }
10048
10049 /* Similar to above, except that the check is for the bounds of a TREE_VEC's
10050 (dynamically sized) vector. */
10051
10052 void
10053 tree_vec_elt_check_failed (int idx, int len, const char *file, int line,
10054 const char *function)
10055 {
10056 internal_error
10057 ("tree check: accessed elt %d of tree_vec with %d elts in %s, at %s:%d",
10058 idx + 1, len, function, trim_filename (file), line);
10059 }
10060
10061 /* Similar to above, except that the check is for the bounds of the operand
10062 vector of an expression node EXP. */
10063
10064 void
10065 tree_operand_check_failed (int idx, const_tree exp, const char *file,
10066 int line, const char *function)
10067 {
10068 enum tree_code code = TREE_CODE (exp);
10069 internal_error
10070 ("tree check: accessed operand %d of %s with %d operands in %s, at %s:%d",
10071 idx + 1, get_tree_code_name (code), TREE_OPERAND_LENGTH (exp),
10072 function, trim_filename (file), line);
10073 }
10074
10075 /* Similar to above, except that the check is for the number of
10076 operands of an OMP_CLAUSE node. */
10077
10078 void
10079 omp_clause_operand_check_failed (int idx, const_tree t, const char *file,
10080 int line, const char *function)
10081 {
10082 internal_error
10083 ("tree check: accessed operand %d of omp_clause %s with %d operands "
10084 "in %s, at %s:%d", idx + 1, omp_clause_code_name[OMP_CLAUSE_CODE (t)],
10085 omp_clause_num_ops [OMP_CLAUSE_CODE (t)], function,
10086 trim_filename (file), line);
10087 }
10088 #endif /* ENABLE_TREE_CHECKING */
10089 \f
10090 /* Create a new vector type node holding SUBPARTS units of type INNERTYPE,
10091 and mapped to the machine mode MODE. Initialize its fields and build
10092 the information necessary for debugging output. */
10093
10094 static tree
10095 make_vector_type (tree innertype, int nunits, machine_mode mode)
10096 {
10097 tree t;
10098 tree mv_innertype = TYPE_MAIN_VARIANT (innertype);
10099
10100 t = make_node (VECTOR_TYPE);
10101 TREE_TYPE (t) = mv_innertype;
10102 SET_TYPE_VECTOR_SUBPARTS (t, nunits);
10103 SET_TYPE_MODE (t, mode);
10104
10105 if (TYPE_STRUCTURAL_EQUALITY_P (mv_innertype) || in_lto_p)
10106 SET_TYPE_STRUCTURAL_EQUALITY (t);
10107 else if ((TYPE_CANONICAL (mv_innertype) != innertype
10108 || mode != VOIDmode)
10109 && !VECTOR_BOOLEAN_TYPE_P (t))
10110 TYPE_CANONICAL (t)
10111 = make_vector_type (TYPE_CANONICAL (mv_innertype), nunits, VOIDmode);
10112
10113 layout_type (t);
10114
10115 hashval_t hash = type_hash_canon_hash (t);
10116 t = type_hash_canon (hash, t);
10117
10118 /* We have built a main variant, based on the main variant of the
10119 inner type. Use it to build the variant we return. */
10120 if ((TYPE_ATTRIBUTES (innertype) || TYPE_QUALS (innertype))
10121 && TREE_TYPE (t) != innertype)
10122 return build_type_attribute_qual_variant (t,
10123 TYPE_ATTRIBUTES (innertype),
10124 TYPE_QUALS (innertype));
10125
10126 return t;
10127 }
10128
10129 static tree
10130 make_or_reuse_type (unsigned size, int unsignedp)
10131 {
10132 int i;
10133
10134 if (size == INT_TYPE_SIZE)
10135 return unsignedp ? unsigned_type_node : integer_type_node;
10136 if (size == CHAR_TYPE_SIZE)
10137 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
10138 if (size == SHORT_TYPE_SIZE)
10139 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
10140 if (size == LONG_TYPE_SIZE)
10141 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
10142 if (size == LONG_LONG_TYPE_SIZE)
10143 return (unsignedp ? long_long_unsigned_type_node
10144 : long_long_integer_type_node);
10145
10146 for (i = 0; i < NUM_INT_N_ENTS; i ++)
10147 if (size == int_n_data[i].bitsize
10148 && int_n_enabled_p[i])
10149 return (unsignedp ? int_n_trees[i].unsigned_type
10150 : int_n_trees[i].signed_type);
10151
10152 if (unsignedp)
10153 return make_unsigned_type (size);
10154 else
10155 return make_signed_type (size);
10156 }
10157
10158 /* Create or reuse a fract type by SIZE, UNSIGNEDP, and SATP. */
10159
10160 static tree
10161 make_or_reuse_fract_type (unsigned size, int unsignedp, int satp)
10162 {
10163 if (satp)
10164 {
10165 if (size == SHORT_FRACT_TYPE_SIZE)
10166 return unsignedp ? sat_unsigned_short_fract_type_node
10167 : sat_short_fract_type_node;
10168 if (size == FRACT_TYPE_SIZE)
10169 return unsignedp ? sat_unsigned_fract_type_node : sat_fract_type_node;
10170 if (size == LONG_FRACT_TYPE_SIZE)
10171 return unsignedp ? sat_unsigned_long_fract_type_node
10172 : sat_long_fract_type_node;
10173 if (size == LONG_LONG_FRACT_TYPE_SIZE)
10174 return unsignedp ? sat_unsigned_long_long_fract_type_node
10175 : sat_long_long_fract_type_node;
10176 }
10177 else
10178 {
10179 if (size == SHORT_FRACT_TYPE_SIZE)
10180 return unsignedp ? unsigned_short_fract_type_node
10181 : short_fract_type_node;
10182 if (size == FRACT_TYPE_SIZE)
10183 return unsignedp ? unsigned_fract_type_node : fract_type_node;
10184 if (size == LONG_FRACT_TYPE_SIZE)
10185 return unsignedp ? unsigned_long_fract_type_node
10186 : long_fract_type_node;
10187 if (size == LONG_LONG_FRACT_TYPE_SIZE)
10188 return unsignedp ? unsigned_long_long_fract_type_node
10189 : long_long_fract_type_node;
10190 }
10191
10192 return make_fract_type (size, unsignedp, satp);
10193 }
10194
10195 /* Create or reuse an accum type by SIZE, UNSIGNEDP, and SATP. */
10196
10197 static tree
10198 make_or_reuse_accum_type (unsigned size, int unsignedp, int satp)
10199 {
10200 if (satp)
10201 {
10202 if (size == SHORT_ACCUM_TYPE_SIZE)
10203 return unsignedp ? sat_unsigned_short_accum_type_node
10204 : sat_short_accum_type_node;
10205 if (size == ACCUM_TYPE_SIZE)
10206 return unsignedp ? sat_unsigned_accum_type_node : sat_accum_type_node;
10207 if (size == LONG_ACCUM_TYPE_SIZE)
10208 return unsignedp ? sat_unsigned_long_accum_type_node
10209 : sat_long_accum_type_node;
10210 if (size == LONG_LONG_ACCUM_TYPE_SIZE)
10211 return unsignedp ? sat_unsigned_long_long_accum_type_node
10212 : sat_long_long_accum_type_node;
10213 }
10214 else
10215 {
10216 if (size == SHORT_ACCUM_TYPE_SIZE)
10217 return unsignedp ? unsigned_short_accum_type_node
10218 : short_accum_type_node;
10219 if (size == ACCUM_TYPE_SIZE)
10220 return unsignedp ? unsigned_accum_type_node : accum_type_node;
10221 if (size == LONG_ACCUM_TYPE_SIZE)
10222 return unsignedp ? unsigned_long_accum_type_node
10223 : long_accum_type_node;
10224 if (size == LONG_LONG_ACCUM_TYPE_SIZE)
10225 return unsignedp ? unsigned_long_long_accum_type_node
10226 : long_long_accum_type_node;
10227 }
10228
10229 return make_accum_type (size, unsignedp, satp);
10230 }
10231
10232
10233 /* Create an atomic variant node for TYPE. This routine is called
10234 during initialization of data types to create the 5 basic atomic
10235 types. The generic build_variant_type function requires these to
10236 already be set up in order to function properly, so cannot be
10237 called from there. If ALIGN is non-zero, then ensure alignment is
10238 overridden to this value. */
10239
10240 static tree
10241 build_atomic_base (tree type, unsigned int align)
10242 {
10243 tree t;
10244
10245 /* Make sure its not already registered. */
10246 if ((t = get_qualified_type (type, TYPE_QUAL_ATOMIC)))
10247 return t;
10248
10249 t = build_variant_type_copy (type);
10250 set_type_quals (t, TYPE_QUAL_ATOMIC);
10251
10252 if (align)
10253 SET_TYPE_ALIGN (t, align);
10254
10255 return t;
10256 }
10257
10258 /* Information about the _FloatN and _FloatNx types. This must be in
10259 the same order as the corresponding TI_* enum values. */
10260 const floatn_type_info floatn_nx_types[NUM_FLOATN_NX_TYPES] =
10261 {
10262 { 16, false },
10263 { 32, false },
10264 { 64, false },
10265 { 128, false },
10266 { 32, true },
10267 { 64, true },
10268 { 128, true },
10269 };
10270
10271
10272 /* Create nodes for all integer types (and error_mark_node) using the sizes
10273 of C datatypes. SIGNED_CHAR specifies whether char is signed. */
10274
10275 void
10276 build_common_tree_nodes (bool signed_char)
10277 {
10278 int i;
10279
10280 error_mark_node = make_node (ERROR_MARK);
10281 TREE_TYPE (error_mark_node) = error_mark_node;
10282
10283 initialize_sizetypes ();
10284
10285 /* Define both `signed char' and `unsigned char'. */
10286 signed_char_type_node = make_signed_type (CHAR_TYPE_SIZE);
10287 TYPE_STRING_FLAG (signed_char_type_node) = 1;
10288 unsigned_char_type_node = make_unsigned_type (CHAR_TYPE_SIZE);
10289 TYPE_STRING_FLAG (unsigned_char_type_node) = 1;
10290
10291 /* Define `char', which is like either `signed char' or `unsigned char'
10292 but not the same as either. */
10293 char_type_node
10294 = (signed_char
10295 ? make_signed_type (CHAR_TYPE_SIZE)
10296 : make_unsigned_type (CHAR_TYPE_SIZE));
10297 TYPE_STRING_FLAG (char_type_node) = 1;
10298
10299 short_integer_type_node = make_signed_type (SHORT_TYPE_SIZE);
10300 short_unsigned_type_node = make_unsigned_type (SHORT_TYPE_SIZE);
10301 integer_type_node = make_signed_type (INT_TYPE_SIZE);
10302 unsigned_type_node = make_unsigned_type (INT_TYPE_SIZE);
10303 long_integer_type_node = make_signed_type (LONG_TYPE_SIZE);
10304 long_unsigned_type_node = make_unsigned_type (LONG_TYPE_SIZE);
10305 long_long_integer_type_node = make_signed_type (LONG_LONG_TYPE_SIZE);
10306 long_long_unsigned_type_node = make_unsigned_type (LONG_LONG_TYPE_SIZE);
10307
10308 for (i = 0; i < NUM_INT_N_ENTS; i ++)
10309 {
10310 int_n_trees[i].signed_type = make_signed_type (int_n_data[i].bitsize);
10311 int_n_trees[i].unsigned_type = make_unsigned_type (int_n_data[i].bitsize);
10312 TYPE_SIZE (int_n_trees[i].signed_type) = bitsize_int (int_n_data[i].bitsize);
10313 TYPE_SIZE (int_n_trees[i].unsigned_type) = bitsize_int (int_n_data[i].bitsize);
10314
10315 if (int_n_data[i].bitsize > LONG_LONG_TYPE_SIZE
10316 && int_n_enabled_p[i])
10317 {
10318 integer_types[itk_intN_0 + i * 2] = int_n_trees[i].signed_type;
10319 integer_types[itk_unsigned_intN_0 + i * 2] = int_n_trees[i].unsigned_type;
10320 }
10321 }
10322
10323 /* Define a boolean type. This type only represents boolean values but
10324 may be larger than char depending on the value of BOOL_TYPE_SIZE. */
10325 boolean_type_node = make_unsigned_type (BOOL_TYPE_SIZE);
10326 TREE_SET_CODE (boolean_type_node, BOOLEAN_TYPE);
10327 TYPE_PRECISION (boolean_type_node) = 1;
10328 TYPE_MAX_VALUE (boolean_type_node) = build_int_cst (boolean_type_node, 1);
10329
10330 /* Define what type to use for size_t. */
10331 if (strcmp (SIZE_TYPE, "unsigned int") == 0)
10332 size_type_node = unsigned_type_node;
10333 else if (strcmp (SIZE_TYPE, "long unsigned int") == 0)
10334 size_type_node = long_unsigned_type_node;
10335 else if (strcmp (SIZE_TYPE, "long long unsigned int") == 0)
10336 size_type_node = long_long_unsigned_type_node;
10337 else if (strcmp (SIZE_TYPE, "short unsigned int") == 0)
10338 size_type_node = short_unsigned_type_node;
10339 else
10340 {
10341 int i;
10342
10343 size_type_node = NULL_TREE;
10344 for (i = 0; i < NUM_INT_N_ENTS; i++)
10345 if (int_n_enabled_p[i])
10346 {
10347 char name[50];
10348 sprintf (name, "__int%d unsigned", int_n_data[i].bitsize);
10349
10350 if (strcmp (name, SIZE_TYPE) == 0)
10351 {
10352 size_type_node = int_n_trees[i].unsigned_type;
10353 }
10354 }
10355 if (size_type_node == NULL_TREE)
10356 gcc_unreachable ();
10357 }
10358
10359 /* Define what type to use for ptrdiff_t. */
10360 if (strcmp (PTRDIFF_TYPE, "int") == 0)
10361 ptrdiff_type_node = integer_type_node;
10362 else if (strcmp (PTRDIFF_TYPE, "long int") == 0)
10363 ptrdiff_type_node = long_integer_type_node;
10364 else if (strcmp (PTRDIFF_TYPE, "long long int") == 0)
10365 ptrdiff_type_node = long_long_integer_type_node;
10366 else if (strcmp (PTRDIFF_TYPE, "short int") == 0)
10367 ptrdiff_type_node = short_integer_type_node;
10368 else
10369 {
10370 ptrdiff_type_node = NULL_TREE;
10371 for (int i = 0; i < NUM_INT_N_ENTS; i++)
10372 if (int_n_enabled_p[i])
10373 {
10374 char name[50];
10375 sprintf (name, "__int%d", int_n_data[i].bitsize);
10376 if (strcmp (name, PTRDIFF_TYPE) == 0)
10377 ptrdiff_type_node = int_n_trees[i].signed_type;
10378 }
10379 if (ptrdiff_type_node == NULL_TREE)
10380 gcc_unreachable ();
10381 }
10382
10383 /* Fill in the rest of the sized types. Reuse existing type nodes
10384 when possible. */
10385 intQI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (QImode), 0);
10386 intHI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (HImode), 0);
10387 intSI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (SImode), 0);
10388 intDI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (DImode), 0);
10389 intTI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (TImode), 0);
10390
10391 unsigned_intQI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (QImode), 1);
10392 unsigned_intHI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (HImode), 1);
10393 unsigned_intSI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (SImode), 1);
10394 unsigned_intDI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (DImode), 1);
10395 unsigned_intTI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (TImode), 1);
10396
10397 /* Don't call build_qualified type for atomics. That routine does
10398 special processing for atomics, and until they are initialized
10399 it's better not to make that call.
10400
10401 Check to see if there is a target override for atomic types. */
10402
10403 atomicQI_type_node = build_atomic_base (unsigned_intQI_type_node,
10404 targetm.atomic_align_for_mode (QImode));
10405 atomicHI_type_node = build_atomic_base (unsigned_intHI_type_node,
10406 targetm.atomic_align_for_mode (HImode));
10407 atomicSI_type_node = build_atomic_base (unsigned_intSI_type_node,
10408 targetm.atomic_align_for_mode (SImode));
10409 atomicDI_type_node = build_atomic_base (unsigned_intDI_type_node,
10410 targetm.atomic_align_for_mode (DImode));
10411 atomicTI_type_node = build_atomic_base (unsigned_intTI_type_node,
10412 targetm.atomic_align_for_mode (TImode));
10413
10414 access_public_node = get_identifier ("public");
10415 access_protected_node = get_identifier ("protected");
10416 access_private_node = get_identifier ("private");
10417
10418 /* Define these next since types below may used them. */
10419 integer_zero_node = build_int_cst (integer_type_node, 0);
10420 integer_one_node = build_int_cst (integer_type_node, 1);
10421 integer_three_node = build_int_cst (integer_type_node, 3);
10422 integer_minus_one_node = build_int_cst (integer_type_node, -1);
10423
10424 size_zero_node = size_int (0);
10425 size_one_node = size_int (1);
10426 bitsize_zero_node = bitsize_int (0);
10427 bitsize_one_node = bitsize_int (1);
10428 bitsize_unit_node = bitsize_int (BITS_PER_UNIT);
10429
10430 boolean_false_node = TYPE_MIN_VALUE (boolean_type_node);
10431 boolean_true_node = TYPE_MAX_VALUE (boolean_type_node);
10432
10433 void_type_node = make_node (VOID_TYPE);
10434 layout_type (void_type_node);
10435
10436 pointer_bounds_type_node = targetm.chkp_bound_type ();
10437
10438 /* We are not going to have real types in C with less than byte alignment,
10439 so we might as well not have any types that claim to have it. */
10440 SET_TYPE_ALIGN (void_type_node, BITS_PER_UNIT);
10441 TYPE_USER_ALIGN (void_type_node) = 0;
10442
10443 void_node = make_node (VOID_CST);
10444 TREE_TYPE (void_node) = void_type_node;
10445
10446 null_pointer_node = build_int_cst (build_pointer_type (void_type_node), 0);
10447 layout_type (TREE_TYPE (null_pointer_node));
10448
10449 ptr_type_node = build_pointer_type (void_type_node);
10450 const_ptr_type_node
10451 = build_pointer_type (build_type_variant (void_type_node, 1, 0));
10452 fileptr_type_node = ptr_type_node;
10453 const_tm_ptr_type_node = const_ptr_type_node;
10454
10455 pointer_sized_int_node = build_nonstandard_integer_type (POINTER_SIZE, 1);
10456
10457 float_type_node = make_node (REAL_TYPE);
10458 TYPE_PRECISION (float_type_node) = FLOAT_TYPE_SIZE;
10459 layout_type (float_type_node);
10460
10461 double_type_node = make_node (REAL_TYPE);
10462 TYPE_PRECISION (double_type_node) = DOUBLE_TYPE_SIZE;
10463 layout_type (double_type_node);
10464
10465 long_double_type_node = make_node (REAL_TYPE);
10466 TYPE_PRECISION (long_double_type_node) = LONG_DOUBLE_TYPE_SIZE;
10467 layout_type (long_double_type_node);
10468
10469 for (i = 0; i < NUM_FLOATN_NX_TYPES; i++)
10470 {
10471 int n = floatn_nx_types[i].n;
10472 bool extended = floatn_nx_types[i].extended;
10473 machine_mode mode = targetm.floatn_mode (n, extended);
10474 if (mode == VOIDmode)
10475 continue;
10476 int precision = GET_MODE_PRECISION (mode);
10477 /* Work around the rs6000 KFmode having precision 113 not
10478 128. */
10479 const struct real_format *fmt = REAL_MODE_FORMAT (mode);
10480 gcc_assert (fmt->b == 2 && fmt->emin + fmt->emax == 3);
10481 int min_precision = fmt->p + ceil_log2 (fmt->emax - fmt->emin);
10482 if (!extended)
10483 gcc_assert (min_precision == n);
10484 if (precision < min_precision)
10485 precision = min_precision;
10486 FLOATN_NX_TYPE_NODE (i) = make_node (REAL_TYPE);
10487 TYPE_PRECISION (FLOATN_NX_TYPE_NODE (i)) = precision;
10488 layout_type (FLOATN_NX_TYPE_NODE (i));
10489 SET_TYPE_MODE (FLOATN_NX_TYPE_NODE (i), mode);
10490 }
10491
10492 float_ptr_type_node = build_pointer_type (float_type_node);
10493 double_ptr_type_node = build_pointer_type (double_type_node);
10494 long_double_ptr_type_node = build_pointer_type (long_double_type_node);
10495 integer_ptr_type_node = build_pointer_type (integer_type_node);
10496
10497 /* Fixed size integer types. */
10498 uint16_type_node = make_or_reuse_type (16, 1);
10499 uint32_type_node = make_or_reuse_type (32, 1);
10500 uint64_type_node = make_or_reuse_type (64, 1);
10501
10502 /* Decimal float types. */
10503 dfloat32_type_node = make_node (REAL_TYPE);
10504 TYPE_PRECISION (dfloat32_type_node) = DECIMAL32_TYPE_SIZE;
10505 SET_TYPE_MODE (dfloat32_type_node, SDmode);
10506 layout_type (dfloat32_type_node);
10507 dfloat32_ptr_type_node = build_pointer_type (dfloat32_type_node);
10508
10509 dfloat64_type_node = make_node (REAL_TYPE);
10510 TYPE_PRECISION (dfloat64_type_node) = DECIMAL64_TYPE_SIZE;
10511 SET_TYPE_MODE (dfloat64_type_node, DDmode);
10512 layout_type (dfloat64_type_node);
10513 dfloat64_ptr_type_node = build_pointer_type (dfloat64_type_node);
10514
10515 dfloat128_type_node = make_node (REAL_TYPE);
10516 TYPE_PRECISION (dfloat128_type_node) = DECIMAL128_TYPE_SIZE;
10517 SET_TYPE_MODE (dfloat128_type_node, TDmode);
10518 layout_type (dfloat128_type_node);
10519 dfloat128_ptr_type_node = build_pointer_type (dfloat128_type_node);
10520
10521 complex_integer_type_node = build_complex_type (integer_type_node, true);
10522 complex_float_type_node = build_complex_type (float_type_node, true);
10523 complex_double_type_node = build_complex_type (double_type_node, true);
10524 complex_long_double_type_node = build_complex_type (long_double_type_node,
10525 true);
10526
10527 for (i = 0; i < NUM_FLOATN_NX_TYPES; i++)
10528 {
10529 if (FLOATN_NX_TYPE_NODE (i) != NULL_TREE)
10530 COMPLEX_FLOATN_NX_TYPE_NODE (i)
10531 = build_complex_type (FLOATN_NX_TYPE_NODE (i));
10532 }
10533
10534 /* Make fixed-point nodes based on sat/non-sat and signed/unsigned. */
10535 #define MAKE_FIXED_TYPE_NODE(KIND,SIZE) \
10536 sat_ ## KIND ## _type_node = \
10537 make_sat_signed_ ## KIND ## _type (SIZE); \
10538 sat_unsigned_ ## KIND ## _type_node = \
10539 make_sat_unsigned_ ## KIND ## _type (SIZE); \
10540 KIND ## _type_node = make_signed_ ## KIND ## _type (SIZE); \
10541 unsigned_ ## KIND ## _type_node = \
10542 make_unsigned_ ## KIND ## _type (SIZE);
10543
10544 #define MAKE_FIXED_TYPE_NODE_WIDTH(KIND,WIDTH,SIZE) \
10545 sat_ ## WIDTH ## KIND ## _type_node = \
10546 make_sat_signed_ ## KIND ## _type (SIZE); \
10547 sat_unsigned_ ## WIDTH ## KIND ## _type_node = \
10548 make_sat_unsigned_ ## KIND ## _type (SIZE); \
10549 WIDTH ## KIND ## _type_node = make_signed_ ## KIND ## _type (SIZE); \
10550 unsigned_ ## WIDTH ## KIND ## _type_node = \
10551 make_unsigned_ ## KIND ## _type (SIZE);
10552
10553 /* Make fixed-point type nodes based on four different widths. */
10554 #define MAKE_FIXED_TYPE_NODE_FAMILY(N1,N2) \
10555 MAKE_FIXED_TYPE_NODE_WIDTH (N1, short_, SHORT_ ## N2 ## _TYPE_SIZE) \
10556 MAKE_FIXED_TYPE_NODE (N1, N2 ## _TYPE_SIZE) \
10557 MAKE_FIXED_TYPE_NODE_WIDTH (N1, long_, LONG_ ## N2 ## _TYPE_SIZE) \
10558 MAKE_FIXED_TYPE_NODE_WIDTH (N1, long_long_, LONG_LONG_ ## N2 ## _TYPE_SIZE)
10559
10560 /* Make fixed-point mode nodes based on sat/non-sat and signed/unsigned. */
10561 #define MAKE_FIXED_MODE_NODE(KIND,NAME,MODE) \
10562 NAME ## _type_node = \
10563 make_or_reuse_signed_ ## KIND ## _type (GET_MODE_BITSIZE (MODE ## mode)); \
10564 u ## NAME ## _type_node = \
10565 make_or_reuse_unsigned_ ## KIND ## _type \
10566 (GET_MODE_BITSIZE (U ## MODE ## mode)); \
10567 sat_ ## NAME ## _type_node = \
10568 make_or_reuse_sat_signed_ ## KIND ## _type \
10569 (GET_MODE_BITSIZE (MODE ## mode)); \
10570 sat_u ## NAME ## _type_node = \
10571 make_or_reuse_sat_unsigned_ ## KIND ## _type \
10572 (GET_MODE_BITSIZE (U ## MODE ## mode));
10573
10574 /* Fixed-point type and mode nodes. */
10575 MAKE_FIXED_TYPE_NODE_FAMILY (fract, FRACT)
10576 MAKE_FIXED_TYPE_NODE_FAMILY (accum, ACCUM)
10577 MAKE_FIXED_MODE_NODE (fract, qq, QQ)
10578 MAKE_FIXED_MODE_NODE (fract, hq, HQ)
10579 MAKE_FIXED_MODE_NODE (fract, sq, SQ)
10580 MAKE_FIXED_MODE_NODE (fract, dq, DQ)
10581 MAKE_FIXED_MODE_NODE (fract, tq, TQ)
10582 MAKE_FIXED_MODE_NODE (accum, ha, HA)
10583 MAKE_FIXED_MODE_NODE (accum, sa, SA)
10584 MAKE_FIXED_MODE_NODE (accum, da, DA)
10585 MAKE_FIXED_MODE_NODE (accum, ta, TA)
10586
10587 {
10588 tree t = targetm.build_builtin_va_list ();
10589
10590 /* Many back-ends define record types without setting TYPE_NAME.
10591 If we copied the record type here, we'd keep the original
10592 record type without a name. This breaks name mangling. So,
10593 don't copy record types and let c_common_nodes_and_builtins()
10594 declare the type to be __builtin_va_list. */
10595 if (TREE_CODE (t) != RECORD_TYPE)
10596 t = build_variant_type_copy (t);
10597
10598 va_list_type_node = t;
10599 }
10600 }
10601
10602 /* Modify DECL for given flags.
10603 TM_PURE attribute is set only on types, so the function will modify
10604 DECL's type when ECF_TM_PURE is used. */
10605
10606 void
10607 set_call_expr_flags (tree decl, int flags)
10608 {
10609 if (flags & ECF_NOTHROW)
10610 TREE_NOTHROW (decl) = 1;
10611 if (flags & ECF_CONST)
10612 TREE_READONLY (decl) = 1;
10613 if (flags & ECF_PURE)
10614 DECL_PURE_P (decl) = 1;
10615 if (flags & ECF_LOOPING_CONST_OR_PURE)
10616 DECL_LOOPING_CONST_OR_PURE_P (decl) = 1;
10617 if (flags & ECF_NOVOPS)
10618 DECL_IS_NOVOPS (decl) = 1;
10619 if (flags & ECF_NORETURN)
10620 TREE_THIS_VOLATILE (decl) = 1;
10621 if (flags & ECF_MALLOC)
10622 DECL_IS_MALLOC (decl) = 1;
10623 if (flags & ECF_RETURNS_TWICE)
10624 DECL_IS_RETURNS_TWICE (decl) = 1;
10625 if (flags & ECF_LEAF)
10626 DECL_ATTRIBUTES (decl) = tree_cons (get_identifier ("leaf"),
10627 NULL, DECL_ATTRIBUTES (decl));
10628 if (flags & ECF_RET1)
10629 DECL_ATTRIBUTES (decl)
10630 = tree_cons (get_identifier ("fn spec"),
10631 build_tree_list (NULL_TREE, build_string (1, "1")),
10632 DECL_ATTRIBUTES (decl));
10633 if ((flags & ECF_TM_PURE) && flag_tm)
10634 apply_tm_attr (decl, get_identifier ("transaction_pure"));
10635 /* Looping const or pure is implied by noreturn.
10636 There is currently no way to declare looping const or looping pure alone. */
10637 gcc_assert (!(flags & ECF_LOOPING_CONST_OR_PURE)
10638 || ((flags & ECF_NORETURN) && (flags & (ECF_CONST | ECF_PURE))));
10639 }
10640
10641
10642 /* A subroutine of build_common_builtin_nodes. Define a builtin function. */
10643
10644 static void
10645 local_define_builtin (const char *name, tree type, enum built_in_function code,
10646 const char *library_name, int ecf_flags)
10647 {
10648 tree decl;
10649
10650 decl = add_builtin_function (name, type, code, BUILT_IN_NORMAL,
10651 library_name, NULL_TREE);
10652 set_call_expr_flags (decl, ecf_flags);
10653
10654 set_builtin_decl (code, decl, true);
10655 }
10656
10657 /* Call this function after instantiating all builtins that the language
10658 front end cares about. This will build the rest of the builtins
10659 and internal functions that are relied upon by the tree optimizers and
10660 the middle-end. */
10661
10662 void
10663 build_common_builtin_nodes (void)
10664 {
10665 tree tmp, ftype;
10666 int ecf_flags;
10667
10668 if (!builtin_decl_explicit_p (BUILT_IN_UNREACHABLE)
10669 || !builtin_decl_explicit_p (BUILT_IN_ABORT))
10670 {
10671 ftype = build_function_type (void_type_node, void_list_node);
10672 if (!builtin_decl_explicit_p (BUILT_IN_UNREACHABLE))
10673 local_define_builtin ("__builtin_unreachable", ftype,
10674 BUILT_IN_UNREACHABLE,
10675 "__builtin_unreachable",
10676 ECF_NOTHROW | ECF_LEAF | ECF_NORETURN
10677 | ECF_CONST);
10678 if (!builtin_decl_explicit_p (BUILT_IN_ABORT))
10679 local_define_builtin ("__builtin_abort", ftype, BUILT_IN_ABORT,
10680 "abort",
10681 ECF_LEAF | ECF_NORETURN | ECF_CONST);
10682 }
10683
10684 if (!builtin_decl_explicit_p (BUILT_IN_MEMCPY)
10685 || !builtin_decl_explicit_p (BUILT_IN_MEMMOVE))
10686 {
10687 ftype = build_function_type_list (ptr_type_node,
10688 ptr_type_node, const_ptr_type_node,
10689 size_type_node, NULL_TREE);
10690
10691 if (!builtin_decl_explicit_p (BUILT_IN_MEMCPY))
10692 local_define_builtin ("__builtin_memcpy", ftype, BUILT_IN_MEMCPY,
10693 "memcpy", ECF_NOTHROW | ECF_LEAF | ECF_RET1);
10694 if (!builtin_decl_explicit_p (BUILT_IN_MEMMOVE))
10695 local_define_builtin ("__builtin_memmove", ftype, BUILT_IN_MEMMOVE,
10696 "memmove", ECF_NOTHROW | ECF_LEAF | ECF_RET1);
10697 }
10698
10699 if (!builtin_decl_explicit_p (BUILT_IN_MEMCMP))
10700 {
10701 ftype = build_function_type_list (integer_type_node, const_ptr_type_node,
10702 const_ptr_type_node, size_type_node,
10703 NULL_TREE);
10704 local_define_builtin ("__builtin_memcmp", ftype, BUILT_IN_MEMCMP,
10705 "memcmp", ECF_PURE | ECF_NOTHROW | ECF_LEAF);
10706 }
10707
10708 if (!builtin_decl_explicit_p (BUILT_IN_MEMSET))
10709 {
10710 ftype = build_function_type_list (ptr_type_node,
10711 ptr_type_node, integer_type_node,
10712 size_type_node, NULL_TREE);
10713 local_define_builtin ("__builtin_memset", ftype, BUILT_IN_MEMSET,
10714 "memset", ECF_NOTHROW | ECF_LEAF | ECF_RET1);
10715 }
10716
10717 /* If we're checking the stack, `alloca' can throw. */
10718 const int alloca_flags
10719 = ECF_MALLOC | ECF_LEAF | (flag_stack_check ? 0 : ECF_NOTHROW);
10720
10721 if (!builtin_decl_explicit_p (BUILT_IN_ALLOCA))
10722 {
10723 ftype = build_function_type_list (ptr_type_node,
10724 size_type_node, NULL_TREE);
10725 local_define_builtin ("__builtin_alloca", ftype, BUILT_IN_ALLOCA,
10726 "alloca", alloca_flags);
10727 }
10728
10729 ftype = build_function_type_list (ptr_type_node, size_type_node,
10730 size_type_node, NULL_TREE);
10731 local_define_builtin ("__builtin_alloca_with_align", ftype,
10732 BUILT_IN_ALLOCA_WITH_ALIGN,
10733 "__builtin_alloca_with_align",
10734 alloca_flags);
10735
10736 ftype = build_function_type_list (void_type_node,
10737 ptr_type_node, ptr_type_node,
10738 ptr_type_node, NULL_TREE);
10739 local_define_builtin ("__builtin_init_trampoline", ftype,
10740 BUILT_IN_INIT_TRAMPOLINE,
10741 "__builtin_init_trampoline", ECF_NOTHROW | ECF_LEAF);
10742 local_define_builtin ("__builtin_init_heap_trampoline", ftype,
10743 BUILT_IN_INIT_HEAP_TRAMPOLINE,
10744 "__builtin_init_heap_trampoline",
10745 ECF_NOTHROW | ECF_LEAF);
10746 local_define_builtin ("__builtin_init_descriptor", ftype,
10747 BUILT_IN_INIT_DESCRIPTOR,
10748 "__builtin_init_descriptor", ECF_NOTHROW | ECF_LEAF);
10749
10750 ftype = build_function_type_list (ptr_type_node, ptr_type_node, NULL_TREE);
10751 local_define_builtin ("__builtin_adjust_trampoline", ftype,
10752 BUILT_IN_ADJUST_TRAMPOLINE,
10753 "__builtin_adjust_trampoline",
10754 ECF_CONST | ECF_NOTHROW);
10755 local_define_builtin ("__builtin_adjust_descriptor", ftype,
10756 BUILT_IN_ADJUST_DESCRIPTOR,
10757 "__builtin_adjust_descriptor",
10758 ECF_CONST | ECF_NOTHROW);
10759
10760 ftype = build_function_type_list (void_type_node,
10761 ptr_type_node, ptr_type_node, NULL_TREE);
10762 local_define_builtin ("__builtin_nonlocal_goto", ftype,
10763 BUILT_IN_NONLOCAL_GOTO,
10764 "__builtin_nonlocal_goto",
10765 ECF_NORETURN | ECF_NOTHROW);
10766
10767 ftype = build_function_type_list (void_type_node,
10768 ptr_type_node, ptr_type_node, NULL_TREE);
10769 local_define_builtin ("__builtin_setjmp_setup", ftype,
10770 BUILT_IN_SETJMP_SETUP,
10771 "__builtin_setjmp_setup", ECF_NOTHROW);
10772
10773 ftype = build_function_type_list (void_type_node, ptr_type_node, NULL_TREE);
10774 local_define_builtin ("__builtin_setjmp_receiver", ftype,
10775 BUILT_IN_SETJMP_RECEIVER,
10776 "__builtin_setjmp_receiver", ECF_NOTHROW | ECF_LEAF);
10777
10778 ftype = build_function_type_list (ptr_type_node, NULL_TREE);
10779 local_define_builtin ("__builtin_stack_save", ftype, BUILT_IN_STACK_SAVE,
10780 "__builtin_stack_save", ECF_NOTHROW | ECF_LEAF);
10781
10782 ftype = build_function_type_list (void_type_node, ptr_type_node, NULL_TREE);
10783 local_define_builtin ("__builtin_stack_restore", ftype,
10784 BUILT_IN_STACK_RESTORE,
10785 "__builtin_stack_restore", ECF_NOTHROW | ECF_LEAF);
10786
10787 ftype = build_function_type_list (integer_type_node, const_ptr_type_node,
10788 const_ptr_type_node, size_type_node,
10789 NULL_TREE);
10790 local_define_builtin ("__builtin_memcmp_eq", ftype, BUILT_IN_MEMCMP_EQ,
10791 "__builtin_memcmp_eq",
10792 ECF_PURE | ECF_NOTHROW | ECF_LEAF);
10793
10794 /* If there's a possibility that we might use the ARM EABI, build the
10795 alternate __cxa_end_cleanup node used to resume from C++ and Java. */
10796 if (targetm.arm_eabi_unwinder)
10797 {
10798 ftype = build_function_type_list (void_type_node, NULL_TREE);
10799 local_define_builtin ("__builtin_cxa_end_cleanup", ftype,
10800 BUILT_IN_CXA_END_CLEANUP,
10801 "__cxa_end_cleanup", ECF_NORETURN | ECF_LEAF);
10802 }
10803
10804 ftype = build_function_type_list (void_type_node, ptr_type_node, NULL_TREE);
10805 local_define_builtin ("__builtin_unwind_resume", ftype,
10806 BUILT_IN_UNWIND_RESUME,
10807 ((targetm_common.except_unwind_info (&global_options)
10808 == UI_SJLJ)
10809 ? "_Unwind_SjLj_Resume" : "_Unwind_Resume"),
10810 ECF_NORETURN);
10811
10812 if (builtin_decl_explicit (BUILT_IN_RETURN_ADDRESS) == NULL_TREE)
10813 {
10814 ftype = build_function_type_list (ptr_type_node, integer_type_node,
10815 NULL_TREE);
10816 local_define_builtin ("__builtin_return_address", ftype,
10817 BUILT_IN_RETURN_ADDRESS,
10818 "__builtin_return_address",
10819 ECF_NOTHROW);
10820 }
10821
10822 if (!builtin_decl_explicit_p (BUILT_IN_PROFILE_FUNC_ENTER)
10823 || !builtin_decl_explicit_p (BUILT_IN_PROFILE_FUNC_EXIT))
10824 {
10825 ftype = build_function_type_list (void_type_node, ptr_type_node,
10826 ptr_type_node, NULL_TREE);
10827 if (!builtin_decl_explicit_p (BUILT_IN_PROFILE_FUNC_ENTER))
10828 local_define_builtin ("__cyg_profile_func_enter", ftype,
10829 BUILT_IN_PROFILE_FUNC_ENTER,
10830 "__cyg_profile_func_enter", 0);
10831 if (!builtin_decl_explicit_p (BUILT_IN_PROFILE_FUNC_EXIT))
10832 local_define_builtin ("__cyg_profile_func_exit", ftype,
10833 BUILT_IN_PROFILE_FUNC_EXIT,
10834 "__cyg_profile_func_exit", 0);
10835 }
10836
10837 /* The exception object and filter values from the runtime. The argument
10838 must be zero before exception lowering, i.e. from the front end. After
10839 exception lowering, it will be the region number for the exception
10840 landing pad. These functions are PURE instead of CONST to prevent
10841 them from being hoisted past the exception edge that will initialize
10842 its value in the landing pad. */
10843 ftype = build_function_type_list (ptr_type_node,
10844 integer_type_node, NULL_TREE);
10845 ecf_flags = ECF_PURE | ECF_NOTHROW | ECF_LEAF;
10846 /* Only use TM_PURE if we have TM language support. */
10847 if (builtin_decl_explicit_p (BUILT_IN_TM_LOAD_1))
10848 ecf_flags |= ECF_TM_PURE;
10849 local_define_builtin ("__builtin_eh_pointer", ftype, BUILT_IN_EH_POINTER,
10850 "__builtin_eh_pointer", ecf_flags);
10851
10852 tmp = lang_hooks.types.type_for_mode (targetm.eh_return_filter_mode (), 0);
10853 ftype = build_function_type_list (tmp, integer_type_node, NULL_TREE);
10854 local_define_builtin ("__builtin_eh_filter", ftype, BUILT_IN_EH_FILTER,
10855 "__builtin_eh_filter", ECF_PURE | ECF_NOTHROW | ECF_LEAF);
10856
10857 ftype = build_function_type_list (void_type_node,
10858 integer_type_node, integer_type_node,
10859 NULL_TREE);
10860 local_define_builtin ("__builtin_eh_copy_values", ftype,
10861 BUILT_IN_EH_COPY_VALUES,
10862 "__builtin_eh_copy_values", ECF_NOTHROW);
10863
10864 /* Complex multiplication and division. These are handled as builtins
10865 rather than optabs because emit_library_call_value doesn't support
10866 complex. Further, we can do slightly better with folding these
10867 beasties if the real and complex parts of the arguments are separate. */
10868 {
10869 int mode;
10870
10871 for (mode = MIN_MODE_COMPLEX_FLOAT; mode <= MAX_MODE_COMPLEX_FLOAT; ++mode)
10872 {
10873 char mode_name_buf[4], *q;
10874 const char *p;
10875 enum built_in_function mcode, dcode;
10876 tree type, inner_type;
10877 const char *prefix = "__";
10878
10879 if (targetm.libfunc_gnu_prefix)
10880 prefix = "__gnu_";
10881
10882 type = lang_hooks.types.type_for_mode ((machine_mode) mode, 0);
10883 if (type == NULL)
10884 continue;
10885 inner_type = TREE_TYPE (type);
10886
10887 ftype = build_function_type_list (type, inner_type, inner_type,
10888 inner_type, inner_type, NULL_TREE);
10889
10890 mcode = ((enum built_in_function)
10891 (BUILT_IN_COMPLEX_MUL_MIN + mode - MIN_MODE_COMPLEX_FLOAT));
10892 dcode = ((enum built_in_function)
10893 (BUILT_IN_COMPLEX_DIV_MIN + mode - MIN_MODE_COMPLEX_FLOAT));
10894
10895 for (p = GET_MODE_NAME (mode), q = mode_name_buf; *p; p++, q++)
10896 *q = TOLOWER (*p);
10897 *q = '\0';
10898
10899 built_in_names[mcode] = concat (prefix, "mul", mode_name_buf, "3",
10900 NULL);
10901 local_define_builtin (built_in_names[mcode], ftype, mcode,
10902 built_in_names[mcode],
10903 ECF_CONST | ECF_NOTHROW | ECF_LEAF);
10904
10905 built_in_names[dcode] = concat (prefix, "div", mode_name_buf, "3",
10906 NULL);
10907 local_define_builtin (built_in_names[dcode], ftype, dcode,
10908 built_in_names[dcode],
10909 ECF_CONST | ECF_NOTHROW | ECF_LEAF);
10910 }
10911 }
10912
10913 init_internal_fns ();
10914 }
10915
10916 /* HACK. GROSS. This is absolutely disgusting. I wish there was a
10917 better way.
10918
10919 If we requested a pointer to a vector, build up the pointers that
10920 we stripped off while looking for the inner type. Similarly for
10921 return values from functions.
10922
10923 The argument TYPE is the top of the chain, and BOTTOM is the
10924 new type which we will point to. */
10925
10926 tree
10927 reconstruct_complex_type (tree type, tree bottom)
10928 {
10929 tree inner, outer;
10930
10931 if (TREE_CODE (type) == POINTER_TYPE)
10932 {
10933 inner = reconstruct_complex_type (TREE_TYPE (type), bottom);
10934 outer = build_pointer_type_for_mode (inner, TYPE_MODE (type),
10935 TYPE_REF_CAN_ALIAS_ALL (type));
10936 }
10937 else if (TREE_CODE (type) == REFERENCE_TYPE)
10938 {
10939 inner = reconstruct_complex_type (TREE_TYPE (type), bottom);
10940 outer = build_reference_type_for_mode (inner, TYPE_MODE (type),
10941 TYPE_REF_CAN_ALIAS_ALL (type));
10942 }
10943 else if (TREE_CODE (type) == ARRAY_TYPE)
10944 {
10945 inner = reconstruct_complex_type (TREE_TYPE (type), bottom);
10946 outer = build_array_type (inner, TYPE_DOMAIN (type));
10947 }
10948 else if (TREE_CODE (type) == FUNCTION_TYPE)
10949 {
10950 inner = reconstruct_complex_type (TREE_TYPE (type), bottom);
10951 outer = build_function_type (inner, TYPE_ARG_TYPES (type));
10952 }
10953 else if (TREE_CODE (type) == METHOD_TYPE)
10954 {
10955 inner = reconstruct_complex_type (TREE_TYPE (type), bottom);
10956 /* The build_method_type_directly() routine prepends 'this' to argument list,
10957 so we must compensate by getting rid of it. */
10958 outer
10959 = build_method_type_directly
10960 (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (type))),
10961 inner,
10962 TREE_CHAIN (TYPE_ARG_TYPES (type)));
10963 }
10964 else if (TREE_CODE (type) == OFFSET_TYPE)
10965 {
10966 inner = reconstruct_complex_type (TREE_TYPE (type), bottom);
10967 outer = build_offset_type (TYPE_OFFSET_BASETYPE (type), inner);
10968 }
10969 else
10970 return bottom;
10971
10972 return build_type_attribute_qual_variant (outer, TYPE_ATTRIBUTES (type),
10973 TYPE_QUALS (type));
10974 }
10975
10976 /* Returns a vector tree node given a mode (integer, vector, or BLKmode) and
10977 the inner type. */
10978 tree
10979 build_vector_type_for_mode (tree innertype, machine_mode mode)
10980 {
10981 int nunits;
10982
10983 switch (GET_MODE_CLASS (mode))
10984 {
10985 case MODE_VECTOR_INT:
10986 case MODE_VECTOR_FLOAT:
10987 case MODE_VECTOR_FRACT:
10988 case MODE_VECTOR_UFRACT:
10989 case MODE_VECTOR_ACCUM:
10990 case MODE_VECTOR_UACCUM:
10991 nunits = GET_MODE_NUNITS (mode);
10992 break;
10993
10994 case MODE_INT:
10995 /* Check that there are no leftover bits. */
10996 gcc_assert (GET_MODE_BITSIZE (mode)
10997 % TREE_INT_CST_LOW (TYPE_SIZE (innertype)) == 0);
10998
10999 nunits = GET_MODE_BITSIZE (mode)
11000 / TREE_INT_CST_LOW (TYPE_SIZE (innertype));
11001 break;
11002
11003 default:
11004 gcc_unreachable ();
11005 }
11006
11007 return make_vector_type (innertype, nunits, mode);
11008 }
11009
11010 /* Similarly, but takes the inner type and number of units, which must be
11011 a power of two. */
11012
11013 tree
11014 build_vector_type (tree innertype, int nunits)
11015 {
11016 return make_vector_type (innertype, nunits, VOIDmode);
11017 }
11018
11019 /* Build truth vector with specified length and number of units. */
11020
11021 tree
11022 build_truth_vector_type (unsigned nunits, unsigned vector_size)
11023 {
11024 machine_mode mask_mode = targetm.vectorize.get_mask_mode (nunits,
11025 vector_size);
11026
11027 gcc_assert (mask_mode != VOIDmode);
11028
11029 unsigned HOST_WIDE_INT vsize;
11030 if (mask_mode == BLKmode)
11031 vsize = vector_size * BITS_PER_UNIT;
11032 else
11033 vsize = GET_MODE_BITSIZE (mask_mode);
11034
11035 unsigned HOST_WIDE_INT esize = vsize / nunits;
11036 gcc_assert (esize * nunits == vsize);
11037
11038 tree bool_type = build_nonstandard_boolean_type (esize);
11039
11040 return make_vector_type (bool_type, nunits, mask_mode);
11041 }
11042
11043 /* Returns a vector type corresponding to a comparison of VECTYPE. */
11044
11045 tree
11046 build_same_sized_truth_vector_type (tree vectype)
11047 {
11048 if (VECTOR_BOOLEAN_TYPE_P (vectype))
11049 return vectype;
11050
11051 unsigned HOST_WIDE_INT size = GET_MODE_SIZE (TYPE_MODE (vectype));
11052
11053 if (!size)
11054 size = tree_to_uhwi (TYPE_SIZE_UNIT (vectype));
11055
11056 return build_truth_vector_type (TYPE_VECTOR_SUBPARTS (vectype), size);
11057 }
11058
11059 /* Similarly, but builds a variant type with TYPE_VECTOR_OPAQUE set. */
11060
11061 tree
11062 build_opaque_vector_type (tree innertype, int nunits)
11063 {
11064 tree t = make_vector_type (innertype, nunits, VOIDmode);
11065 tree cand;
11066 /* We always build the non-opaque variant before the opaque one,
11067 so if it already exists, it is TYPE_NEXT_VARIANT of this one. */
11068 cand = TYPE_NEXT_VARIANT (t);
11069 if (cand
11070 && TYPE_VECTOR_OPAQUE (cand)
11071 && check_qualified_type (cand, t, TYPE_QUALS (t)))
11072 return cand;
11073 /* Othewise build a variant type and make sure to queue it after
11074 the non-opaque type. */
11075 cand = build_distinct_type_copy (t);
11076 TYPE_VECTOR_OPAQUE (cand) = true;
11077 TYPE_CANONICAL (cand) = TYPE_CANONICAL (t);
11078 TYPE_NEXT_VARIANT (cand) = TYPE_NEXT_VARIANT (t);
11079 TYPE_NEXT_VARIANT (t) = cand;
11080 TYPE_MAIN_VARIANT (cand) = TYPE_MAIN_VARIANT (t);
11081 return cand;
11082 }
11083
11084
11085 /* Given an initializer INIT, return TRUE if INIT is zero or some
11086 aggregate of zeros. Otherwise return FALSE. */
11087 bool
11088 initializer_zerop (const_tree init)
11089 {
11090 tree elt;
11091
11092 STRIP_NOPS (init);
11093
11094 switch (TREE_CODE (init))
11095 {
11096 case INTEGER_CST:
11097 return integer_zerop (init);
11098
11099 case REAL_CST:
11100 /* ??? Note that this is not correct for C4X float formats. There,
11101 a bit pattern of all zeros is 1.0; 0.0 is encoded with the most
11102 negative exponent. */
11103 return real_zerop (init)
11104 && ! REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (init));
11105
11106 case FIXED_CST:
11107 return fixed_zerop (init);
11108
11109 case COMPLEX_CST:
11110 return integer_zerop (init)
11111 || (real_zerop (init)
11112 && ! REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (TREE_REALPART (init)))
11113 && ! REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (TREE_IMAGPART (init))));
11114
11115 case VECTOR_CST:
11116 {
11117 unsigned i;
11118 for (i = 0; i < VECTOR_CST_NELTS (init); ++i)
11119 if (!initializer_zerop (VECTOR_CST_ELT (init, i)))
11120 return false;
11121 return true;
11122 }
11123
11124 case CONSTRUCTOR:
11125 {
11126 unsigned HOST_WIDE_INT idx;
11127
11128 if (TREE_CLOBBER_P (init))
11129 return false;
11130 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (init), idx, elt)
11131 if (!initializer_zerop (elt))
11132 return false;
11133 return true;
11134 }
11135
11136 case STRING_CST:
11137 {
11138 int i;
11139
11140 /* We need to loop through all elements to handle cases like
11141 "\0" and "\0foobar". */
11142 for (i = 0; i < TREE_STRING_LENGTH (init); ++i)
11143 if (TREE_STRING_POINTER (init)[i] != '\0')
11144 return false;
11145
11146 return true;
11147 }
11148
11149 default:
11150 return false;
11151 }
11152 }
11153
11154 /* Check if vector VEC consists of all the equal elements and
11155 that the number of elements corresponds to the type of VEC.
11156 The function returns first element of the vector
11157 or NULL_TREE if the vector is not uniform. */
11158 tree
11159 uniform_vector_p (const_tree vec)
11160 {
11161 tree first, t;
11162 unsigned i;
11163
11164 if (vec == NULL_TREE)
11165 return NULL_TREE;
11166
11167 gcc_assert (VECTOR_TYPE_P (TREE_TYPE (vec)));
11168
11169 if (TREE_CODE (vec) == VECTOR_CST)
11170 {
11171 first = VECTOR_CST_ELT (vec, 0);
11172 for (i = 1; i < VECTOR_CST_NELTS (vec); ++i)
11173 if (!operand_equal_p (first, VECTOR_CST_ELT (vec, i), 0))
11174 return NULL_TREE;
11175
11176 return first;
11177 }
11178
11179 else if (TREE_CODE (vec) == CONSTRUCTOR)
11180 {
11181 first = error_mark_node;
11182
11183 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (vec), i, t)
11184 {
11185 if (i == 0)
11186 {
11187 first = t;
11188 continue;
11189 }
11190 if (!operand_equal_p (first, t, 0))
11191 return NULL_TREE;
11192 }
11193 if (i != TYPE_VECTOR_SUBPARTS (TREE_TYPE (vec)))
11194 return NULL_TREE;
11195
11196 return first;
11197 }
11198
11199 return NULL_TREE;
11200 }
11201
11202 /* Build an empty statement at location LOC. */
11203
11204 tree
11205 build_empty_stmt (location_t loc)
11206 {
11207 tree t = build1 (NOP_EXPR, void_type_node, size_zero_node);
11208 SET_EXPR_LOCATION (t, loc);
11209 return t;
11210 }
11211
11212
11213 /* Build an OpenMP clause with code CODE. LOC is the location of the
11214 clause. */
11215
11216 tree
11217 build_omp_clause (location_t loc, enum omp_clause_code code)
11218 {
11219 tree t;
11220 int size, length;
11221
11222 length = omp_clause_num_ops[code];
11223 size = (sizeof (struct tree_omp_clause) + (length - 1) * sizeof (tree));
11224
11225 record_node_allocation_statistics (OMP_CLAUSE, size);
11226
11227 t = (tree) ggc_internal_alloc (size);
11228 memset (t, 0, size);
11229 TREE_SET_CODE (t, OMP_CLAUSE);
11230 OMP_CLAUSE_SET_CODE (t, code);
11231 OMP_CLAUSE_LOCATION (t) = loc;
11232
11233 return t;
11234 }
11235
11236 /* Build a tcc_vl_exp object with code CODE and room for LEN operands. LEN
11237 includes the implicit operand count in TREE_OPERAND 0, and so must be >= 1.
11238 Except for the CODE and operand count field, other storage for the
11239 object is initialized to zeros. */
11240
11241 tree
11242 build_vl_exp_stat (enum tree_code code, int len MEM_STAT_DECL)
11243 {
11244 tree t;
11245 int length = (len - 1) * sizeof (tree) + sizeof (struct tree_exp);
11246
11247 gcc_assert (TREE_CODE_CLASS (code) == tcc_vl_exp);
11248 gcc_assert (len >= 1);
11249
11250 record_node_allocation_statistics (code, length);
11251
11252 t = ggc_alloc_cleared_tree_node_stat (length PASS_MEM_STAT);
11253
11254 TREE_SET_CODE (t, code);
11255
11256 /* Can't use TREE_OPERAND to store the length because if checking is
11257 enabled, it will try to check the length before we store it. :-P */
11258 t->exp.operands[0] = build_int_cst (sizetype, len);
11259
11260 return t;
11261 }
11262
11263 /* Helper function for build_call_* functions; build a CALL_EXPR with
11264 indicated RETURN_TYPE, FN, and NARGS, but do not initialize any of
11265 the argument slots. */
11266
11267 static tree
11268 build_call_1 (tree return_type, tree fn, int nargs)
11269 {
11270 tree t;
11271
11272 t = build_vl_exp (CALL_EXPR, nargs + 3);
11273 TREE_TYPE (t) = return_type;
11274 CALL_EXPR_FN (t) = fn;
11275 CALL_EXPR_STATIC_CHAIN (t) = NULL;
11276
11277 return t;
11278 }
11279
11280 /* Build a CALL_EXPR of class tcc_vl_exp with the indicated RETURN_TYPE and
11281 FN and a null static chain slot. NARGS is the number of call arguments
11282 which are specified as "..." arguments. */
11283
11284 tree
11285 build_call_nary (tree return_type, tree fn, int nargs, ...)
11286 {
11287 tree ret;
11288 va_list args;
11289 va_start (args, nargs);
11290 ret = build_call_valist (return_type, fn, nargs, args);
11291 va_end (args);
11292 return ret;
11293 }
11294
11295 /* Build a CALL_EXPR of class tcc_vl_exp with the indicated RETURN_TYPE and
11296 FN and a null static chain slot. NARGS is the number of call arguments
11297 which are specified as a va_list ARGS. */
11298
11299 tree
11300 build_call_valist (tree return_type, tree fn, int nargs, va_list args)
11301 {
11302 tree t;
11303 int i;
11304
11305 t = build_call_1 (return_type, fn, nargs);
11306 for (i = 0; i < nargs; i++)
11307 CALL_EXPR_ARG (t, i) = va_arg (args, tree);
11308 process_call_operands (t);
11309 return t;
11310 }
11311
11312 /* Build a CALL_EXPR of class tcc_vl_exp with the indicated RETURN_TYPE and
11313 FN and a null static chain slot. NARGS is the number of call arguments
11314 which are specified as a tree array ARGS. */
11315
11316 tree
11317 build_call_array_loc (location_t loc, tree return_type, tree fn,
11318 int nargs, const tree *args)
11319 {
11320 tree t;
11321 int i;
11322
11323 t = build_call_1 (return_type, fn, nargs);
11324 for (i = 0; i < nargs; i++)
11325 CALL_EXPR_ARG (t, i) = args[i];
11326 process_call_operands (t);
11327 SET_EXPR_LOCATION (t, loc);
11328 return t;
11329 }
11330
11331 /* Like build_call_array, but takes a vec. */
11332
11333 tree
11334 build_call_vec (tree return_type, tree fn, vec<tree, va_gc> *args)
11335 {
11336 tree ret, t;
11337 unsigned int ix;
11338
11339 ret = build_call_1 (return_type, fn, vec_safe_length (args));
11340 FOR_EACH_VEC_SAFE_ELT (args, ix, t)
11341 CALL_EXPR_ARG (ret, ix) = t;
11342 process_call_operands (ret);
11343 return ret;
11344 }
11345
11346 /* Conveniently construct a function call expression. FNDECL names the
11347 function to be called and N arguments are passed in the array
11348 ARGARRAY. */
11349
11350 tree
11351 build_call_expr_loc_array (location_t loc, tree fndecl, int n, tree *argarray)
11352 {
11353 tree fntype = TREE_TYPE (fndecl);
11354 tree fn = build1 (ADDR_EXPR, build_pointer_type (fntype), fndecl);
11355
11356 return fold_build_call_array_loc (loc, TREE_TYPE (fntype), fn, n, argarray);
11357 }
11358
11359 /* Conveniently construct a function call expression. FNDECL names the
11360 function to be called and the arguments are passed in the vector
11361 VEC. */
11362
11363 tree
11364 build_call_expr_loc_vec (location_t loc, tree fndecl, vec<tree, va_gc> *vec)
11365 {
11366 return build_call_expr_loc_array (loc, fndecl, vec_safe_length (vec),
11367 vec_safe_address (vec));
11368 }
11369
11370
11371 /* Conveniently construct a function call expression. FNDECL names the
11372 function to be called, N is the number of arguments, and the "..."
11373 parameters are the argument expressions. */
11374
11375 tree
11376 build_call_expr_loc (location_t loc, tree fndecl, int n, ...)
11377 {
11378 va_list ap;
11379 tree *argarray = XALLOCAVEC (tree, n);
11380 int i;
11381
11382 va_start (ap, n);
11383 for (i = 0; i < n; i++)
11384 argarray[i] = va_arg (ap, tree);
11385 va_end (ap);
11386 return build_call_expr_loc_array (loc, fndecl, n, argarray);
11387 }
11388
11389 /* Like build_call_expr_loc (UNKNOWN_LOCATION, ...). Duplicated because
11390 varargs macros aren't supported by all bootstrap compilers. */
11391
11392 tree
11393 build_call_expr (tree fndecl, int n, ...)
11394 {
11395 va_list ap;
11396 tree *argarray = XALLOCAVEC (tree, n);
11397 int i;
11398
11399 va_start (ap, n);
11400 for (i = 0; i < n; i++)
11401 argarray[i] = va_arg (ap, tree);
11402 va_end (ap);
11403 return build_call_expr_loc_array (UNKNOWN_LOCATION, fndecl, n, argarray);
11404 }
11405
11406 /* Build an internal call to IFN, with arguments ARGS[0:N-1] and with return
11407 type TYPE. This is just like CALL_EXPR, except its CALL_EXPR_FN is NULL.
11408 It will get gimplified later into an ordinary internal function. */
11409
11410 tree
11411 build_call_expr_internal_loc_array (location_t loc, internal_fn ifn,
11412 tree type, int n, const tree *args)
11413 {
11414 tree t = build_call_1 (type, NULL_TREE, n);
11415 for (int i = 0; i < n; ++i)
11416 CALL_EXPR_ARG (t, i) = args[i];
11417 SET_EXPR_LOCATION (t, loc);
11418 CALL_EXPR_IFN (t) = ifn;
11419 return t;
11420 }
11421
11422 /* Build internal call expression. This is just like CALL_EXPR, except
11423 its CALL_EXPR_FN is NULL. It will get gimplified later into ordinary
11424 internal function. */
11425
11426 tree
11427 build_call_expr_internal_loc (location_t loc, enum internal_fn ifn,
11428 tree type, int n, ...)
11429 {
11430 va_list ap;
11431 tree *argarray = XALLOCAVEC (tree, n);
11432 int i;
11433
11434 va_start (ap, n);
11435 for (i = 0; i < n; i++)
11436 argarray[i] = va_arg (ap, tree);
11437 va_end (ap);
11438 return build_call_expr_internal_loc_array (loc, ifn, type, n, argarray);
11439 }
11440
11441 /* Return a function call to FN, if the target is guaranteed to support it,
11442 or null otherwise.
11443
11444 N is the number of arguments, passed in the "...", and TYPE is the
11445 type of the return value. */
11446
11447 tree
11448 maybe_build_call_expr_loc (location_t loc, combined_fn fn, tree type,
11449 int n, ...)
11450 {
11451 va_list ap;
11452 tree *argarray = XALLOCAVEC (tree, n);
11453 int i;
11454
11455 va_start (ap, n);
11456 for (i = 0; i < n; i++)
11457 argarray[i] = va_arg (ap, tree);
11458 va_end (ap);
11459 if (internal_fn_p (fn))
11460 {
11461 internal_fn ifn = as_internal_fn (fn);
11462 if (direct_internal_fn_p (ifn))
11463 {
11464 tree_pair types = direct_internal_fn_types (ifn, type, argarray);
11465 if (!direct_internal_fn_supported_p (ifn, types,
11466 OPTIMIZE_FOR_BOTH))
11467 return NULL_TREE;
11468 }
11469 return build_call_expr_internal_loc_array (loc, ifn, type, n, argarray);
11470 }
11471 else
11472 {
11473 tree fndecl = builtin_decl_implicit (as_builtin_fn (fn));
11474 if (!fndecl)
11475 return NULL_TREE;
11476 return build_call_expr_loc_array (loc, fndecl, n, argarray);
11477 }
11478 }
11479
11480 /* Create a new constant string literal and return a char* pointer to it.
11481 The STRING_CST value is the LEN characters at STR. */
11482 tree
11483 build_string_literal (int len, const char *str)
11484 {
11485 tree t, elem, index, type;
11486
11487 t = build_string (len, str);
11488 elem = build_type_variant (char_type_node, 1, 0);
11489 index = build_index_type (size_int (len - 1));
11490 type = build_array_type (elem, index);
11491 TREE_TYPE (t) = type;
11492 TREE_CONSTANT (t) = 1;
11493 TREE_READONLY (t) = 1;
11494 TREE_STATIC (t) = 1;
11495
11496 type = build_pointer_type (elem);
11497 t = build1 (ADDR_EXPR, type,
11498 build4 (ARRAY_REF, elem,
11499 t, integer_zero_node, NULL_TREE, NULL_TREE));
11500 return t;
11501 }
11502
11503
11504
11505 /* Return true if T (assumed to be a DECL) must be assigned a memory
11506 location. */
11507
11508 bool
11509 needs_to_live_in_memory (const_tree t)
11510 {
11511 return (TREE_ADDRESSABLE (t)
11512 || is_global_var (t)
11513 || (TREE_CODE (t) == RESULT_DECL
11514 && !DECL_BY_REFERENCE (t)
11515 && aggregate_value_p (t, current_function_decl)));
11516 }
11517
11518 /* Return value of a constant X and sign-extend it. */
11519
11520 HOST_WIDE_INT
11521 int_cst_value (const_tree x)
11522 {
11523 unsigned bits = TYPE_PRECISION (TREE_TYPE (x));
11524 unsigned HOST_WIDE_INT val = TREE_INT_CST_LOW (x);
11525
11526 /* Make sure the sign-extended value will fit in a HOST_WIDE_INT. */
11527 gcc_assert (cst_and_fits_in_hwi (x));
11528
11529 if (bits < HOST_BITS_PER_WIDE_INT)
11530 {
11531 bool negative = ((val >> (bits - 1)) & 1) != 0;
11532 if (negative)
11533 val |= HOST_WIDE_INT_M1U << (bits - 1) << 1;
11534 else
11535 val &= ~(HOST_WIDE_INT_M1U << (bits - 1) << 1);
11536 }
11537
11538 return val;
11539 }
11540
11541 /* If TYPE is an integral or pointer type, return an integer type with
11542 the same precision which is unsigned iff UNSIGNEDP is true, or itself
11543 if TYPE is already an integer type of signedness UNSIGNEDP. */
11544
11545 tree
11546 signed_or_unsigned_type_for (int unsignedp, tree type)
11547 {
11548 if (TREE_CODE (type) == INTEGER_TYPE && TYPE_UNSIGNED (type) == unsignedp)
11549 return type;
11550
11551 if (TREE_CODE (type) == VECTOR_TYPE)
11552 {
11553 tree inner = TREE_TYPE (type);
11554 tree inner2 = signed_or_unsigned_type_for (unsignedp, inner);
11555 if (!inner2)
11556 return NULL_TREE;
11557 if (inner == inner2)
11558 return type;
11559 return build_vector_type (inner2, TYPE_VECTOR_SUBPARTS (type));
11560 }
11561
11562 if (!INTEGRAL_TYPE_P (type)
11563 && !POINTER_TYPE_P (type)
11564 && TREE_CODE (type) != OFFSET_TYPE)
11565 return NULL_TREE;
11566
11567 return build_nonstandard_integer_type (TYPE_PRECISION (type), unsignedp);
11568 }
11569
11570 /* If TYPE is an integral or pointer type, return an integer type with
11571 the same precision which is unsigned, or itself if TYPE is already an
11572 unsigned integer type. */
11573
11574 tree
11575 unsigned_type_for (tree type)
11576 {
11577 return signed_or_unsigned_type_for (1, type);
11578 }
11579
11580 /* If TYPE is an integral or pointer type, return an integer type with
11581 the same precision which is signed, or itself if TYPE is already a
11582 signed integer type. */
11583
11584 tree
11585 signed_type_for (tree type)
11586 {
11587 return signed_or_unsigned_type_for (0, type);
11588 }
11589
11590 /* If TYPE is a vector type, return a signed integer vector type with the
11591 same width and number of subparts. Otherwise return boolean_type_node. */
11592
11593 tree
11594 truth_type_for (tree type)
11595 {
11596 if (TREE_CODE (type) == VECTOR_TYPE)
11597 {
11598 if (VECTOR_BOOLEAN_TYPE_P (type))
11599 return type;
11600 return build_truth_vector_type (TYPE_VECTOR_SUBPARTS (type),
11601 GET_MODE_SIZE (TYPE_MODE (type)));
11602 }
11603 else
11604 return boolean_type_node;
11605 }
11606
11607 /* Returns the largest value obtainable by casting something in INNER type to
11608 OUTER type. */
11609
11610 tree
11611 upper_bound_in_type (tree outer, tree inner)
11612 {
11613 unsigned int det = 0;
11614 unsigned oprec = TYPE_PRECISION (outer);
11615 unsigned iprec = TYPE_PRECISION (inner);
11616 unsigned prec;
11617
11618 /* Compute a unique number for every combination. */
11619 det |= (oprec > iprec) ? 4 : 0;
11620 det |= TYPE_UNSIGNED (outer) ? 2 : 0;
11621 det |= TYPE_UNSIGNED (inner) ? 1 : 0;
11622
11623 /* Determine the exponent to use. */
11624 switch (det)
11625 {
11626 case 0:
11627 case 1:
11628 /* oprec <= iprec, outer: signed, inner: don't care. */
11629 prec = oprec - 1;
11630 break;
11631 case 2:
11632 case 3:
11633 /* oprec <= iprec, outer: unsigned, inner: don't care. */
11634 prec = oprec;
11635 break;
11636 case 4:
11637 /* oprec > iprec, outer: signed, inner: signed. */
11638 prec = iprec - 1;
11639 break;
11640 case 5:
11641 /* oprec > iprec, outer: signed, inner: unsigned. */
11642 prec = iprec;
11643 break;
11644 case 6:
11645 /* oprec > iprec, outer: unsigned, inner: signed. */
11646 prec = oprec;
11647 break;
11648 case 7:
11649 /* oprec > iprec, outer: unsigned, inner: unsigned. */
11650 prec = iprec;
11651 break;
11652 default:
11653 gcc_unreachable ();
11654 }
11655
11656 return wide_int_to_tree (outer,
11657 wi::mask (prec, false, TYPE_PRECISION (outer)));
11658 }
11659
11660 /* Returns the smallest value obtainable by casting something in INNER type to
11661 OUTER type. */
11662
11663 tree
11664 lower_bound_in_type (tree outer, tree inner)
11665 {
11666 unsigned oprec = TYPE_PRECISION (outer);
11667 unsigned iprec = TYPE_PRECISION (inner);
11668
11669 /* If OUTER type is unsigned, we can definitely cast 0 to OUTER type
11670 and obtain 0. */
11671 if (TYPE_UNSIGNED (outer)
11672 /* If we are widening something of an unsigned type, OUTER type
11673 contains all values of INNER type. In particular, both INNER
11674 and OUTER types have zero in common. */
11675 || (oprec > iprec && TYPE_UNSIGNED (inner)))
11676 return build_int_cst (outer, 0);
11677 else
11678 {
11679 /* If we are widening a signed type to another signed type, we
11680 want to obtain -2^^(iprec-1). If we are keeping the
11681 precision or narrowing to a signed type, we want to obtain
11682 -2^(oprec-1). */
11683 unsigned prec = oprec > iprec ? iprec : oprec;
11684 return wide_int_to_tree (outer,
11685 wi::mask (prec - 1, true,
11686 TYPE_PRECISION (outer)));
11687 }
11688 }
11689
11690 /* Return nonzero if two operands that are suitable for PHI nodes are
11691 necessarily equal. Specifically, both ARG0 and ARG1 must be either
11692 SSA_NAME or invariant. Note that this is strictly an optimization.
11693 That is, callers of this function can directly call operand_equal_p
11694 and get the same result, only slower. */
11695
11696 int
11697 operand_equal_for_phi_arg_p (const_tree arg0, const_tree arg1)
11698 {
11699 if (arg0 == arg1)
11700 return 1;
11701 if (TREE_CODE (arg0) == SSA_NAME || TREE_CODE (arg1) == SSA_NAME)
11702 return 0;
11703 return operand_equal_p (arg0, arg1, 0);
11704 }
11705
11706 /* Returns number of zeros at the end of binary representation of X. */
11707
11708 tree
11709 num_ending_zeros (const_tree x)
11710 {
11711 return build_int_cst (TREE_TYPE (x), wi::ctz (x));
11712 }
11713
11714
11715 #define WALK_SUBTREE(NODE) \
11716 do \
11717 { \
11718 result = walk_tree_1 (&(NODE), func, data, pset, lh); \
11719 if (result) \
11720 return result; \
11721 } \
11722 while (0)
11723
11724 /* This is a subroutine of walk_tree that walks field of TYPE that are to
11725 be walked whenever a type is seen in the tree. Rest of operands and return
11726 value are as for walk_tree. */
11727
11728 static tree
11729 walk_type_fields (tree type, walk_tree_fn func, void *data,
11730 hash_set<tree> *pset, walk_tree_lh lh)
11731 {
11732 tree result = NULL_TREE;
11733
11734 switch (TREE_CODE (type))
11735 {
11736 case POINTER_TYPE:
11737 case REFERENCE_TYPE:
11738 case VECTOR_TYPE:
11739 /* We have to worry about mutually recursive pointers. These can't
11740 be written in C. They can in Ada. It's pathological, but
11741 there's an ACATS test (c38102a) that checks it. Deal with this
11742 by checking if we're pointing to another pointer, that one
11743 points to another pointer, that one does too, and we have no htab.
11744 If so, get a hash table. We check three levels deep to avoid
11745 the cost of the hash table if we don't need one. */
11746 if (POINTER_TYPE_P (TREE_TYPE (type))
11747 && POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (type)))
11748 && POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (TREE_TYPE (type))))
11749 && !pset)
11750 {
11751 result = walk_tree_without_duplicates (&TREE_TYPE (type),
11752 func, data);
11753 if (result)
11754 return result;
11755
11756 break;
11757 }
11758
11759 /* fall through */
11760
11761 case COMPLEX_TYPE:
11762 WALK_SUBTREE (TREE_TYPE (type));
11763 break;
11764
11765 case METHOD_TYPE:
11766 WALK_SUBTREE (TYPE_METHOD_BASETYPE (type));
11767
11768 /* Fall through. */
11769
11770 case FUNCTION_TYPE:
11771 WALK_SUBTREE (TREE_TYPE (type));
11772 {
11773 tree arg;
11774
11775 /* We never want to walk into default arguments. */
11776 for (arg = TYPE_ARG_TYPES (type); arg; arg = TREE_CHAIN (arg))
11777 WALK_SUBTREE (TREE_VALUE (arg));
11778 }
11779 break;
11780
11781 case ARRAY_TYPE:
11782 /* Don't follow this nodes's type if a pointer for fear that
11783 we'll have infinite recursion. If we have a PSET, then we
11784 need not fear. */
11785 if (pset
11786 || (!POINTER_TYPE_P (TREE_TYPE (type))
11787 && TREE_CODE (TREE_TYPE (type)) != OFFSET_TYPE))
11788 WALK_SUBTREE (TREE_TYPE (type));
11789 WALK_SUBTREE (TYPE_DOMAIN (type));
11790 break;
11791
11792 case OFFSET_TYPE:
11793 WALK_SUBTREE (TREE_TYPE (type));
11794 WALK_SUBTREE (TYPE_OFFSET_BASETYPE (type));
11795 break;
11796
11797 default:
11798 break;
11799 }
11800
11801 return NULL_TREE;
11802 }
11803
11804 /* Apply FUNC to all the sub-trees of TP in a pre-order traversal. FUNC is
11805 called with the DATA and the address of each sub-tree. If FUNC returns a
11806 non-NULL value, the traversal is stopped, and the value returned by FUNC
11807 is returned. If PSET is non-NULL it is used to record the nodes visited,
11808 and to avoid visiting a node more than once. */
11809
11810 tree
11811 walk_tree_1 (tree *tp, walk_tree_fn func, void *data,
11812 hash_set<tree> *pset, walk_tree_lh lh)
11813 {
11814 enum tree_code code;
11815 int walk_subtrees;
11816 tree result;
11817
11818 #define WALK_SUBTREE_TAIL(NODE) \
11819 do \
11820 { \
11821 tp = & (NODE); \
11822 goto tail_recurse; \
11823 } \
11824 while (0)
11825
11826 tail_recurse:
11827 /* Skip empty subtrees. */
11828 if (!*tp)
11829 return NULL_TREE;
11830
11831 /* Don't walk the same tree twice, if the user has requested
11832 that we avoid doing so. */
11833 if (pset && pset->add (*tp))
11834 return NULL_TREE;
11835
11836 /* Call the function. */
11837 walk_subtrees = 1;
11838 result = (*func) (tp, &walk_subtrees, data);
11839
11840 /* If we found something, return it. */
11841 if (result)
11842 return result;
11843
11844 code = TREE_CODE (*tp);
11845
11846 /* Even if we didn't, FUNC may have decided that there was nothing
11847 interesting below this point in the tree. */
11848 if (!walk_subtrees)
11849 {
11850 /* But we still need to check our siblings. */
11851 if (code == TREE_LIST)
11852 WALK_SUBTREE_TAIL (TREE_CHAIN (*tp));
11853 else if (code == OMP_CLAUSE)
11854 WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp));
11855 else
11856 return NULL_TREE;
11857 }
11858
11859 if (lh)
11860 {
11861 result = (*lh) (tp, &walk_subtrees, func, data, pset);
11862 if (result || !walk_subtrees)
11863 return result;
11864 }
11865
11866 switch (code)
11867 {
11868 case ERROR_MARK:
11869 case IDENTIFIER_NODE:
11870 case INTEGER_CST:
11871 case REAL_CST:
11872 case FIXED_CST:
11873 case VECTOR_CST:
11874 case STRING_CST:
11875 case BLOCK:
11876 case PLACEHOLDER_EXPR:
11877 case SSA_NAME:
11878 case FIELD_DECL:
11879 case RESULT_DECL:
11880 /* None of these have subtrees other than those already walked
11881 above. */
11882 break;
11883
11884 case TREE_LIST:
11885 WALK_SUBTREE (TREE_VALUE (*tp));
11886 WALK_SUBTREE_TAIL (TREE_CHAIN (*tp));
11887 break;
11888
11889 case TREE_VEC:
11890 {
11891 int len = TREE_VEC_LENGTH (*tp);
11892
11893 if (len == 0)
11894 break;
11895
11896 /* Walk all elements but the first. */
11897 while (--len)
11898 WALK_SUBTREE (TREE_VEC_ELT (*tp, len));
11899
11900 /* Now walk the first one as a tail call. */
11901 WALK_SUBTREE_TAIL (TREE_VEC_ELT (*tp, 0));
11902 }
11903
11904 case COMPLEX_CST:
11905 WALK_SUBTREE (TREE_REALPART (*tp));
11906 WALK_SUBTREE_TAIL (TREE_IMAGPART (*tp));
11907
11908 case CONSTRUCTOR:
11909 {
11910 unsigned HOST_WIDE_INT idx;
11911 constructor_elt *ce;
11912
11913 for (idx = 0; vec_safe_iterate (CONSTRUCTOR_ELTS (*tp), idx, &ce);
11914 idx++)
11915 WALK_SUBTREE (ce->value);
11916 }
11917 break;
11918
11919 case SAVE_EXPR:
11920 WALK_SUBTREE_TAIL (TREE_OPERAND (*tp, 0));
11921
11922 case BIND_EXPR:
11923 {
11924 tree decl;
11925 for (decl = BIND_EXPR_VARS (*tp); decl; decl = DECL_CHAIN (decl))
11926 {
11927 /* Walk the DECL_INITIAL and DECL_SIZE. We don't want to walk
11928 into declarations that are just mentioned, rather than
11929 declared; they don't really belong to this part of the tree.
11930 And, we can see cycles: the initializer for a declaration
11931 can refer to the declaration itself. */
11932 WALK_SUBTREE (DECL_INITIAL (decl));
11933 WALK_SUBTREE (DECL_SIZE (decl));
11934 WALK_SUBTREE (DECL_SIZE_UNIT (decl));
11935 }
11936 WALK_SUBTREE_TAIL (BIND_EXPR_BODY (*tp));
11937 }
11938
11939 case STATEMENT_LIST:
11940 {
11941 tree_stmt_iterator i;
11942 for (i = tsi_start (*tp); !tsi_end_p (i); tsi_next (&i))
11943 WALK_SUBTREE (*tsi_stmt_ptr (i));
11944 }
11945 break;
11946
11947 case OMP_CLAUSE:
11948 switch (OMP_CLAUSE_CODE (*tp))
11949 {
11950 case OMP_CLAUSE_GANG:
11951 case OMP_CLAUSE__GRIDDIM_:
11952 WALK_SUBTREE (OMP_CLAUSE_OPERAND (*tp, 1));
11953 /* FALLTHRU */
11954
11955 case OMP_CLAUSE_ASYNC:
11956 case OMP_CLAUSE_WAIT:
11957 case OMP_CLAUSE_WORKER:
11958 case OMP_CLAUSE_VECTOR:
11959 case OMP_CLAUSE_NUM_GANGS:
11960 case OMP_CLAUSE_NUM_WORKERS:
11961 case OMP_CLAUSE_VECTOR_LENGTH:
11962 case OMP_CLAUSE_PRIVATE:
11963 case OMP_CLAUSE_SHARED:
11964 case OMP_CLAUSE_FIRSTPRIVATE:
11965 case OMP_CLAUSE_COPYIN:
11966 case OMP_CLAUSE_COPYPRIVATE:
11967 case OMP_CLAUSE_FINAL:
11968 case OMP_CLAUSE_IF:
11969 case OMP_CLAUSE_NUM_THREADS:
11970 case OMP_CLAUSE_SCHEDULE:
11971 case OMP_CLAUSE_UNIFORM:
11972 case OMP_CLAUSE_DEPEND:
11973 case OMP_CLAUSE_NUM_TEAMS:
11974 case OMP_CLAUSE_THREAD_LIMIT:
11975 case OMP_CLAUSE_DEVICE:
11976 case OMP_CLAUSE_DIST_SCHEDULE:
11977 case OMP_CLAUSE_SAFELEN:
11978 case OMP_CLAUSE_SIMDLEN:
11979 case OMP_CLAUSE_ORDERED:
11980 case OMP_CLAUSE_PRIORITY:
11981 case OMP_CLAUSE_GRAINSIZE:
11982 case OMP_CLAUSE_NUM_TASKS:
11983 case OMP_CLAUSE_HINT:
11984 case OMP_CLAUSE_TO_DECLARE:
11985 case OMP_CLAUSE_LINK:
11986 case OMP_CLAUSE_USE_DEVICE_PTR:
11987 case OMP_CLAUSE_IS_DEVICE_PTR:
11988 case OMP_CLAUSE__LOOPTEMP_:
11989 case OMP_CLAUSE__SIMDUID_:
11990 case OMP_CLAUSE__CILK_FOR_COUNT_:
11991 WALK_SUBTREE (OMP_CLAUSE_OPERAND (*tp, 0));
11992 /* FALLTHRU */
11993
11994 case OMP_CLAUSE_INDEPENDENT:
11995 case OMP_CLAUSE_NOWAIT:
11996 case OMP_CLAUSE_DEFAULT:
11997 case OMP_CLAUSE_UNTIED:
11998 case OMP_CLAUSE_MERGEABLE:
11999 case OMP_CLAUSE_PROC_BIND:
12000 case OMP_CLAUSE_INBRANCH:
12001 case OMP_CLAUSE_NOTINBRANCH:
12002 case OMP_CLAUSE_FOR:
12003 case OMP_CLAUSE_PARALLEL:
12004 case OMP_CLAUSE_SECTIONS:
12005 case OMP_CLAUSE_TASKGROUP:
12006 case OMP_CLAUSE_NOGROUP:
12007 case OMP_CLAUSE_THREADS:
12008 case OMP_CLAUSE_SIMD:
12009 case OMP_CLAUSE_DEFAULTMAP:
12010 case OMP_CLAUSE_AUTO:
12011 case OMP_CLAUSE_SEQ:
12012 case OMP_CLAUSE_TILE:
12013 case OMP_CLAUSE__SIMT_:
12014 WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp));
12015
12016 case OMP_CLAUSE_LASTPRIVATE:
12017 WALK_SUBTREE (OMP_CLAUSE_DECL (*tp));
12018 WALK_SUBTREE (OMP_CLAUSE_LASTPRIVATE_STMT (*tp));
12019 WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp));
12020
12021 case OMP_CLAUSE_COLLAPSE:
12022 {
12023 int i;
12024 for (i = 0; i < 3; i++)
12025 WALK_SUBTREE (OMP_CLAUSE_OPERAND (*tp, i));
12026 WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp));
12027 }
12028
12029 case OMP_CLAUSE_LINEAR:
12030 WALK_SUBTREE (OMP_CLAUSE_DECL (*tp));
12031 WALK_SUBTREE (OMP_CLAUSE_LINEAR_STEP (*tp));
12032 WALK_SUBTREE (OMP_CLAUSE_LINEAR_STMT (*tp));
12033 WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp));
12034
12035 case OMP_CLAUSE_ALIGNED:
12036 case OMP_CLAUSE_FROM:
12037 case OMP_CLAUSE_TO:
12038 case OMP_CLAUSE_MAP:
12039 case OMP_CLAUSE__CACHE_:
12040 WALK_SUBTREE (OMP_CLAUSE_DECL (*tp));
12041 WALK_SUBTREE (OMP_CLAUSE_OPERAND (*tp, 1));
12042 WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp));
12043
12044 case OMP_CLAUSE_REDUCTION:
12045 {
12046 int i;
12047 for (i = 0; i < 5; i++)
12048 WALK_SUBTREE (OMP_CLAUSE_OPERAND (*tp, i));
12049 WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp));
12050 }
12051
12052 default:
12053 gcc_unreachable ();
12054 }
12055 break;
12056
12057 case TARGET_EXPR:
12058 {
12059 int i, len;
12060
12061 /* TARGET_EXPRs are peculiar: operands 1 and 3 can be the same.
12062 But, we only want to walk once. */
12063 len = (TREE_OPERAND (*tp, 3) == TREE_OPERAND (*tp, 1)) ? 2 : 3;
12064 for (i = 0; i < len; ++i)
12065 WALK_SUBTREE (TREE_OPERAND (*tp, i));
12066 WALK_SUBTREE_TAIL (TREE_OPERAND (*tp, len));
12067 }
12068
12069 case DECL_EXPR:
12070 /* If this is a TYPE_DECL, walk into the fields of the type that it's
12071 defining. We only want to walk into these fields of a type in this
12072 case and not in the general case of a mere reference to the type.
12073
12074 The criterion is as follows: if the field can be an expression, it
12075 must be walked only here. This should be in keeping with the fields
12076 that are directly gimplified in gimplify_type_sizes in order for the
12077 mark/copy-if-shared/unmark machinery of the gimplifier to work with
12078 variable-sized types.
12079
12080 Note that DECLs get walked as part of processing the BIND_EXPR. */
12081 if (TREE_CODE (DECL_EXPR_DECL (*tp)) == TYPE_DECL)
12082 {
12083 tree *type_p = &TREE_TYPE (DECL_EXPR_DECL (*tp));
12084 if (TREE_CODE (*type_p) == ERROR_MARK)
12085 return NULL_TREE;
12086
12087 /* Call the function for the type. See if it returns anything or
12088 doesn't want us to continue. If we are to continue, walk both
12089 the normal fields and those for the declaration case. */
12090 result = (*func) (type_p, &walk_subtrees, data);
12091 if (result || !walk_subtrees)
12092 return result;
12093
12094 /* But do not walk a pointed-to type since it may itself need to
12095 be walked in the declaration case if it isn't anonymous. */
12096 if (!POINTER_TYPE_P (*type_p))
12097 {
12098 result = walk_type_fields (*type_p, func, data, pset, lh);
12099 if (result)
12100 return result;
12101 }
12102
12103 /* If this is a record type, also walk the fields. */
12104 if (RECORD_OR_UNION_TYPE_P (*type_p))
12105 {
12106 tree field;
12107
12108 for (field = TYPE_FIELDS (*type_p); field;
12109 field = DECL_CHAIN (field))
12110 {
12111 /* We'd like to look at the type of the field, but we can
12112 easily get infinite recursion. So assume it's pointed
12113 to elsewhere in the tree. Also, ignore things that
12114 aren't fields. */
12115 if (TREE_CODE (field) != FIELD_DECL)
12116 continue;
12117
12118 WALK_SUBTREE (DECL_FIELD_OFFSET (field));
12119 WALK_SUBTREE (DECL_SIZE (field));
12120 WALK_SUBTREE (DECL_SIZE_UNIT (field));
12121 if (TREE_CODE (*type_p) == QUAL_UNION_TYPE)
12122 WALK_SUBTREE (DECL_QUALIFIER (field));
12123 }
12124 }
12125
12126 /* Same for scalar types. */
12127 else if (TREE_CODE (*type_p) == BOOLEAN_TYPE
12128 || TREE_CODE (*type_p) == ENUMERAL_TYPE
12129 || TREE_CODE (*type_p) == INTEGER_TYPE
12130 || TREE_CODE (*type_p) == FIXED_POINT_TYPE
12131 || TREE_CODE (*type_p) == REAL_TYPE)
12132 {
12133 WALK_SUBTREE (TYPE_MIN_VALUE (*type_p));
12134 WALK_SUBTREE (TYPE_MAX_VALUE (*type_p));
12135 }
12136
12137 WALK_SUBTREE (TYPE_SIZE (*type_p));
12138 WALK_SUBTREE_TAIL (TYPE_SIZE_UNIT (*type_p));
12139 }
12140 /* FALLTHRU */
12141
12142 default:
12143 if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (code)))
12144 {
12145 int i, len;
12146
12147 /* Walk over all the sub-trees of this operand. */
12148 len = TREE_OPERAND_LENGTH (*tp);
12149
12150 /* Go through the subtrees. We need to do this in forward order so
12151 that the scope of a FOR_EXPR is handled properly. */
12152 if (len)
12153 {
12154 for (i = 0; i < len - 1; ++i)
12155 WALK_SUBTREE (TREE_OPERAND (*tp, i));
12156 WALK_SUBTREE_TAIL (TREE_OPERAND (*tp, len - 1));
12157 }
12158 }
12159 /* If this is a type, walk the needed fields in the type. */
12160 else if (TYPE_P (*tp))
12161 return walk_type_fields (*tp, func, data, pset, lh);
12162 break;
12163 }
12164
12165 /* We didn't find what we were looking for. */
12166 return NULL_TREE;
12167
12168 #undef WALK_SUBTREE_TAIL
12169 }
12170 #undef WALK_SUBTREE
12171
12172 /* Like walk_tree, but does not walk duplicate nodes more than once. */
12173
12174 tree
12175 walk_tree_without_duplicates_1 (tree *tp, walk_tree_fn func, void *data,
12176 walk_tree_lh lh)
12177 {
12178 tree result;
12179
12180 hash_set<tree> pset;
12181 result = walk_tree_1 (tp, func, data, &pset, lh);
12182 return result;
12183 }
12184
12185
12186 tree
12187 tree_block (tree t)
12188 {
12189 const enum tree_code_class c = TREE_CODE_CLASS (TREE_CODE (t));
12190
12191 if (IS_EXPR_CODE_CLASS (c))
12192 return LOCATION_BLOCK (t->exp.locus);
12193 gcc_unreachable ();
12194 return NULL;
12195 }
12196
12197 void
12198 tree_set_block (tree t, tree b)
12199 {
12200 const enum tree_code_class c = TREE_CODE_CLASS (TREE_CODE (t));
12201
12202 if (IS_EXPR_CODE_CLASS (c))
12203 {
12204 t->exp.locus = set_block (t->exp.locus, b);
12205 }
12206 else
12207 gcc_unreachable ();
12208 }
12209
12210 /* Create a nameless artificial label and put it in the current
12211 function context. The label has a location of LOC. Returns the
12212 newly created label. */
12213
12214 tree
12215 create_artificial_label (location_t loc)
12216 {
12217 tree lab = build_decl (loc,
12218 LABEL_DECL, NULL_TREE, void_type_node);
12219
12220 DECL_ARTIFICIAL (lab) = 1;
12221 DECL_IGNORED_P (lab) = 1;
12222 DECL_CONTEXT (lab) = current_function_decl;
12223 return lab;
12224 }
12225
12226 /* Given a tree, try to return a useful variable name that we can use
12227 to prefix a temporary that is being assigned the value of the tree.
12228 I.E. given <temp> = &A, return A. */
12229
12230 const char *
12231 get_name (tree t)
12232 {
12233 tree stripped_decl;
12234
12235 stripped_decl = t;
12236 STRIP_NOPS (stripped_decl);
12237 if (DECL_P (stripped_decl) && DECL_NAME (stripped_decl))
12238 return IDENTIFIER_POINTER (DECL_NAME (stripped_decl));
12239 else if (TREE_CODE (stripped_decl) == SSA_NAME)
12240 {
12241 tree name = SSA_NAME_IDENTIFIER (stripped_decl);
12242 if (!name)
12243 return NULL;
12244 return IDENTIFIER_POINTER (name);
12245 }
12246 else
12247 {
12248 switch (TREE_CODE (stripped_decl))
12249 {
12250 case ADDR_EXPR:
12251 return get_name (TREE_OPERAND (stripped_decl, 0));
12252 default:
12253 return NULL;
12254 }
12255 }
12256 }
12257
12258 /* Return true if TYPE has a variable argument list. */
12259
12260 bool
12261 stdarg_p (const_tree fntype)
12262 {
12263 function_args_iterator args_iter;
12264 tree n = NULL_TREE, t;
12265
12266 if (!fntype)
12267 return false;
12268
12269 FOREACH_FUNCTION_ARGS (fntype, t, args_iter)
12270 {
12271 n = t;
12272 }
12273
12274 return n != NULL_TREE && n != void_type_node;
12275 }
12276
12277 /* Return true if TYPE has a prototype. */
12278
12279 bool
12280 prototype_p (const_tree fntype)
12281 {
12282 tree t;
12283
12284 gcc_assert (fntype != NULL_TREE);
12285
12286 t = TYPE_ARG_TYPES (fntype);
12287 return (t != NULL_TREE);
12288 }
12289
12290 /* If BLOCK is inlined from an __attribute__((__artificial__))
12291 routine, return pointer to location from where it has been
12292 called. */
12293 location_t *
12294 block_nonartificial_location (tree block)
12295 {
12296 location_t *ret = NULL;
12297
12298 while (block && TREE_CODE (block) == BLOCK
12299 && BLOCK_ABSTRACT_ORIGIN (block))
12300 {
12301 tree ao = BLOCK_ABSTRACT_ORIGIN (block);
12302
12303 while (TREE_CODE (ao) == BLOCK
12304 && BLOCK_ABSTRACT_ORIGIN (ao)
12305 && BLOCK_ABSTRACT_ORIGIN (ao) != ao)
12306 ao = BLOCK_ABSTRACT_ORIGIN (ao);
12307
12308 if (TREE_CODE (ao) == FUNCTION_DECL)
12309 {
12310 /* If AO is an artificial inline, point RET to the
12311 call site locus at which it has been inlined and continue
12312 the loop, in case AO's caller is also an artificial
12313 inline. */
12314 if (DECL_DECLARED_INLINE_P (ao)
12315 && lookup_attribute ("artificial", DECL_ATTRIBUTES (ao)))
12316 ret = &BLOCK_SOURCE_LOCATION (block);
12317 else
12318 break;
12319 }
12320 else if (TREE_CODE (ao) != BLOCK)
12321 break;
12322
12323 block = BLOCK_SUPERCONTEXT (block);
12324 }
12325 return ret;
12326 }
12327
12328
12329 /* If EXP is inlined from an __attribute__((__artificial__))
12330 function, return the location of the original call expression. */
12331
12332 location_t
12333 tree_nonartificial_location (tree exp)
12334 {
12335 location_t *loc = block_nonartificial_location (TREE_BLOCK (exp));
12336
12337 if (loc)
12338 return *loc;
12339 else
12340 return EXPR_LOCATION (exp);
12341 }
12342
12343
12344 /* These are the hash table functions for the hash table of OPTIMIZATION_NODEq
12345 nodes. */
12346
12347 /* Return the hash code X, an OPTIMIZATION_NODE or TARGET_OPTION code. */
12348
12349 hashval_t
12350 cl_option_hasher::hash (tree x)
12351 {
12352 const_tree const t = x;
12353 const char *p;
12354 size_t i;
12355 size_t len = 0;
12356 hashval_t hash = 0;
12357
12358 if (TREE_CODE (t) == OPTIMIZATION_NODE)
12359 {
12360 p = (const char *)TREE_OPTIMIZATION (t);
12361 len = sizeof (struct cl_optimization);
12362 }
12363
12364 else if (TREE_CODE (t) == TARGET_OPTION_NODE)
12365 return cl_target_option_hash (TREE_TARGET_OPTION (t));
12366
12367 else
12368 gcc_unreachable ();
12369
12370 /* assume most opt flags are just 0/1, some are 2-3, and a few might be
12371 something else. */
12372 for (i = 0; i < len; i++)
12373 if (p[i])
12374 hash = (hash << 4) ^ ((i << 2) | p[i]);
12375
12376 return hash;
12377 }
12378
12379 /* Return nonzero if the value represented by *X (an OPTIMIZATION or
12380 TARGET_OPTION tree node) is the same as that given by *Y, which is the
12381 same. */
12382
12383 bool
12384 cl_option_hasher::equal (tree x, tree y)
12385 {
12386 const_tree const xt = x;
12387 const_tree const yt = y;
12388 const char *xp;
12389 const char *yp;
12390 size_t len;
12391
12392 if (TREE_CODE (xt) != TREE_CODE (yt))
12393 return 0;
12394
12395 if (TREE_CODE (xt) == OPTIMIZATION_NODE)
12396 {
12397 xp = (const char *)TREE_OPTIMIZATION (xt);
12398 yp = (const char *)TREE_OPTIMIZATION (yt);
12399 len = sizeof (struct cl_optimization);
12400 }
12401
12402 else if (TREE_CODE (xt) == TARGET_OPTION_NODE)
12403 {
12404 return cl_target_option_eq (TREE_TARGET_OPTION (xt),
12405 TREE_TARGET_OPTION (yt));
12406 }
12407
12408 else
12409 gcc_unreachable ();
12410
12411 return (memcmp (xp, yp, len) == 0);
12412 }
12413
12414 /* Build an OPTIMIZATION_NODE based on the options in OPTS. */
12415
12416 tree
12417 build_optimization_node (struct gcc_options *opts)
12418 {
12419 tree t;
12420
12421 /* Use the cache of optimization nodes. */
12422
12423 cl_optimization_save (TREE_OPTIMIZATION (cl_optimization_node),
12424 opts);
12425
12426 tree *slot = cl_option_hash_table->find_slot (cl_optimization_node, INSERT);
12427 t = *slot;
12428 if (!t)
12429 {
12430 /* Insert this one into the hash table. */
12431 t = cl_optimization_node;
12432 *slot = t;
12433
12434 /* Make a new node for next time round. */
12435 cl_optimization_node = make_node (OPTIMIZATION_NODE);
12436 }
12437
12438 return t;
12439 }
12440
12441 /* Build a TARGET_OPTION_NODE based on the options in OPTS. */
12442
12443 tree
12444 build_target_option_node (struct gcc_options *opts)
12445 {
12446 tree t;
12447
12448 /* Use the cache of optimization nodes. */
12449
12450 cl_target_option_save (TREE_TARGET_OPTION (cl_target_option_node),
12451 opts);
12452
12453 tree *slot = cl_option_hash_table->find_slot (cl_target_option_node, INSERT);
12454 t = *slot;
12455 if (!t)
12456 {
12457 /* Insert this one into the hash table. */
12458 t = cl_target_option_node;
12459 *slot = t;
12460
12461 /* Make a new node for next time round. */
12462 cl_target_option_node = make_node (TARGET_OPTION_NODE);
12463 }
12464
12465 return t;
12466 }
12467
12468 /* Clear TREE_TARGET_GLOBALS of all TARGET_OPTION_NODE trees,
12469 so that they aren't saved during PCH writing. */
12470
12471 void
12472 prepare_target_option_nodes_for_pch (void)
12473 {
12474 hash_table<cl_option_hasher>::iterator iter = cl_option_hash_table->begin ();
12475 for (; iter != cl_option_hash_table->end (); ++iter)
12476 if (TREE_CODE (*iter) == TARGET_OPTION_NODE)
12477 TREE_TARGET_GLOBALS (*iter) = NULL;
12478 }
12479
12480 /* Determine the "ultimate origin" of a block. The block may be an inlined
12481 instance of an inlined instance of a block which is local to an inline
12482 function, so we have to trace all of the way back through the origin chain
12483 to find out what sort of node actually served as the original seed for the
12484 given block. */
12485
12486 tree
12487 block_ultimate_origin (const_tree block)
12488 {
12489 tree immediate_origin = BLOCK_ABSTRACT_ORIGIN (block);
12490
12491 /* BLOCK_ABSTRACT_ORIGIN can point to itself; ignore that if
12492 we're trying to output the abstract instance of this function. */
12493 if (BLOCK_ABSTRACT (block) && immediate_origin == block)
12494 return NULL_TREE;
12495
12496 if (immediate_origin == NULL_TREE)
12497 return NULL_TREE;
12498 else
12499 {
12500 tree ret_val;
12501 tree lookahead = immediate_origin;
12502
12503 do
12504 {
12505 ret_val = lookahead;
12506 lookahead = (TREE_CODE (ret_val) == BLOCK
12507 ? BLOCK_ABSTRACT_ORIGIN (ret_val) : NULL);
12508 }
12509 while (lookahead != NULL && lookahead != ret_val);
12510
12511 /* The block's abstract origin chain may not be the *ultimate* origin of
12512 the block. It could lead to a DECL that has an abstract origin set.
12513 If so, we want that DECL's abstract origin (which is what DECL_ORIGIN
12514 will give us if it has one). Note that DECL's abstract origins are
12515 supposed to be the most distant ancestor (or so decl_ultimate_origin
12516 claims), so we don't need to loop following the DECL origins. */
12517 if (DECL_P (ret_val))
12518 return DECL_ORIGIN (ret_val);
12519
12520 return ret_val;
12521 }
12522 }
12523
12524 /* Return true iff conversion from INNER_TYPE to OUTER_TYPE generates
12525 no instruction. */
12526
12527 bool
12528 tree_nop_conversion_p (const_tree outer_type, const_tree inner_type)
12529 {
12530 /* Do not strip casts into or out of differing address spaces. */
12531 if (POINTER_TYPE_P (outer_type)
12532 && TYPE_ADDR_SPACE (TREE_TYPE (outer_type)) != ADDR_SPACE_GENERIC)
12533 {
12534 if (!POINTER_TYPE_P (inner_type)
12535 || (TYPE_ADDR_SPACE (TREE_TYPE (outer_type))
12536 != TYPE_ADDR_SPACE (TREE_TYPE (inner_type))))
12537 return false;
12538 }
12539 else if (POINTER_TYPE_P (inner_type)
12540 && TYPE_ADDR_SPACE (TREE_TYPE (inner_type)) != ADDR_SPACE_GENERIC)
12541 {
12542 /* We already know that outer_type is not a pointer with
12543 a non-generic address space. */
12544 return false;
12545 }
12546
12547 /* Use precision rather then machine mode when we can, which gives
12548 the correct answer even for submode (bit-field) types. */
12549 if ((INTEGRAL_TYPE_P (outer_type)
12550 || POINTER_TYPE_P (outer_type)
12551 || TREE_CODE (outer_type) == OFFSET_TYPE)
12552 && (INTEGRAL_TYPE_P (inner_type)
12553 || POINTER_TYPE_P (inner_type)
12554 || TREE_CODE (inner_type) == OFFSET_TYPE))
12555 return TYPE_PRECISION (outer_type) == TYPE_PRECISION (inner_type);
12556
12557 /* Otherwise fall back on comparing machine modes (e.g. for
12558 aggregate types, floats). */
12559 return TYPE_MODE (outer_type) == TYPE_MODE (inner_type);
12560 }
12561
12562 /* Return true iff conversion in EXP generates no instruction. Mark
12563 it inline so that we fully inline into the stripping functions even
12564 though we have two uses of this function. */
12565
12566 static inline bool
12567 tree_nop_conversion (const_tree exp)
12568 {
12569 tree outer_type, inner_type;
12570
12571 if (!CONVERT_EXPR_P (exp)
12572 && TREE_CODE (exp) != NON_LVALUE_EXPR)
12573 return false;
12574 if (TREE_OPERAND (exp, 0) == error_mark_node)
12575 return false;
12576
12577 outer_type = TREE_TYPE (exp);
12578 inner_type = TREE_TYPE (TREE_OPERAND (exp, 0));
12579
12580 if (!inner_type)
12581 return false;
12582
12583 return tree_nop_conversion_p (outer_type, inner_type);
12584 }
12585
12586 /* Return true iff conversion in EXP generates no instruction. Don't
12587 consider conversions changing the signedness. */
12588
12589 static bool
12590 tree_sign_nop_conversion (const_tree exp)
12591 {
12592 tree outer_type, inner_type;
12593
12594 if (!tree_nop_conversion (exp))
12595 return false;
12596
12597 outer_type = TREE_TYPE (exp);
12598 inner_type = TREE_TYPE (TREE_OPERAND (exp, 0));
12599
12600 return (TYPE_UNSIGNED (outer_type) == TYPE_UNSIGNED (inner_type)
12601 && POINTER_TYPE_P (outer_type) == POINTER_TYPE_P (inner_type));
12602 }
12603
12604 /* Strip conversions from EXP according to tree_nop_conversion and
12605 return the resulting expression. */
12606
12607 tree
12608 tree_strip_nop_conversions (tree exp)
12609 {
12610 while (tree_nop_conversion (exp))
12611 exp = TREE_OPERAND (exp, 0);
12612 return exp;
12613 }
12614
12615 /* Strip conversions from EXP according to tree_sign_nop_conversion
12616 and return the resulting expression. */
12617
12618 tree
12619 tree_strip_sign_nop_conversions (tree exp)
12620 {
12621 while (tree_sign_nop_conversion (exp))
12622 exp = TREE_OPERAND (exp, 0);
12623 return exp;
12624 }
12625
12626 /* Avoid any floating point extensions from EXP. */
12627 tree
12628 strip_float_extensions (tree exp)
12629 {
12630 tree sub, expt, subt;
12631
12632 /* For floating point constant look up the narrowest type that can hold
12633 it properly and handle it like (type)(narrowest_type)constant.
12634 This way we can optimize for instance a=a*2.0 where "a" is float
12635 but 2.0 is double constant. */
12636 if (TREE_CODE (exp) == REAL_CST && !DECIMAL_FLOAT_TYPE_P (TREE_TYPE (exp)))
12637 {
12638 REAL_VALUE_TYPE orig;
12639 tree type = NULL;
12640
12641 orig = TREE_REAL_CST (exp);
12642 if (TYPE_PRECISION (TREE_TYPE (exp)) > TYPE_PRECISION (float_type_node)
12643 && exact_real_truncate (TYPE_MODE (float_type_node), &orig))
12644 type = float_type_node;
12645 else if (TYPE_PRECISION (TREE_TYPE (exp))
12646 > TYPE_PRECISION (double_type_node)
12647 && exact_real_truncate (TYPE_MODE (double_type_node), &orig))
12648 type = double_type_node;
12649 if (type)
12650 return build_real_truncate (type, orig);
12651 }
12652
12653 if (!CONVERT_EXPR_P (exp))
12654 return exp;
12655
12656 sub = TREE_OPERAND (exp, 0);
12657 subt = TREE_TYPE (sub);
12658 expt = TREE_TYPE (exp);
12659
12660 if (!FLOAT_TYPE_P (subt))
12661 return exp;
12662
12663 if (DECIMAL_FLOAT_TYPE_P (expt) != DECIMAL_FLOAT_TYPE_P (subt))
12664 return exp;
12665
12666 if (TYPE_PRECISION (subt) > TYPE_PRECISION (expt))
12667 return exp;
12668
12669 return strip_float_extensions (sub);
12670 }
12671
12672 /* Strip out all handled components that produce invariant
12673 offsets. */
12674
12675 const_tree
12676 strip_invariant_refs (const_tree op)
12677 {
12678 while (handled_component_p (op))
12679 {
12680 switch (TREE_CODE (op))
12681 {
12682 case ARRAY_REF:
12683 case ARRAY_RANGE_REF:
12684 if (!is_gimple_constant (TREE_OPERAND (op, 1))
12685 || TREE_OPERAND (op, 2) != NULL_TREE
12686 || TREE_OPERAND (op, 3) != NULL_TREE)
12687 return NULL;
12688 break;
12689
12690 case COMPONENT_REF:
12691 if (TREE_OPERAND (op, 2) != NULL_TREE)
12692 return NULL;
12693 break;
12694
12695 default:;
12696 }
12697 op = TREE_OPERAND (op, 0);
12698 }
12699
12700 return op;
12701 }
12702
12703 static GTY(()) tree gcc_eh_personality_decl;
12704
12705 /* Return the GCC personality function decl. */
12706
12707 tree
12708 lhd_gcc_personality (void)
12709 {
12710 if (!gcc_eh_personality_decl)
12711 gcc_eh_personality_decl = build_personality_function ("gcc");
12712 return gcc_eh_personality_decl;
12713 }
12714
12715 /* TARGET is a call target of GIMPLE call statement
12716 (obtained by gimple_call_fn). Return true if it is
12717 OBJ_TYPE_REF representing an virtual call of C++ method.
12718 (As opposed to OBJ_TYPE_REF representing objc calls
12719 through a cast where middle-end devirtualization machinery
12720 can't apply.) */
12721
12722 bool
12723 virtual_method_call_p (const_tree target)
12724 {
12725 if (TREE_CODE (target) != OBJ_TYPE_REF)
12726 return false;
12727 tree t = TREE_TYPE (target);
12728 gcc_checking_assert (TREE_CODE (t) == POINTER_TYPE);
12729 t = TREE_TYPE (t);
12730 if (TREE_CODE (t) == FUNCTION_TYPE)
12731 return false;
12732 gcc_checking_assert (TREE_CODE (t) == METHOD_TYPE);
12733 /* If we do not have BINFO associated, it means that type was built
12734 without devirtualization enabled. Do not consider this a virtual
12735 call. */
12736 if (!TYPE_BINFO (obj_type_ref_class (target)))
12737 return false;
12738 return true;
12739 }
12740
12741 /* REF is OBJ_TYPE_REF, return the class the ref corresponds to. */
12742
12743 tree
12744 obj_type_ref_class (const_tree ref)
12745 {
12746 gcc_checking_assert (TREE_CODE (ref) == OBJ_TYPE_REF);
12747 ref = TREE_TYPE (ref);
12748 gcc_checking_assert (TREE_CODE (ref) == POINTER_TYPE);
12749 ref = TREE_TYPE (ref);
12750 /* We look for type THIS points to. ObjC also builds
12751 OBJ_TYPE_REF with non-method calls, Their first parameter
12752 ID however also corresponds to class type. */
12753 gcc_checking_assert (TREE_CODE (ref) == METHOD_TYPE
12754 || TREE_CODE (ref) == FUNCTION_TYPE);
12755 ref = TREE_VALUE (TYPE_ARG_TYPES (ref));
12756 gcc_checking_assert (TREE_CODE (ref) == POINTER_TYPE);
12757 return TREE_TYPE (ref);
12758 }
12759
12760 /* Lookup sub-BINFO of BINFO of TYPE at offset POS. */
12761
12762 static tree
12763 lookup_binfo_at_offset (tree binfo, tree type, HOST_WIDE_INT pos)
12764 {
12765 unsigned int i;
12766 tree base_binfo, b;
12767
12768 for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
12769 if (pos == tree_to_shwi (BINFO_OFFSET (base_binfo))
12770 && types_same_for_odr (TREE_TYPE (base_binfo), type))
12771 return base_binfo;
12772 else if ((b = lookup_binfo_at_offset (base_binfo, type, pos)) != NULL)
12773 return b;
12774 return NULL;
12775 }
12776
12777 /* Try to find a base info of BINFO that would have its field decl at offset
12778 OFFSET within the BINFO type and which is of EXPECTED_TYPE. If it can be
12779 found, return, otherwise return NULL_TREE. */
12780
12781 tree
12782 get_binfo_at_offset (tree binfo, HOST_WIDE_INT offset, tree expected_type)
12783 {
12784 tree type = BINFO_TYPE (binfo);
12785
12786 while (true)
12787 {
12788 HOST_WIDE_INT pos, size;
12789 tree fld;
12790 int i;
12791
12792 if (types_same_for_odr (type, expected_type))
12793 return binfo;
12794 if (offset < 0)
12795 return NULL_TREE;
12796
12797 for (fld = TYPE_FIELDS (type); fld; fld = DECL_CHAIN (fld))
12798 {
12799 if (TREE_CODE (fld) != FIELD_DECL || !DECL_ARTIFICIAL (fld))
12800 continue;
12801
12802 pos = int_bit_position (fld);
12803 size = tree_to_uhwi (DECL_SIZE (fld));
12804 if (pos <= offset && (pos + size) > offset)
12805 break;
12806 }
12807 if (!fld || TREE_CODE (TREE_TYPE (fld)) != RECORD_TYPE)
12808 return NULL_TREE;
12809
12810 /* Offset 0 indicates the primary base, whose vtable contents are
12811 represented in the binfo for the derived class. */
12812 else if (offset != 0)
12813 {
12814 tree found_binfo = NULL, base_binfo;
12815 /* Offsets in BINFO are in bytes relative to the whole structure
12816 while POS is in bits relative to the containing field. */
12817 int binfo_offset = (tree_to_shwi (BINFO_OFFSET (binfo)) + pos
12818 / BITS_PER_UNIT);
12819
12820 for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
12821 if (tree_to_shwi (BINFO_OFFSET (base_binfo)) == binfo_offset
12822 && types_same_for_odr (TREE_TYPE (base_binfo), TREE_TYPE (fld)))
12823 {
12824 found_binfo = base_binfo;
12825 break;
12826 }
12827 if (found_binfo)
12828 binfo = found_binfo;
12829 else
12830 binfo = lookup_binfo_at_offset (binfo, TREE_TYPE (fld),
12831 binfo_offset);
12832 }
12833
12834 type = TREE_TYPE (fld);
12835 offset -= pos;
12836 }
12837 }
12838
12839 /* Returns true if X is a typedef decl. */
12840
12841 bool
12842 is_typedef_decl (const_tree x)
12843 {
12844 return (x && TREE_CODE (x) == TYPE_DECL
12845 && DECL_ORIGINAL_TYPE (x) != NULL_TREE);
12846 }
12847
12848 /* Returns true iff TYPE is a type variant created for a typedef. */
12849
12850 bool
12851 typedef_variant_p (const_tree type)
12852 {
12853 return is_typedef_decl (TYPE_NAME (type));
12854 }
12855
12856 /* Warn about a use of an identifier which was marked deprecated. */
12857 void
12858 warn_deprecated_use (tree node, tree attr)
12859 {
12860 const char *msg;
12861
12862 if (node == 0 || !warn_deprecated_decl)
12863 return;
12864
12865 if (!attr)
12866 {
12867 if (DECL_P (node))
12868 attr = DECL_ATTRIBUTES (node);
12869 else if (TYPE_P (node))
12870 {
12871 tree decl = TYPE_STUB_DECL (node);
12872 if (decl)
12873 attr = lookup_attribute ("deprecated",
12874 TYPE_ATTRIBUTES (TREE_TYPE (decl)));
12875 }
12876 }
12877
12878 if (attr)
12879 attr = lookup_attribute ("deprecated", attr);
12880
12881 if (attr)
12882 msg = TREE_STRING_POINTER (TREE_VALUE (TREE_VALUE (attr)));
12883 else
12884 msg = NULL;
12885
12886 bool w;
12887 if (DECL_P (node))
12888 {
12889 if (msg)
12890 w = warning (OPT_Wdeprecated_declarations,
12891 "%qD is deprecated: %s", node, msg);
12892 else
12893 w = warning (OPT_Wdeprecated_declarations,
12894 "%qD is deprecated", node);
12895 if (w)
12896 inform (DECL_SOURCE_LOCATION (node), "declared here");
12897 }
12898 else if (TYPE_P (node))
12899 {
12900 tree what = NULL_TREE;
12901 tree decl = TYPE_STUB_DECL (node);
12902
12903 if (TYPE_NAME (node))
12904 {
12905 if (TREE_CODE (TYPE_NAME (node)) == IDENTIFIER_NODE)
12906 what = TYPE_NAME (node);
12907 else if (TREE_CODE (TYPE_NAME (node)) == TYPE_DECL
12908 && DECL_NAME (TYPE_NAME (node)))
12909 what = DECL_NAME (TYPE_NAME (node));
12910 }
12911
12912 if (decl)
12913 {
12914 if (what)
12915 {
12916 if (msg)
12917 w = warning (OPT_Wdeprecated_declarations,
12918 "%qE is deprecated: %s", what, msg);
12919 else
12920 w = warning (OPT_Wdeprecated_declarations,
12921 "%qE is deprecated", what);
12922 }
12923 else
12924 {
12925 if (msg)
12926 w = warning (OPT_Wdeprecated_declarations,
12927 "type is deprecated: %s", msg);
12928 else
12929 w = warning (OPT_Wdeprecated_declarations,
12930 "type is deprecated");
12931 }
12932 if (w)
12933 inform (DECL_SOURCE_LOCATION (decl), "declared here");
12934 }
12935 else
12936 {
12937 if (what)
12938 {
12939 if (msg)
12940 warning (OPT_Wdeprecated_declarations, "%qE is deprecated: %s",
12941 what, msg);
12942 else
12943 warning (OPT_Wdeprecated_declarations, "%qE is deprecated", what);
12944 }
12945 else
12946 {
12947 if (msg)
12948 warning (OPT_Wdeprecated_declarations, "type is deprecated: %s",
12949 msg);
12950 else
12951 warning (OPT_Wdeprecated_declarations, "type is deprecated");
12952 }
12953 }
12954 }
12955 }
12956
12957 /* Return true if REF has a COMPONENT_REF with a bit-field field declaration
12958 somewhere in it. */
12959
12960 bool
12961 contains_bitfld_component_ref_p (const_tree ref)
12962 {
12963 while (handled_component_p (ref))
12964 {
12965 if (TREE_CODE (ref) == COMPONENT_REF
12966 && DECL_BIT_FIELD (TREE_OPERAND (ref, 1)))
12967 return true;
12968 ref = TREE_OPERAND (ref, 0);
12969 }
12970
12971 return false;
12972 }
12973
12974 /* Try to determine whether a TRY_CATCH expression can fall through.
12975 This is a subroutine of block_may_fallthru. */
12976
12977 static bool
12978 try_catch_may_fallthru (const_tree stmt)
12979 {
12980 tree_stmt_iterator i;
12981
12982 /* If the TRY block can fall through, the whole TRY_CATCH can
12983 fall through. */
12984 if (block_may_fallthru (TREE_OPERAND (stmt, 0)))
12985 return true;
12986
12987 i = tsi_start (TREE_OPERAND (stmt, 1));
12988 switch (TREE_CODE (tsi_stmt (i)))
12989 {
12990 case CATCH_EXPR:
12991 /* We expect to see a sequence of CATCH_EXPR trees, each with a
12992 catch expression and a body. The whole TRY_CATCH may fall
12993 through iff any of the catch bodies falls through. */
12994 for (; !tsi_end_p (i); tsi_next (&i))
12995 {
12996 if (block_may_fallthru (CATCH_BODY (tsi_stmt (i))))
12997 return true;
12998 }
12999 return false;
13000
13001 case EH_FILTER_EXPR:
13002 /* The exception filter expression only matters if there is an
13003 exception. If the exception does not match EH_FILTER_TYPES,
13004 we will execute EH_FILTER_FAILURE, and we will fall through
13005 if that falls through. If the exception does match
13006 EH_FILTER_TYPES, the stack unwinder will continue up the
13007 stack, so we will not fall through. We don't know whether we
13008 will throw an exception which matches EH_FILTER_TYPES or not,
13009 so we just ignore EH_FILTER_TYPES and assume that we might
13010 throw an exception which doesn't match. */
13011 return block_may_fallthru (EH_FILTER_FAILURE (tsi_stmt (i)));
13012
13013 default:
13014 /* This case represents statements to be executed when an
13015 exception occurs. Those statements are implicitly followed
13016 by a RESX statement to resume execution after the exception.
13017 So in this case the TRY_CATCH never falls through. */
13018 return false;
13019 }
13020 }
13021
13022 /* Try to determine if we can fall out of the bottom of BLOCK. This guess
13023 need not be 100% accurate; simply be conservative and return true if we
13024 don't know. This is used only to avoid stupidly generating extra code.
13025 If we're wrong, we'll just delete the extra code later. */
13026
13027 bool
13028 block_may_fallthru (const_tree block)
13029 {
13030 /* This CONST_CAST is okay because expr_last returns its argument
13031 unmodified and we assign it to a const_tree. */
13032 const_tree stmt = expr_last (CONST_CAST_TREE (block));
13033
13034 switch (stmt ? TREE_CODE (stmt) : ERROR_MARK)
13035 {
13036 case GOTO_EXPR:
13037 case RETURN_EXPR:
13038 /* Easy cases. If the last statement of the block implies
13039 control transfer, then we can't fall through. */
13040 return false;
13041
13042 case SWITCH_EXPR:
13043 /* If SWITCH_LABELS is set, this is lowered, and represents a
13044 branch to a selected label and hence can not fall through.
13045 Otherwise SWITCH_BODY is set, and the switch can fall
13046 through. */
13047 return SWITCH_LABELS (stmt) == NULL_TREE;
13048
13049 case COND_EXPR:
13050 if (block_may_fallthru (COND_EXPR_THEN (stmt)))
13051 return true;
13052 return block_may_fallthru (COND_EXPR_ELSE (stmt));
13053
13054 case BIND_EXPR:
13055 return block_may_fallthru (BIND_EXPR_BODY (stmt));
13056
13057 case TRY_CATCH_EXPR:
13058 return try_catch_may_fallthru (stmt);
13059
13060 case TRY_FINALLY_EXPR:
13061 /* The finally clause is always executed after the try clause,
13062 so if it does not fall through, then the try-finally will not
13063 fall through. Otherwise, if the try clause does not fall
13064 through, then when the finally clause falls through it will
13065 resume execution wherever the try clause was going. So the
13066 whole try-finally will only fall through if both the try
13067 clause and the finally clause fall through. */
13068 return (block_may_fallthru (TREE_OPERAND (stmt, 0))
13069 && block_may_fallthru (TREE_OPERAND (stmt, 1)));
13070
13071 case MODIFY_EXPR:
13072 if (TREE_CODE (TREE_OPERAND (stmt, 1)) == CALL_EXPR)
13073 stmt = TREE_OPERAND (stmt, 1);
13074 else
13075 return true;
13076 /* FALLTHRU */
13077
13078 case CALL_EXPR:
13079 /* Functions that do not return do not fall through. */
13080 return (call_expr_flags (stmt) & ECF_NORETURN) == 0;
13081
13082 case CLEANUP_POINT_EXPR:
13083 return block_may_fallthru (TREE_OPERAND (stmt, 0));
13084
13085 case TARGET_EXPR:
13086 return block_may_fallthru (TREE_OPERAND (stmt, 1));
13087
13088 case ERROR_MARK:
13089 return true;
13090
13091 default:
13092 return lang_hooks.block_may_fallthru (stmt);
13093 }
13094 }
13095
13096 /* True if we are using EH to handle cleanups. */
13097 static bool using_eh_for_cleanups_flag = false;
13098
13099 /* This routine is called from front ends to indicate eh should be used for
13100 cleanups. */
13101 void
13102 using_eh_for_cleanups (void)
13103 {
13104 using_eh_for_cleanups_flag = true;
13105 }
13106
13107 /* Query whether EH is used for cleanups. */
13108 bool
13109 using_eh_for_cleanups_p (void)
13110 {
13111 return using_eh_for_cleanups_flag;
13112 }
13113
13114 /* Wrapper for tree_code_name to ensure that tree code is valid */
13115 const char *
13116 get_tree_code_name (enum tree_code code)
13117 {
13118 const char *invalid = "<invalid tree code>";
13119
13120 if (code >= MAX_TREE_CODES)
13121 return invalid;
13122
13123 return tree_code_name[code];
13124 }
13125
13126 /* Drops the TREE_OVERFLOW flag from T. */
13127
13128 tree
13129 drop_tree_overflow (tree t)
13130 {
13131 gcc_checking_assert (TREE_OVERFLOW (t));
13132
13133 /* For tree codes with a sharing machinery re-build the result. */
13134 if (TREE_CODE (t) == INTEGER_CST)
13135 return wide_int_to_tree (TREE_TYPE (t), t);
13136
13137 /* Otherwise, as all tcc_constants are possibly shared, copy the node
13138 and drop the flag. */
13139 t = copy_node (t);
13140 TREE_OVERFLOW (t) = 0;
13141 return t;
13142 }
13143
13144 /* Given a memory reference expression T, return its base address.
13145 The base address of a memory reference expression is the main
13146 object being referenced. For instance, the base address for
13147 'array[i].fld[j]' is 'array'. You can think of this as stripping
13148 away the offset part from a memory address.
13149
13150 This function calls handled_component_p to strip away all the inner
13151 parts of the memory reference until it reaches the base object. */
13152
13153 tree
13154 get_base_address (tree t)
13155 {
13156 while (handled_component_p (t))
13157 t = TREE_OPERAND (t, 0);
13158
13159 if ((TREE_CODE (t) == MEM_REF
13160 || TREE_CODE (t) == TARGET_MEM_REF)
13161 && TREE_CODE (TREE_OPERAND (t, 0)) == ADDR_EXPR)
13162 t = TREE_OPERAND (TREE_OPERAND (t, 0), 0);
13163
13164 /* ??? Either the alias oracle or all callers need to properly deal
13165 with WITH_SIZE_EXPRs before we can look through those. */
13166 if (TREE_CODE (t) == WITH_SIZE_EXPR)
13167 return NULL_TREE;
13168
13169 return t;
13170 }
13171
13172 /* Return a tree of sizetype representing the size, in bytes, of the element
13173 of EXP, an ARRAY_REF or an ARRAY_RANGE_REF. */
13174
13175 tree
13176 array_ref_element_size (tree exp)
13177 {
13178 tree aligned_size = TREE_OPERAND (exp, 3);
13179 tree elmt_type = TREE_TYPE (TREE_TYPE (TREE_OPERAND (exp, 0)));
13180 location_t loc = EXPR_LOCATION (exp);
13181
13182 /* If a size was specified in the ARRAY_REF, it's the size measured
13183 in alignment units of the element type. So multiply by that value. */
13184 if (aligned_size)
13185 {
13186 /* ??? tree_ssa_useless_type_conversion will eliminate casts to
13187 sizetype from another type of the same width and signedness. */
13188 if (TREE_TYPE (aligned_size) != sizetype)
13189 aligned_size = fold_convert_loc (loc, sizetype, aligned_size);
13190 return size_binop_loc (loc, MULT_EXPR, aligned_size,
13191 size_int (TYPE_ALIGN_UNIT (elmt_type)));
13192 }
13193
13194 /* Otherwise, take the size from that of the element type. Substitute
13195 any PLACEHOLDER_EXPR that we have. */
13196 else
13197 return SUBSTITUTE_PLACEHOLDER_IN_EXPR (TYPE_SIZE_UNIT (elmt_type), exp);
13198 }
13199
13200 /* Return a tree representing the lower bound of the array mentioned in
13201 EXP, an ARRAY_REF or an ARRAY_RANGE_REF. */
13202
13203 tree
13204 array_ref_low_bound (tree exp)
13205 {
13206 tree domain_type = TYPE_DOMAIN (TREE_TYPE (TREE_OPERAND (exp, 0)));
13207
13208 /* If a lower bound is specified in EXP, use it. */
13209 if (TREE_OPERAND (exp, 2))
13210 return TREE_OPERAND (exp, 2);
13211
13212 /* Otherwise, if there is a domain type and it has a lower bound, use it,
13213 substituting for a PLACEHOLDER_EXPR as needed. */
13214 if (domain_type && TYPE_MIN_VALUE (domain_type))
13215 return SUBSTITUTE_PLACEHOLDER_IN_EXPR (TYPE_MIN_VALUE (domain_type), exp);
13216
13217 /* Otherwise, return a zero of the appropriate type. */
13218 return build_int_cst (TREE_TYPE (TREE_OPERAND (exp, 1)), 0);
13219 }
13220
13221 /* Return a tree representing the upper bound of the array mentioned in
13222 EXP, an ARRAY_REF or an ARRAY_RANGE_REF. */
13223
13224 tree
13225 array_ref_up_bound (tree exp)
13226 {
13227 tree domain_type = TYPE_DOMAIN (TREE_TYPE (TREE_OPERAND (exp, 0)));
13228
13229 /* If there is a domain type and it has an upper bound, use it, substituting
13230 for a PLACEHOLDER_EXPR as needed. */
13231 if (domain_type && TYPE_MAX_VALUE (domain_type))
13232 return SUBSTITUTE_PLACEHOLDER_IN_EXPR (TYPE_MAX_VALUE (domain_type), exp);
13233
13234 /* Otherwise fail. */
13235 return NULL_TREE;
13236 }
13237
13238 /* Returns true if REF is an array reference or a component reference
13239 to an array at the end of a structure.
13240 If this is the case, the array may be allocated larger
13241 than its upper bound implies. */
13242
13243 bool
13244 array_at_struct_end_p (tree ref)
13245 {
13246 tree atype;
13247
13248 if (TREE_CODE (ref) == ARRAY_REF
13249 || TREE_CODE (ref) == ARRAY_RANGE_REF)
13250 {
13251 atype = TREE_TYPE (TREE_OPERAND (ref, 0));
13252 ref = TREE_OPERAND (ref, 0);
13253 }
13254 else if (TREE_CODE (ref) == COMPONENT_REF
13255 && TREE_CODE (TREE_TYPE (TREE_OPERAND (ref, 1))) == ARRAY_TYPE)
13256 atype = TREE_TYPE (TREE_OPERAND (ref, 1));
13257 else
13258 return false;
13259
13260 while (handled_component_p (ref))
13261 {
13262 /* If the reference chain contains a component reference to a
13263 non-union type and there follows another field the reference
13264 is not at the end of a structure. */
13265 if (TREE_CODE (ref) == COMPONENT_REF)
13266 {
13267 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (ref, 0))) == RECORD_TYPE)
13268 {
13269 tree nextf = DECL_CHAIN (TREE_OPERAND (ref, 1));
13270 while (nextf && TREE_CODE (nextf) != FIELD_DECL)
13271 nextf = DECL_CHAIN (nextf);
13272 if (nextf)
13273 return false;
13274 }
13275 }
13276 /* If we have a multi-dimensional array we do not consider
13277 a non-innermost dimension as flex array if the whole
13278 multi-dimensional array is at struct end.
13279 Same for an array of aggregates with a trailing array
13280 member. */
13281 else if (TREE_CODE (ref) == ARRAY_REF)
13282 return false;
13283 else if (TREE_CODE (ref) == ARRAY_RANGE_REF)
13284 ;
13285 /* If we view an underlying object as sth else then what we
13286 gathered up to now is what we have to rely on. */
13287 else if (TREE_CODE (ref) == VIEW_CONVERT_EXPR)
13288 break;
13289 else
13290 gcc_unreachable ();
13291
13292 ref = TREE_OPERAND (ref, 0);
13293 }
13294
13295 /* The array now is at struct end. Treat flexible arrays as
13296 always subject to extend, even into just padding constrained by
13297 an underlying decl. */
13298 if (! TYPE_SIZE (atype))
13299 return true;
13300
13301 tree size = NULL;
13302
13303 if (TREE_CODE (ref) == MEM_REF
13304 && TREE_CODE (TREE_OPERAND (ref, 0)) == ADDR_EXPR)
13305 {
13306 size = TYPE_SIZE (TREE_TYPE (ref));
13307 ref = TREE_OPERAND (TREE_OPERAND (ref, 0), 0);
13308 }
13309
13310 /* If the reference is based on a declared entity, the size of the array
13311 is constrained by its given domain. (Do not trust commons PR/69368). */
13312 if (DECL_P (ref)
13313 /* Be sure the size of MEM_REF target match. For example:
13314
13315 char buf[10];
13316 struct foo *str = (struct foo *)&buf;
13317
13318 str->trailin_array[2] = 1;
13319
13320 is valid because BUF allocate enough space. */
13321
13322 && (!size || (DECL_SIZE (ref) != NULL
13323 && operand_equal_p (DECL_SIZE (ref), size, 0)))
13324 && !(flag_unconstrained_commons
13325 && VAR_P (ref) && DECL_COMMON (ref)))
13326 return false;
13327
13328 return true;
13329 }
13330
13331 /* Return a tree representing the offset, in bytes, of the field referenced
13332 by EXP. This does not include any offset in DECL_FIELD_BIT_OFFSET. */
13333
13334 tree
13335 component_ref_field_offset (tree exp)
13336 {
13337 tree aligned_offset = TREE_OPERAND (exp, 2);
13338 tree field = TREE_OPERAND (exp, 1);
13339 location_t loc = EXPR_LOCATION (exp);
13340
13341 /* If an offset was specified in the COMPONENT_REF, it's the offset measured
13342 in units of DECL_OFFSET_ALIGN / BITS_PER_UNIT. So multiply by that
13343 value. */
13344 if (aligned_offset)
13345 {
13346 /* ??? tree_ssa_useless_type_conversion will eliminate casts to
13347 sizetype from another type of the same width and signedness. */
13348 if (TREE_TYPE (aligned_offset) != sizetype)
13349 aligned_offset = fold_convert_loc (loc, sizetype, aligned_offset);
13350 return size_binop_loc (loc, MULT_EXPR, aligned_offset,
13351 size_int (DECL_OFFSET_ALIGN (field)
13352 / BITS_PER_UNIT));
13353 }
13354
13355 /* Otherwise, take the offset from that of the field. Substitute
13356 any PLACEHOLDER_EXPR that we have. */
13357 else
13358 return SUBSTITUTE_PLACEHOLDER_IN_EXPR (DECL_FIELD_OFFSET (field), exp);
13359 }
13360
13361 /* Return the machine mode of T. For vectors, returns the mode of the
13362 inner type. The main use case is to feed the result to HONOR_NANS,
13363 avoiding the BLKmode that a direct TYPE_MODE (T) might return. */
13364
13365 machine_mode
13366 element_mode (const_tree t)
13367 {
13368 if (!TYPE_P (t))
13369 t = TREE_TYPE (t);
13370 if (VECTOR_TYPE_P (t) || TREE_CODE (t) == COMPLEX_TYPE)
13371 t = TREE_TYPE (t);
13372 return TYPE_MODE (t);
13373 }
13374
13375
13376 /* Veirfy that basic properties of T match TV and thus T can be a variant of
13377 TV. TV should be the more specified variant (i.e. the main variant). */
13378
13379 static bool
13380 verify_type_variant (const_tree t, tree tv)
13381 {
13382 /* Type variant can differ by:
13383
13384 - TYPE_QUALS: TYPE_READONLY, TYPE_VOLATILE, TYPE_ATOMIC, TYPE_RESTRICT,
13385 ENCODE_QUAL_ADDR_SPACE.
13386 - main variant may be TYPE_COMPLETE_P and variant types !TYPE_COMPLETE_P
13387 in this case some values may not be set in the variant types
13388 (see TYPE_COMPLETE_P checks).
13389 - it is possible to have TYPE_ARTIFICIAL variant of non-artifical type
13390 - by TYPE_NAME and attributes (i.e. when variant originate by typedef)
13391 - TYPE_CANONICAL (TYPE_ALIAS_SET is the same among variants)
13392 - by the alignment: TYPE_ALIGN and TYPE_USER_ALIGN
13393 - during LTO by TYPE_CONTEXT if type is TYPE_FILE_SCOPE_P
13394 this is necessary to make it possible to merge types form different TUs
13395 - arrays, pointers and references may have TREE_TYPE that is a variant
13396 of TREE_TYPE of their main variants.
13397 - aggregates may have new TYPE_FIELDS list that list variants of
13398 the main variant TYPE_FIELDS.
13399 - vector types may differ by TYPE_VECTOR_OPAQUE
13400 - TYPE_METHODS is always NULL for variant types and maintained for
13401 main variant only.
13402 */
13403
13404 /* Convenience macro for matching individual fields. */
13405 #define verify_variant_match(flag) \
13406 do { \
13407 if (flag (tv) != flag (t)) \
13408 { \
13409 error ("type variant differs by " #flag "."); \
13410 debug_tree (tv); \
13411 return false; \
13412 } \
13413 } while (false)
13414
13415 /* tree_base checks. */
13416
13417 verify_variant_match (TREE_CODE);
13418 /* FIXME: Ada builds non-artificial variants of artificial types. */
13419 if (TYPE_ARTIFICIAL (tv) && 0)
13420 verify_variant_match (TYPE_ARTIFICIAL);
13421 if (POINTER_TYPE_P (tv))
13422 verify_variant_match (TYPE_REF_CAN_ALIAS_ALL);
13423 /* FIXME: TYPE_SIZES_GIMPLIFIED may differs for Ada build. */
13424 verify_variant_match (TYPE_UNSIGNED);
13425 verify_variant_match (TYPE_PACKED);
13426 if (TREE_CODE (t) == REFERENCE_TYPE)
13427 verify_variant_match (TYPE_REF_IS_RVALUE);
13428 if (AGGREGATE_TYPE_P (t))
13429 verify_variant_match (TYPE_REVERSE_STORAGE_ORDER);
13430 else
13431 verify_variant_match (TYPE_SATURATING);
13432 /* FIXME: This check trigger during libstdc++ build. */
13433 if (RECORD_OR_UNION_TYPE_P (t) && COMPLETE_TYPE_P (t) && 0)
13434 verify_variant_match (TYPE_FINAL_P);
13435
13436 /* tree_type_common checks. */
13437
13438 if (COMPLETE_TYPE_P (t))
13439 {
13440 verify_variant_match (TYPE_MODE);
13441 if (TREE_CODE (TYPE_SIZE (t)) != PLACEHOLDER_EXPR
13442 && TREE_CODE (TYPE_SIZE (tv)) != PLACEHOLDER_EXPR)
13443 verify_variant_match (TYPE_SIZE);
13444 if (TREE_CODE (TYPE_SIZE_UNIT (t)) != PLACEHOLDER_EXPR
13445 && TREE_CODE (TYPE_SIZE_UNIT (tv)) != PLACEHOLDER_EXPR
13446 && TYPE_SIZE_UNIT (t) != TYPE_SIZE_UNIT (tv))
13447 {
13448 gcc_assert (!operand_equal_p (TYPE_SIZE_UNIT (t),
13449 TYPE_SIZE_UNIT (tv), 0));
13450 error ("type variant has different TYPE_SIZE_UNIT");
13451 debug_tree (tv);
13452 error ("type variant's TYPE_SIZE_UNIT");
13453 debug_tree (TYPE_SIZE_UNIT (tv));
13454 error ("type's TYPE_SIZE_UNIT");
13455 debug_tree (TYPE_SIZE_UNIT (t));
13456 return false;
13457 }
13458 }
13459 verify_variant_match (TYPE_PRECISION);
13460 verify_variant_match (TYPE_NEEDS_CONSTRUCTING);
13461 if (RECORD_OR_UNION_TYPE_P (t))
13462 verify_variant_match (TYPE_TRANSPARENT_AGGR);
13463 else if (TREE_CODE (t) == ARRAY_TYPE)
13464 verify_variant_match (TYPE_NONALIASED_COMPONENT);
13465 /* During LTO we merge variant lists from diferent translation units
13466 that may differ BY TYPE_CONTEXT that in turn may point
13467 to TRANSLATION_UNIT_DECL.
13468 Ada also builds variants of types with different TYPE_CONTEXT. */
13469 if ((!in_lto_p || !TYPE_FILE_SCOPE_P (t)) && 0)
13470 verify_variant_match (TYPE_CONTEXT);
13471 verify_variant_match (TYPE_STRING_FLAG);
13472 if (TYPE_ALIAS_SET_KNOWN_P (t))
13473 {
13474 error ("type variant with TYPE_ALIAS_SET_KNOWN_P");
13475 debug_tree (tv);
13476 return false;
13477 }
13478
13479 /* tree_type_non_common checks. */
13480
13481 /* FIXME: C FE uses TYPE_VFIELD to record C_TYPE_INCOMPLETE_VARS
13482 and dangle the pointer from time to time. */
13483 if (RECORD_OR_UNION_TYPE_P (t) && TYPE_VFIELD (t) != TYPE_VFIELD (tv)
13484 && (in_lto_p || !TYPE_VFIELD (tv)
13485 || TREE_CODE (TYPE_VFIELD (tv)) != TREE_LIST))
13486 {
13487 error ("type variant has different TYPE_VFIELD");
13488 debug_tree (tv);
13489 return false;
13490 }
13491 if ((TREE_CODE (t) == ENUMERAL_TYPE && COMPLETE_TYPE_P (t))
13492 || TREE_CODE (t) == INTEGER_TYPE
13493 || TREE_CODE (t) == BOOLEAN_TYPE
13494 || TREE_CODE (t) == REAL_TYPE
13495 || TREE_CODE (t) == FIXED_POINT_TYPE)
13496 {
13497 verify_variant_match (TYPE_MAX_VALUE);
13498 verify_variant_match (TYPE_MIN_VALUE);
13499 }
13500 if (TREE_CODE (t) == METHOD_TYPE)
13501 verify_variant_match (TYPE_METHOD_BASETYPE);
13502 if (RECORD_OR_UNION_TYPE_P (t) && TYPE_METHODS (t))
13503 {
13504 error ("type variant has TYPE_METHODS");
13505 debug_tree (tv);
13506 return false;
13507 }
13508 if (TREE_CODE (t) == OFFSET_TYPE)
13509 verify_variant_match (TYPE_OFFSET_BASETYPE);
13510 if (TREE_CODE (t) == ARRAY_TYPE)
13511 verify_variant_match (TYPE_ARRAY_MAX_SIZE);
13512 /* FIXME: Be lax and allow TYPE_BINFO to be missing in variant types
13513 or even type's main variant. This is needed to make bootstrap pass
13514 and the bug seems new in GCC 5.
13515 C++ FE should be updated to make this consistent and we should check
13516 that TYPE_BINFO is always NULL for !COMPLETE_TYPE_P and otherwise there
13517 is a match with main variant.
13518
13519 Also disable the check for Java for now because of parser hack that builds
13520 first an dummy BINFO and then sometimes replace it by real BINFO in some
13521 of the copies. */
13522 if (RECORD_OR_UNION_TYPE_P (t) && TYPE_BINFO (t) && TYPE_BINFO (tv)
13523 && TYPE_BINFO (t) != TYPE_BINFO (tv)
13524 /* FIXME: Java sometimes keep dump TYPE_BINFOs on variant types.
13525 Since there is no cheap way to tell C++/Java type w/o LTO, do checking
13526 at LTO time only. */
13527 && (in_lto_p && odr_type_p (t)))
13528 {
13529 error ("type variant has different TYPE_BINFO");
13530 debug_tree (tv);
13531 error ("type variant's TYPE_BINFO");
13532 debug_tree (TYPE_BINFO (tv));
13533 error ("type's TYPE_BINFO");
13534 debug_tree (TYPE_BINFO (t));
13535 return false;
13536 }
13537
13538 /* Check various uses of TYPE_VALUES_RAW. */
13539 if (TREE_CODE (t) == ENUMERAL_TYPE)
13540 verify_variant_match (TYPE_VALUES);
13541 else if (TREE_CODE (t) == ARRAY_TYPE)
13542 verify_variant_match (TYPE_DOMAIN);
13543 /* Permit incomplete variants of complete type. While FEs may complete
13544 all variants, this does not happen for C++ templates in all cases. */
13545 else if (RECORD_OR_UNION_TYPE_P (t)
13546 && COMPLETE_TYPE_P (t)
13547 && TYPE_FIELDS (t) != TYPE_FIELDS (tv))
13548 {
13549 tree f1, f2;
13550
13551 /* Fortran builds qualified variants as new records with items of
13552 qualified type. Verify that they looks same. */
13553 for (f1 = TYPE_FIELDS (t), f2 = TYPE_FIELDS (tv);
13554 f1 && f2;
13555 f1 = TREE_CHAIN (f1), f2 = TREE_CHAIN (f2))
13556 if (TREE_CODE (f1) != FIELD_DECL || TREE_CODE (f2) != FIELD_DECL
13557 || (TYPE_MAIN_VARIANT (TREE_TYPE (f1))
13558 != TYPE_MAIN_VARIANT (TREE_TYPE (f2))
13559 /* FIXME: gfc_nonrestricted_type builds all types as variants
13560 with exception of pointer types. It deeply copies the type
13561 which means that we may end up with a variant type
13562 referring non-variant pointer. We may change it to
13563 produce types as variants, too, like
13564 objc_get_protocol_qualified_type does. */
13565 && !POINTER_TYPE_P (TREE_TYPE (f1)))
13566 || DECL_FIELD_OFFSET (f1) != DECL_FIELD_OFFSET (f2)
13567 || DECL_FIELD_BIT_OFFSET (f1) != DECL_FIELD_BIT_OFFSET (f2))
13568 break;
13569 if (f1 || f2)
13570 {
13571 error ("type variant has different TYPE_FIELDS");
13572 debug_tree (tv);
13573 error ("first mismatch is field");
13574 debug_tree (f1);
13575 error ("and field");
13576 debug_tree (f2);
13577 return false;
13578 }
13579 }
13580 else if ((TREE_CODE (t) == FUNCTION_TYPE || TREE_CODE (t) == METHOD_TYPE))
13581 verify_variant_match (TYPE_ARG_TYPES);
13582 /* For C++ the qualified variant of array type is really an array type
13583 of qualified TREE_TYPE.
13584 objc builds variants of pointer where pointer to type is a variant, too
13585 in objc_get_protocol_qualified_type. */
13586 if (TREE_TYPE (t) != TREE_TYPE (tv)
13587 && ((TREE_CODE (t) != ARRAY_TYPE
13588 && !POINTER_TYPE_P (t))
13589 || TYPE_MAIN_VARIANT (TREE_TYPE (t))
13590 != TYPE_MAIN_VARIANT (TREE_TYPE (tv))))
13591 {
13592 error ("type variant has different TREE_TYPE");
13593 debug_tree (tv);
13594 error ("type variant's TREE_TYPE");
13595 debug_tree (TREE_TYPE (tv));
13596 error ("type's TREE_TYPE");
13597 debug_tree (TREE_TYPE (t));
13598 return false;
13599 }
13600 if (type_with_alias_set_p (t)
13601 && !gimple_canonical_types_compatible_p (t, tv, false))
13602 {
13603 error ("type is not compatible with its variant");
13604 debug_tree (tv);
13605 error ("type variant's TREE_TYPE");
13606 debug_tree (TREE_TYPE (tv));
13607 error ("type's TREE_TYPE");
13608 debug_tree (TREE_TYPE (t));
13609 return false;
13610 }
13611 return true;
13612 #undef verify_variant_match
13613 }
13614
13615
13616 /* The TYPE_CANONICAL merging machinery. It should closely resemble
13617 the middle-end types_compatible_p function. It needs to avoid
13618 claiming types are different for types that should be treated
13619 the same with respect to TBAA. Canonical types are also used
13620 for IL consistency checks via the useless_type_conversion_p
13621 predicate which does not handle all type kinds itself but falls
13622 back to pointer-comparison of TYPE_CANONICAL for aggregates
13623 for example. */
13624
13625 /* Return true if TYPE_UNSIGNED of TYPE should be ignored for canonical
13626 type calculation because we need to allow inter-operability between signed
13627 and unsigned variants. */
13628
13629 bool
13630 type_with_interoperable_signedness (const_tree type)
13631 {
13632 /* Fortran standard require C_SIGNED_CHAR to be interoperable with both
13633 signed char and unsigned char. Similarly fortran FE builds
13634 C_SIZE_T as signed type, while C defines it unsigned. */
13635
13636 return tree_code_for_canonical_type_merging (TREE_CODE (type))
13637 == INTEGER_TYPE
13638 && (TYPE_PRECISION (type) == TYPE_PRECISION (signed_char_type_node)
13639 || TYPE_PRECISION (type) == TYPE_PRECISION (size_type_node));
13640 }
13641
13642 /* Return true iff T1 and T2 are structurally identical for what
13643 TBAA is concerned.
13644 This function is used both by lto.c canonical type merging and by the
13645 verifier. If TRUST_TYPE_CANONICAL we do not look into structure of types
13646 that have TYPE_CANONICAL defined and assume them equivalent. This is useful
13647 only for LTO because only in these cases TYPE_CANONICAL equivalence
13648 correspond to one defined by gimple_canonical_types_compatible_p. */
13649
13650 bool
13651 gimple_canonical_types_compatible_p (const_tree t1, const_tree t2,
13652 bool trust_type_canonical)
13653 {
13654 /* Type variants should be same as the main variant. When not doing sanity
13655 checking to verify this fact, go to main variants and save some work. */
13656 if (trust_type_canonical)
13657 {
13658 t1 = TYPE_MAIN_VARIANT (t1);
13659 t2 = TYPE_MAIN_VARIANT (t2);
13660 }
13661
13662 /* Check first for the obvious case of pointer identity. */
13663 if (t1 == t2)
13664 return true;
13665
13666 /* Check that we have two types to compare. */
13667 if (t1 == NULL_TREE || t2 == NULL_TREE)
13668 return false;
13669
13670 /* We consider complete types always compatible with incomplete type.
13671 This does not make sense for canonical type calculation and thus we
13672 need to ensure that we are never called on it.
13673
13674 FIXME: For more correctness the function probably should have three modes
13675 1) mode assuming that types are complete mathcing their structure
13676 2) mode allowing incomplete types but producing equivalence classes
13677 and thus ignoring all info from complete types
13678 3) mode allowing incomplete types to match complete but checking
13679 compatibility between complete types.
13680
13681 1 and 2 can be used for canonical type calculation. 3 is the real
13682 definition of type compatibility that can be used i.e. for warnings during
13683 declaration merging. */
13684
13685 gcc_assert (!trust_type_canonical
13686 || (type_with_alias_set_p (t1) && type_with_alias_set_p (t2)));
13687 /* If the types have been previously registered and found equal
13688 they still are. */
13689
13690 if (TYPE_CANONICAL (t1) && TYPE_CANONICAL (t2)
13691 && trust_type_canonical)
13692 {
13693 /* Do not use TYPE_CANONICAL of pointer types. For LTO streamed types
13694 they are always NULL, but they are set to non-NULL for types
13695 constructed by build_pointer_type and variants. In this case the
13696 TYPE_CANONICAL is more fine grained than the equivalnce we test (where
13697 all pointers are considered equal. Be sure to not return false
13698 negatives. */
13699 gcc_checking_assert (canonical_type_used_p (t1)
13700 && canonical_type_used_p (t2));
13701 return TYPE_CANONICAL (t1) == TYPE_CANONICAL (t2);
13702 }
13703
13704 /* Can't be the same type if the types don't have the same code. */
13705 enum tree_code code = tree_code_for_canonical_type_merging (TREE_CODE (t1));
13706 if (code != tree_code_for_canonical_type_merging (TREE_CODE (t2)))
13707 return false;
13708
13709 /* Qualifiers do not matter for canonical type comparison purposes. */
13710
13711 /* Void types and nullptr types are always the same. */
13712 if (TREE_CODE (t1) == VOID_TYPE
13713 || TREE_CODE (t1) == NULLPTR_TYPE)
13714 return true;
13715
13716 /* Can't be the same type if they have different mode. */
13717 if (TYPE_MODE (t1) != TYPE_MODE (t2))
13718 return false;
13719
13720 /* Non-aggregate types can be handled cheaply. */
13721 if (INTEGRAL_TYPE_P (t1)
13722 || SCALAR_FLOAT_TYPE_P (t1)
13723 || FIXED_POINT_TYPE_P (t1)
13724 || TREE_CODE (t1) == VECTOR_TYPE
13725 || TREE_CODE (t1) == COMPLEX_TYPE
13726 || TREE_CODE (t1) == OFFSET_TYPE
13727 || POINTER_TYPE_P (t1))
13728 {
13729 /* Can't be the same type if they have different recision. */
13730 if (TYPE_PRECISION (t1) != TYPE_PRECISION (t2))
13731 return false;
13732
13733 /* In some cases the signed and unsigned types are required to be
13734 inter-operable. */
13735 if (TYPE_UNSIGNED (t1) != TYPE_UNSIGNED (t2)
13736 && !type_with_interoperable_signedness (t1))
13737 return false;
13738
13739 /* Fortran's C_SIGNED_CHAR is !TYPE_STRING_FLAG but needs to be
13740 interoperable with "signed char". Unless all frontends are revisited
13741 to agree on these types, we must ignore the flag completely. */
13742
13743 /* Fortran standard define C_PTR type that is compatible with every
13744 C pointer. For this reason we need to glob all pointers into one.
13745 Still pointers in different address spaces are not compatible. */
13746 if (POINTER_TYPE_P (t1))
13747 {
13748 if (TYPE_ADDR_SPACE (TREE_TYPE (t1))
13749 != TYPE_ADDR_SPACE (TREE_TYPE (t2)))
13750 return false;
13751 }
13752
13753 /* Tail-recurse to components. */
13754 if (TREE_CODE (t1) == VECTOR_TYPE
13755 || TREE_CODE (t1) == COMPLEX_TYPE)
13756 return gimple_canonical_types_compatible_p (TREE_TYPE (t1),
13757 TREE_TYPE (t2),
13758 trust_type_canonical);
13759
13760 return true;
13761 }
13762
13763 /* Do type-specific comparisons. */
13764 switch (TREE_CODE (t1))
13765 {
13766 case ARRAY_TYPE:
13767 /* Array types are the same if the element types are the same and
13768 the number of elements are the same. */
13769 if (!gimple_canonical_types_compatible_p (TREE_TYPE (t1), TREE_TYPE (t2),
13770 trust_type_canonical)
13771 || TYPE_STRING_FLAG (t1) != TYPE_STRING_FLAG (t2)
13772 || TYPE_REVERSE_STORAGE_ORDER (t1) != TYPE_REVERSE_STORAGE_ORDER (t2)
13773 || TYPE_NONALIASED_COMPONENT (t1) != TYPE_NONALIASED_COMPONENT (t2))
13774 return false;
13775 else
13776 {
13777 tree i1 = TYPE_DOMAIN (t1);
13778 tree i2 = TYPE_DOMAIN (t2);
13779
13780 /* For an incomplete external array, the type domain can be
13781 NULL_TREE. Check this condition also. */
13782 if (i1 == NULL_TREE && i2 == NULL_TREE)
13783 return true;
13784 else if (i1 == NULL_TREE || i2 == NULL_TREE)
13785 return false;
13786 else
13787 {
13788 tree min1 = TYPE_MIN_VALUE (i1);
13789 tree min2 = TYPE_MIN_VALUE (i2);
13790 tree max1 = TYPE_MAX_VALUE (i1);
13791 tree max2 = TYPE_MAX_VALUE (i2);
13792
13793 /* The minimum/maximum values have to be the same. */
13794 if ((min1 == min2
13795 || (min1 && min2
13796 && ((TREE_CODE (min1) == PLACEHOLDER_EXPR
13797 && TREE_CODE (min2) == PLACEHOLDER_EXPR)
13798 || operand_equal_p (min1, min2, 0))))
13799 && (max1 == max2
13800 || (max1 && max2
13801 && ((TREE_CODE (max1) == PLACEHOLDER_EXPR
13802 && TREE_CODE (max2) == PLACEHOLDER_EXPR)
13803 || operand_equal_p (max1, max2, 0)))))
13804 return true;
13805 else
13806 return false;
13807 }
13808 }
13809
13810 case METHOD_TYPE:
13811 case FUNCTION_TYPE:
13812 /* Function types are the same if the return type and arguments types
13813 are the same. */
13814 if (!gimple_canonical_types_compatible_p (TREE_TYPE (t1), TREE_TYPE (t2),
13815 trust_type_canonical))
13816 return false;
13817
13818 if (TYPE_ARG_TYPES (t1) == TYPE_ARG_TYPES (t2))
13819 return true;
13820 else
13821 {
13822 tree parms1, parms2;
13823
13824 for (parms1 = TYPE_ARG_TYPES (t1), parms2 = TYPE_ARG_TYPES (t2);
13825 parms1 && parms2;
13826 parms1 = TREE_CHAIN (parms1), parms2 = TREE_CHAIN (parms2))
13827 {
13828 if (!gimple_canonical_types_compatible_p
13829 (TREE_VALUE (parms1), TREE_VALUE (parms2),
13830 trust_type_canonical))
13831 return false;
13832 }
13833
13834 if (parms1 || parms2)
13835 return false;
13836
13837 return true;
13838 }
13839
13840 case RECORD_TYPE:
13841 case UNION_TYPE:
13842 case QUAL_UNION_TYPE:
13843 {
13844 tree f1, f2;
13845
13846 /* Don't try to compare variants of an incomplete type, before
13847 TYPE_FIELDS has been copied around. */
13848 if (!COMPLETE_TYPE_P (t1) && !COMPLETE_TYPE_P (t2))
13849 return true;
13850
13851
13852 if (TYPE_REVERSE_STORAGE_ORDER (t1) != TYPE_REVERSE_STORAGE_ORDER (t2))
13853 return false;
13854
13855 /* For aggregate types, all the fields must be the same. */
13856 for (f1 = TYPE_FIELDS (t1), f2 = TYPE_FIELDS (t2);
13857 f1 || f2;
13858 f1 = TREE_CHAIN (f1), f2 = TREE_CHAIN (f2))
13859 {
13860 /* Skip non-fields and zero-sized fields. */
13861 while (f1 && (TREE_CODE (f1) != FIELD_DECL
13862 || (DECL_SIZE (f1)
13863 && integer_zerop (DECL_SIZE (f1)))))
13864 f1 = TREE_CHAIN (f1);
13865 while (f2 && (TREE_CODE (f2) != FIELD_DECL
13866 || (DECL_SIZE (f2)
13867 && integer_zerop (DECL_SIZE (f2)))))
13868 f2 = TREE_CHAIN (f2);
13869 if (!f1 || !f2)
13870 break;
13871 /* The fields must have the same name, offset and type. */
13872 if (DECL_NONADDRESSABLE_P (f1) != DECL_NONADDRESSABLE_P (f2)
13873 || !gimple_compare_field_offset (f1, f2)
13874 || !gimple_canonical_types_compatible_p
13875 (TREE_TYPE (f1), TREE_TYPE (f2),
13876 trust_type_canonical))
13877 return false;
13878 }
13879
13880 /* If one aggregate has more fields than the other, they
13881 are not the same. */
13882 if (f1 || f2)
13883 return false;
13884
13885 return true;
13886 }
13887
13888 default:
13889 /* Consider all types with language specific trees in them mutually
13890 compatible. This is executed only from verify_type and false
13891 positives can be tolerated. */
13892 gcc_assert (!in_lto_p);
13893 return true;
13894 }
13895 }
13896
13897 /* Verify type T. */
13898
13899 void
13900 verify_type (const_tree t)
13901 {
13902 bool error_found = false;
13903 tree mv = TYPE_MAIN_VARIANT (t);
13904 if (!mv)
13905 {
13906 error ("Main variant is not defined");
13907 error_found = true;
13908 }
13909 else if (mv != TYPE_MAIN_VARIANT (mv))
13910 {
13911 error ("TYPE_MAIN_VARIANT has different TYPE_MAIN_VARIANT");
13912 debug_tree (mv);
13913 error_found = true;
13914 }
13915 else if (t != mv && !verify_type_variant (t, mv))
13916 error_found = true;
13917
13918 tree ct = TYPE_CANONICAL (t);
13919 if (!ct)
13920 ;
13921 else if (TYPE_CANONICAL (t) != ct)
13922 {
13923 error ("TYPE_CANONICAL has different TYPE_CANONICAL");
13924 debug_tree (ct);
13925 error_found = true;
13926 }
13927 /* Method and function types can not be used to address memory and thus
13928 TYPE_CANONICAL really matters only for determining useless conversions.
13929
13930 FIXME: C++ FE produce declarations of builtin functions that are not
13931 compatible with main variants. */
13932 else if (TREE_CODE (t) == FUNCTION_TYPE)
13933 ;
13934 else if (t != ct
13935 /* FIXME: gimple_canonical_types_compatible_p can not compare types
13936 with variably sized arrays because their sizes possibly
13937 gimplified to different variables. */
13938 && !variably_modified_type_p (ct, NULL)
13939 && !gimple_canonical_types_compatible_p (t, ct, false))
13940 {
13941 error ("TYPE_CANONICAL is not compatible");
13942 debug_tree (ct);
13943 error_found = true;
13944 }
13945
13946 if (COMPLETE_TYPE_P (t) && TYPE_CANONICAL (t)
13947 && TYPE_MODE (t) != TYPE_MODE (TYPE_CANONICAL (t)))
13948 {
13949 error ("TYPE_MODE of TYPE_CANONICAL is not compatible");
13950 debug_tree (ct);
13951 error_found = true;
13952 }
13953 /* FIXME: this is violated by the C++ FE as discussed in PR70029, when
13954 FUNCTION_*_QUALIFIED flags are set. */
13955 if (0 && TYPE_MAIN_VARIANT (t) == t && ct && TYPE_MAIN_VARIANT (ct) != ct)
13956 {
13957 error ("TYPE_CANONICAL of main variant is not main variant");
13958 debug_tree (ct);
13959 debug_tree (TYPE_MAIN_VARIANT (ct));
13960 error_found = true;
13961 }
13962
13963
13964 /* Check various uses of TYPE_MINVAL. */
13965 if (RECORD_OR_UNION_TYPE_P (t))
13966 {
13967 /* FIXME: C FE uses TYPE_VFIELD to record C_TYPE_INCOMPLETE_VARS
13968 and danagle the pointer from time to time. */
13969 if (TYPE_VFIELD (t)
13970 && TREE_CODE (TYPE_VFIELD (t)) != FIELD_DECL
13971 && TREE_CODE (TYPE_VFIELD (t)) != TREE_LIST)
13972 {
13973 error ("TYPE_VFIELD is not FIELD_DECL nor TREE_LIST");
13974 debug_tree (TYPE_VFIELD (t));
13975 error_found = true;
13976 }
13977 }
13978 else if (TREE_CODE (t) == POINTER_TYPE)
13979 {
13980 if (TYPE_NEXT_PTR_TO (t)
13981 && TREE_CODE (TYPE_NEXT_PTR_TO (t)) != POINTER_TYPE)
13982 {
13983 error ("TYPE_NEXT_PTR_TO is not POINTER_TYPE");
13984 debug_tree (TYPE_NEXT_PTR_TO (t));
13985 error_found = true;
13986 }
13987 }
13988 else if (TREE_CODE (t) == REFERENCE_TYPE)
13989 {
13990 if (TYPE_NEXT_REF_TO (t)
13991 && TREE_CODE (TYPE_NEXT_REF_TO (t)) != REFERENCE_TYPE)
13992 {
13993 error ("TYPE_NEXT_REF_TO is not REFERENCE_TYPE");
13994 debug_tree (TYPE_NEXT_REF_TO (t));
13995 error_found = true;
13996 }
13997 }
13998 else if (INTEGRAL_TYPE_P (t) || TREE_CODE (t) == REAL_TYPE
13999 || TREE_CODE (t) == FIXED_POINT_TYPE)
14000 {
14001 /* FIXME: The following check should pass:
14002 useless_type_conversion_p (const_cast <tree> (t),
14003 TREE_TYPE (TYPE_MIN_VALUE (t))
14004 but does not for C sizetypes in LTO. */
14005 }
14006 /* Java uses TYPE_MINVAL for TYPE_ARGUMENT_SIGNATURE. */
14007 else if (TYPE_MINVAL (t)
14008 && ((TREE_CODE (t) != METHOD_TYPE && TREE_CODE (t) != FUNCTION_TYPE)
14009 || in_lto_p))
14010 {
14011 error ("TYPE_MINVAL non-NULL");
14012 debug_tree (TYPE_MINVAL (t));
14013 error_found = true;
14014 }
14015
14016 /* Check various uses of TYPE_MAXVAL. */
14017 if (RECORD_OR_UNION_TYPE_P (t))
14018 {
14019 if (TYPE_METHODS (t) && TREE_CODE (TYPE_METHODS (t)) != FUNCTION_DECL
14020 && TREE_CODE (TYPE_METHODS (t)) != TEMPLATE_DECL
14021 && TYPE_METHODS (t) != error_mark_node)
14022 {
14023 error ("TYPE_METHODS is not FUNCTION_DECL, TEMPLATE_DECL nor error_mark_node");
14024 debug_tree (TYPE_METHODS (t));
14025 error_found = true;
14026 }
14027 }
14028 else if (TREE_CODE (t) == FUNCTION_TYPE || TREE_CODE (t) == METHOD_TYPE)
14029 {
14030 if (TYPE_METHOD_BASETYPE (t)
14031 && TREE_CODE (TYPE_METHOD_BASETYPE (t)) != RECORD_TYPE
14032 && TREE_CODE (TYPE_METHOD_BASETYPE (t)) != UNION_TYPE)
14033 {
14034 error ("TYPE_METHOD_BASETYPE is not record nor union");
14035 debug_tree (TYPE_METHOD_BASETYPE (t));
14036 error_found = true;
14037 }
14038 }
14039 else if (TREE_CODE (t) == OFFSET_TYPE)
14040 {
14041 if (TYPE_OFFSET_BASETYPE (t)
14042 && TREE_CODE (TYPE_OFFSET_BASETYPE (t)) != RECORD_TYPE
14043 && TREE_CODE (TYPE_OFFSET_BASETYPE (t)) != UNION_TYPE)
14044 {
14045 error ("TYPE_OFFSET_BASETYPE is not record nor union");
14046 debug_tree (TYPE_OFFSET_BASETYPE (t));
14047 error_found = true;
14048 }
14049 }
14050 else if (INTEGRAL_TYPE_P (t) || TREE_CODE (t) == REAL_TYPE
14051 || TREE_CODE (t) == FIXED_POINT_TYPE)
14052 {
14053 /* FIXME: The following check should pass:
14054 useless_type_conversion_p (const_cast <tree> (t),
14055 TREE_TYPE (TYPE_MAX_VALUE (t))
14056 but does not for C sizetypes in LTO. */
14057 }
14058 else if (TREE_CODE (t) == ARRAY_TYPE)
14059 {
14060 if (TYPE_ARRAY_MAX_SIZE (t)
14061 && TREE_CODE (TYPE_ARRAY_MAX_SIZE (t)) != INTEGER_CST)
14062 {
14063 error ("TYPE_ARRAY_MAX_SIZE not INTEGER_CST");
14064 debug_tree (TYPE_ARRAY_MAX_SIZE (t));
14065 error_found = true;
14066 }
14067 }
14068 else if (TYPE_MAXVAL (t))
14069 {
14070 error ("TYPE_MAXVAL non-NULL");
14071 debug_tree (TYPE_MAXVAL (t));
14072 error_found = true;
14073 }
14074
14075 /* Check various uses of TYPE_BINFO. */
14076 if (RECORD_OR_UNION_TYPE_P (t))
14077 {
14078 if (!TYPE_BINFO (t))
14079 ;
14080 else if (TREE_CODE (TYPE_BINFO (t)) != TREE_BINFO)
14081 {
14082 error ("TYPE_BINFO is not TREE_BINFO");
14083 debug_tree (TYPE_BINFO (t));
14084 error_found = true;
14085 }
14086 /* FIXME: Java builds invalid empty binfos that do not have
14087 TREE_TYPE set. */
14088 else if (TREE_TYPE (TYPE_BINFO (t)) != TYPE_MAIN_VARIANT (t) && 0)
14089 {
14090 error ("TYPE_BINFO type is not TYPE_MAIN_VARIANT");
14091 debug_tree (TREE_TYPE (TYPE_BINFO (t)));
14092 error_found = true;
14093 }
14094 }
14095 else if (TYPE_LANG_SLOT_1 (t) && in_lto_p)
14096 {
14097 error ("TYPE_LANG_SLOT_1 (binfo) field is non-NULL");
14098 debug_tree (TYPE_LANG_SLOT_1 (t));
14099 error_found = true;
14100 }
14101
14102 /* Check various uses of TYPE_VALUES_RAW. */
14103 if (TREE_CODE (t) == ENUMERAL_TYPE)
14104 for (tree l = TYPE_VALUES (t); l; l = TREE_CHAIN (l))
14105 {
14106 tree value = TREE_VALUE (l);
14107 tree name = TREE_PURPOSE (l);
14108
14109 /* C FE porduce INTEGER_CST of INTEGER_TYPE, while C++ FE uses
14110 CONST_DECL of ENUMERAL TYPE. */
14111 if (TREE_CODE (value) != INTEGER_CST && TREE_CODE (value) != CONST_DECL)
14112 {
14113 error ("Enum value is not CONST_DECL or INTEGER_CST");
14114 debug_tree (value);
14115 debug_tree (name);
14116 error_found = true;
14117 }
14118 if (TREE_CODE (TREE_TYPE (value)) != INTEGER_TYPE
14119 && !useless_type_conversion_p (const_cast <tree> (t), TREE_TYPE (value)))
14120 {
14121 error ("Enum value type is not INTEGER_TYPE nor convertible to the enum");
14122 debug_tree (value);
14123 debug_tree (name);
14124 error_found = true;
14125 }
14126 if (TREE_CODE (name) != IDENTIFIER_NODE)
14127 {
14128 error ("Enum value name is not IDENTIFIER_NODE");
14129 debug_tree (value);
14130 debug_tree (name);
14131 error_found = true;
14132 }
14133 }
14134 else if (TREE_CODE (t) == ARRAY_TYPE)
14135 {
14136 if (TYPE_DOMAIN (t) && TREE_CODE (TYPE_DOMAIN (t)) != INTEGER_TYPE)
14137 {
14138 error ("Array TYPE_DOMAIN is not integer type");
14139 debug_tree (TYPE_DOMAIN (t));
14140 error_found = true;
14141 }
14142 }
14143 else if (RECORD_OR_UNION_TYPE_P (t))
14144 {
14145 if (TYPE_FIELDS (t) && !COMPLETE_TYPE_P (t) && in_lto_p)
14146 {
14147 error ("TYPE_FIELDS defined in incomplete type");
14148 error_found = true;
14149 }
14150 for (tree fld = TYPE_FIELDS (t); fld; fld = TREE_CHAIN (fld))
14151 {
14152 /* TODO: verify properties of decls. */
14153 if (TREE_CODE (fld) == FIELD_DECL)
14154 ;
14155 else if (TREE_CODE (fld) == TYPE_DECL)
14156 ;
14157 else if (TREE_CODE (fld) == CONST_DECL)
14158 ;
14159 else if (VAR_P (fld))
14160 ;
14161 else if (TREE_CODE (fld) == TEMPLATE_DECL)
14162 ;
14163 else if (TREE_CODE (fld) == USING_DECL)
14164 ;
14165 else
14166 {
14167 error ("Wrong tree in TYPE_FIELDS list");
14168 debug_tree (fld);
14169 error_found = true;
14170 }
14171 }
14172 }
14173 else if (TREE_CODE (t) == INTEGER_TYPE
14174 || TREE_CODE (t) == BOOLEAN_TYPE
14175 || TREE_CODE (t) == OFFSET_TYPE
14176 || TREE_CODE (t) == REFERENCE_TYPE
14177 || TREE_CODE (t) == NULLPTR_TYPE
14178 || TREE_CODE (t) == POINTER_TYPE)
14179 {
14180 if (TYPE_CACHED_VALUES_P (t) != (TYPE_CACHED_VALUES (t) != NULL))
14181 {
14182 error ("TYPE_CACHED_VALUES_P is %i while TYPE_CACHED_VALUES is %p",
14183 TYPE_CACHED_VALUES_P (t), (void *)TYPE_CACHED_VALUES (t));
14184 error_found = true;
14185 }
14186 else if (TYPE_CACHED_VALUES_P (t) && TREE_CODE (TYPE_CACHED_VALUES (t)) != TREE_VEC)
14187 {
14188 error ("TYPE_CACHED_VALUES is not TREE_VEC");
14189 debug_tree (TYPE_CACHED_VALUES (t));
14190 error_found = true;
14191 }
14192 /* Verify just enough of cache to ensure that no one copied it to new type.
14193 All copying should go by copy_node that should clear it. */
14194 else if (TYPE_CACHED_VALUES_P (t))
14195 {
14196 int i;
14197 for (i = 0; i < TREE_VEC_LENGTH (TYPE_CACHED_VALUES (t)); i++)
14198 if (TREE_VEC_ELT (TYPE_CACHED_VALUES (t), i)
14199 && TREE_TYPE (TREE_VEC_ELT (TYPE_CACHED_VALUES (t), i)) != t)
14200 {
14201 error ("wrong TYPE_CACHED_VALUES entry");
14202 debug_tree (TREE_VEC_ELT (TYPE_CACHED_VALUES (t), i));
14203 error_found = true;
14204 break;
14205 }
14206 }
14207 }
14208 else if (TREE_CODE (t) == FUNCTION_TYPE || TREE_CODE (t) == METHOD_TYPE)
14209 for (tree l = TYPE_ARG_TYPES (t); l; l = TREE_CHAIN (l))
14210 {
14211 /* C++ FE uses TREE_PURPOSE to store initial values. */
14212 if (TREE_PURPOSE (l) && in_lto_p)
14213 {
14214 error ("TREE_PURPOSE is non-NULL in TYPE_ARG_TYPES list");
14215 debug_tree (l);
14216 error_found = true;
14217 }
14218 if (!TYPE_P (TREE_VALUE (l)))
14219 {
14220 error ("Wrong entry in TYPE_ARG_TYPES list");
14221 debug_tree (l);
14222 error_found = true;
14223 }
14224 }
14225 else if (!is_lang_specific (t) && TYPE_VALUES_RAW (t))
14226 {
14227 error ("TYPE_VALUES_RAW field is non-NULL");
14228 debug_tree (TYPE_VALUES_RAW (t));
14229 error_found = true;
14230 }
14231 if (TREE_CODE (t) != INTEGER_TYPE
14232 && TREE_CODE (t) != BOOLEAN_TYPE
14233 && TREE_CODE (t) != OFFSET_TYPE
14234 && TREE_CODE (t) != REFERENCE_TYPE
14235 && TREE_CODE (t) != NULLPTR_TYPE
14236 && TREE_CODE (t) != POINTER_TYPE
14237 && TYPE_CACHED_VALUES_P (t))
14238 {
14239 error ("TYPE_CACHED_VALUES_P is set while it should not");
14240 error_found = true;
14241 }
14242 if (TYPE_STRING_FLAG (t)
14243 && TREE_CODE (t) != ARRAY_TYPE && TREE_CODE (t) != INTEGER_TYPE)
14244 {
14245 error ("TYPE_STRING_FLAG is set on wrong type code");
14246 error_found = true;
14247 }
14248 else if (TYPE_STRING_FLAG (t))
14249 {
14250 const_tree b = t;
14251 if (TREE_CODE (b) == ARRAY_TYPE)
14252 b = TREE_TYPE (t);
14253 /* Java builds arrays with TYPE_STRING_FLAG of promoted_char_type
14254 that is 32bits. */
14255 if (TREE_CODE (b) != INTEGER_TYPE)
14256 {
14257 error ("TYPE_STRING_FLAG is set on type that does not look like "
14258 "char nor array of chars");
14259 error_found = true;
14260 }
14261 }
14262
14263 /* ipa-devirt makes an assumption that TYPE_METHOD_BASETYPE is always
14264 TYPE_MAIN_VARIANT and it would be odd to add methods only to variatns
14265 of a type. */
14266 if (TREE_CODE (t) == METHOD_TYPE
14267 && TYPE_MAIN_VARIANT (TYPE_METHOD_BASETYPE (t)) != TYPE_METHOD_BASETYPE (t))
14268 {
14269 error ("TYPE_METHOD_BASETYPE is not main variant");
14270 error_found = true;
14271 }
14272
14273 if (error_found)
14274 {
14275 debug_tree (const_cast <tree> (t));
14276 internal_error ("verify_type failed");
14277 }
14278 }
14279
14280
14281 /* Return 1 if ARG interpreted as signed in its precision is known to be
14282 always positive or 2 if ARG is known to be always negative, or 3 if
14283 ARG may be positive or negative. */
14284
14285 int
14286 get_range_pos_neg (tree arg)
14287 {
14288 if (arg == error_mark_node)
14289 return 3;
14290
14291 int prec = TYPE_PRECISION (TREE_TYPE (arg));
14292 int cnt = 0;
14293 if (TREE_CODE (arg) == INTEGER_CST)
14294 {
14295 wide_int w = wi::sext (arg, prec);
14296 if (wi::neg_p (w))
14297 return 2;
14298 else
14299 return 1;
14300 }
14301 while (CONVERT_EXPR_P (arg)
14302 && INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (arg, 0)))
14303 && TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (arg, 0))) <= prec)
14304 {
14305 arg = TREE_OPERAND (arg, 0);
14306 /* Narrower value zero extended into wider type
14307 will always result in positive values. */
14308 if (TYPE_UNSIGNED (TREE_TYPE (arg))
14309 && TYPE_PRECISION (TREE_TYPE (arg)) < prec)
14310 return 1;
14311 prec = TYPE_PRECISION (TREE_TYPE (arg));
14312 if (++cnt > 30)
14313 return 3;
14314 }
14315
14316 if (TREE_CODE (arg) != SSA_NAME)
14317 return 3;
14318 wide_int arg_min, arg_max;
14319 while (get_range_info (arg, &arg_min, &arg_max) != VR_RANGE)
14320 {
14321 gimple *g = SSA_NAME_DEF_STMT (arg);
14322 if (is_gimple_assign (g)
14323 && CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (g)))
14324 {
14325 tree t = gimple_assign_rhs1 (g);
14326 if (INTEGRAL_TYPE_P (TREE_TYPE (t))
14327 && TYPE_PRECISION (TREE_TYPE (t)) <= prec)
14328 {
14329 if (TYPE_UNSIGNED (TREE_TYPE (t))
14330 && TYPE_PRECISION (TREE_TYPE (t)) < prec)
14331 return 1;
14332 prec = TYPE_PRECISION (TREE_TYPE (t));
14333 arg = t;
14334 if (++cnt > 30)
14335 return 3;
14336 continue;
14337 }
14338 }
14339 return 3;
14340 }
14341 if (TYPE_UNSIGNED (TREE_TYPE (arg)))
14342 {
14343 /* For unsigned values, the "positive" range comes
14344 below the "negative" range. */
14345 if (!wi::neg_p (wi::sext (arg_max, prec), SIGNED))
14346 return 1;
14347 if (wi::neg_p (wi::sext (arg_min, prec), SIGNED))
14348 return 2;
14349 }
14350 else
14351 {
14352 if (!wi::neg_p (wi::sext (arg_min, prec), SIGNED))
14353 return 1;
14354 if (wi::neg_p (wi::sext (arg_max, prec), SIGNED))
14355 return 2;
14356 }
14357 return 3;
14358 }
14359
14360
14361
14362
14363 /* Return true if ARG is marked with the nonnull attribute in the
14364 current function signature. */
14365
14366 bool
14367 nonnull_arg_p (const_tree arg)
14368 {
14369 tree t, attrs, fntype;
14370 unsigned HOST_WIDE_INT arg_num;
14371
14372 gcc_assert (TREE_CODE (arg) == PARM_DECL
14373 && (POINTER_TYPE_P (TREE_TYPE (arg))
14374 || TREE_CODE (TREE_TYPE (arg)) == OFFSET_TYPE));
14375
14376 /* The static chain decl is always non null. */
14377 if (arg == cfun->static_chain_decl)
14378 return true;
14379
14380 /* THIS argument of method is always non-NULL. */
14381 if (TREE_CODE (TREE_TYPE (cfun->decl)) == METHOD_TYPE
14382 && arg == DECL_ARGUMENTS (cfun->decl)
14383 && flag_delete_null_pointer_checks)
14384 return true;
14385
14386 /* Values passed by reference are always non-NULL. */
14387 if (TREE_CODE (TREE_TYPE (arg)) == REFERENCE_TYPE
14388 && flag_delete_null_pointer_checks)
14389 return true;
14390
14391 fntype = TREE_TYPE (cfun->decl);
14392 for (attrs = TYPE_ATTRIBUTES (fntype); attrs; attrs = TREE_CHAIN (attrs))
14393 {
14394 attrs = lookup_attribute ("nonnull", attrs);
14395
14396 /* If "nonnull" wasn't specified, we know nothing about the argument. */
14397 if (attrs == NULL_TREE)
14398 return false;
14399
14400 /* If "nonnull" applies to all the arguments, then ARG is non-null. */
14401 if (TREE_VALUE (attrs) == NULL_TREE)
14402 return true;
14403
14404 /* Get the position number for ARG in the function signature. */
14405 for (arg_num = 1, t = DECL_ARGUMENTS (cfun->decl);
14406 t;
14407 t = DECL_CHAIN (t), arg_num++)
14408 {
14409 if (t == arg)
14410 break;
14411 }
14412
14413 gcc_assert (t == arg);
14414
14415 /* Now see if ARG_NUM is mentioned in the nonnull list. */
14416 for (t = TREE_VALUE (attrs); t; t = TREE_CHAIN (t))
14417 {
14418 if (compare_tree_int (TREE_VALUE (t), arg_num) == 0)
14419 return true;
14420 }
14421 }
14422
14423 return false;
14424 }
14425
14426 /* Combine LOC and BLOCK to a combined adhoc loc, retaining any range
14427 information. */
14428
14429 location_t
14430 set_block (location_t loc, tree block)
14431 {
14432 location_t pure_loc = get_pure_location (loc);
14433 source_range src_range = get_range_from_loc (line_table, loc);
14434 return COMBINE_LOCATION_DATA (line_table, pure_loc, src_range, block);
14435 }
14436
14437 location_t
14438 set_source_range (tree expr, location_t start, location_t finish)
14439 {
14440 source_range src_range;
14441 src_range.m_start = start;
14442 src_range.m_finish = finish;
14443 return set_source_range (expr, src_range);
14444 }
14445
14446 location_t
14447 set_source_range (tree expr, source_range src_range)
14448 {
14449 if (!EXPR_P (expr))
14450 return UNKNOWN_LOCATION;
14451
14452 location_t pure_loc = get_pure_location (EXPR_LOCATION (expr));
14453 location_t adhoc = COMBINE_LOCATION_DATA (line_table,
14454 pure_loc,
14455 src_range,
14456 NULL);
14457 SET_EXPR_LOCATION (expr, adhoc);
14458 return adhoc;
14459 }
14460
14461 /* Return the name of combined function FN, for debugging purposes. */
14462
14463 const char *
14464 combined_fn_name (combined_fn fn)
14465 {
14466 if (builtin_fn_p (fn))
14467 {
14468 tree fndecl = builtin_decl_explicit (as_builtin_fn (fn));
14469 return IDENTIFIER_POINTER (DECL_NAME (fndecl));
14470 }
14471 else
14472 return internal_fn_name (as_internal_fn (fn));
14473 }
14474
14475 /* Return a bitmap with a bit set corresponding to each argument in
14476 a function call type FNTYPE declared with attribute nonnull,
14477 or null if none of the function's argument are nonnull. The caller
14478 must free the bitmap. */
14479
14480 bitmap
14481 get_nonnull_args (const_tree fntype)
14482 {
14483 if (fntype == NULL_TREE)
14484 return NULL;
14485
14486 tree attrs = TYPE_ATTRIBUTES (fntype);
14487 if (!attrs)
14488 return NULL;
14489
14490 bitmap argmap = NULL;
14491
14492 /* A function declaration can specify multiple attribute nonnull,
14493 each with zero or more arguments. The loop below creates a bitmap
14494 representing a union of all the arguments. An empty (but non-null)
14495 bitmap means that all arguments have been declaraed nonnull. */
14496 for ( ; attrs; attrs = TREE_CHAIN (attrs))
14497 {
14498 attrs = lookup_attribute ("nonnull", attrs);
14499 if (!attrs)
14500 break;
14501
14502 if (!argmap)
14503 argmap = BITMAP_ALLOC (NULL);
14504
14505 if (!TREE_VALUE (attrs))
14506 {
14507 /* Clear the bitmap in case a previous attribute nonnull
14508 set it and this one overrides it for all arguments. */
14509 bitmap_clear (argmap);
14510 return argmap;
14511 }
14512
14513 /* Iterate over the indices of the format arguments declared nonnull
14514 and set a bit for each. */
14515 for (tree idx = TREE_VALUE (attrs); idx; idx = TREE_CHAIN (idx))
14516 {
14517 unsigned int val = TREE_INT_CST_LOW (TREE_VALUE (idx)) - 1;
14518 bitmap_set_bit (argmap, val);
14519 }
14520 }
14521
14522 return argmap;
14523 }
14524
14525 #if CHECKING_P
14526
14527 namespace selftest {
14528
14529 /* Selftests for tree. */
14530
14531 /* Verify that integer constants are sane. */
14532
14533 static void
14534 test_integer_constants ()
14535 {
14536 ASSERT_TRUE (integer_type_node != NULL);
14537 ASSERT_TRUE (build_int_cst (integer_type_node, 0) != NULL);
14538
14539 tree type = integer_type_node;
14540
14541 tree zero = build_zero_cst (type);
14542 ASSERT_EQ (INTEGER_CST, TREE_CODE (zero));
14543 ASSERT_EQ (type, TREE_TYPE (zero));
14544
14545 tree one = build_int_cst (type, 1);
14546 ASSERT_EQ (INTEGER_CST, TREE_CODE (one));
14547 ASSERT_EQ (type, TREE_TYPE (zero));
14548 }
14549
14550 /* Verify identifiers. */
14551
14552 static void
14553 test_identifiers ()
14554 {
14555 tree identifier = get_identifier ("foo");
14556 ASSERT_EQ (3, IDENTIFIER_LENGTH (identifier));
14557 ASSERT_STREQ ("foo", IDENTIFIER_POINTER (identifier));
14558 }
14559
14560 /* Verify LABEL_DECL. */
14561
14562 static void
14563 test_labels ()
14564 {
14565 tree identifier = get_identifier ("err");
14566 tree label_decl = build_decl (UNKNOWN_LOCATION, LABEL_DECL,
14567 identifier, void_type_node);
14568 ASSERT_EQ (-1, LABEL_DECL_UID (label_decl));
14569 ASSERT_FALSE (FORCED_LABEL (label_decl));
14570 }
14571
14572 /* Run all of the selftests within this file. */
14573
14574 void
14575 tree_c_tests ()
14576 {
14577 test_integer_constants ();
14578 test_identifiers ();
14579 test_labels ();
14580 }
14581
14582 } // namespace selftest
14583
14584 #endif /* CHECKING_P */
14585
14586 #include "gt-tree.h"