1 /* Language-independent node constructors for parse phase of GNU compiler.
2 Copyright (C) 1987-2018 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 #include "stringpool.h"
66 #include "attribs.h"
67 #include "rtl.h"
68 #include "regs.h"
69 #include "tree-vector-builder.h"
70
71 /* Tree code classes. */
72
73 #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) TYPE,
74 #define END_OF_BASE_TREE_CODES tcc_exceptional,
75
76 const enum tree_code_class tree_code_type[] = {
77 #include "all-tree.def"
78 };
79
80 #undef DEFTREECODE
81 #undef END_OF_BASE_TREE_CODES
82
83 /* Table indexed by tree code giving number of expression
84 operands beyond the fixed part of the node structure.
85 Not used for types or decls. */
86
87 #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) LENGTH,
88 #define END_OF_BASE_TREE_CODES 0,
89
90 const unsigned char tree_code_length[] = {
91 #include "all-tree.def"
92 };
93
94 #undef DEFTREECODE
95 #undef END_OF_BASE_TREE_CODES
96
97 /* Names of tree components.
98 Used for printing out the tree and error messages. */
99 #define DEFTREECODE(SYM, NAME, TYPE, LEN) NAME,
100 #define END_OF_BASE_TREE_CODES "@dummy",
101
102 static const char *const tree_code_name[] = {
103 #include "all-tree.def"
104 };
105
106 #undef DEFTREECODE
107 #undef END_OF_BASE_TREE_CODES
108
109 /* Each tree code class has an associated string representation.
110 These must correspond to the tree_code_class entries. */
111
112 const char *const tree_code_class_strings[] =
113 {
114 "exceptional",
115 "constant",
116 "type",
117 "declaration",
118 "reference",
119 "comparison",
120 "unary",
121 "binary",
122 "statement",
123 "vl_exp",
124 "expression"
125 };
126
127 /* obstack.[ch] explicitly declined to prototype this. */
128 extern int _obstack_allocated_p (struct obstack *h, void *obj);
129
130 /* Statistics-gathering stuff. */
131
132 static uint64_t tree_code_counts[MAX_TREE_CODES];
133 uint64_t tree_node_counts[(int) all_kinds];
134 uint64_t tree_node_sizes[(int) all_kinds];
135
136 /* Keep in sync with tree.h:enum tree_node_kind. */
137 static const char * const tree_node_kind_names[] = {
138 "decls",
139 "types",
140 "blocks",
141 "stmts",
142 "refs",
143 "exprs",
144 "constants",
145 "identifiers",
146 "vecs",
147 "binfos",
148 "ssa names",
149 "constructors",
150 "random kinds",
151 "lang_decl kinds",
152 "lang_type kinds",
153 "omp clauses",
154 };
155
156 /* Unique id for next decl created. */
157 static GTY(()) int next_decl_uid;
158 /* Unique id for next type created. */
159 static GTY(()) unsigned next_type_uid = 1;
160 /* Unique id for next debug decl created. Use negative numbers,
161 to catch erroneous uses. */
162 static GTY(()) int next_debug_decl_uid;
163
164 /* Since we cannot rehash a type after it is in the table, we have to
165 keep the hash code. */
166
167 struct GTY((for_user)) type_hash {
168 unsigned long hash;
169 tree type;
170 };
171
172 /* Initial size of the hash table (rounded to next prime). */
173 #define TYPE_HASH_INITIAL_SIZE 1000
174
175 struct type_cache_hasher : ggc_cache_ptr_hash<type_hash>
176 {
hashtype_cache_hasher177 static hashval_t hash (type_hash *t) { return t->hash; }
178 static bool equal (type_hash *a, type_hash *b);
179
180 static int
keep_cache_entrytype_cache_hasher181 keep_cache_entry (type_hash *&t)
182 {
183 return ggc_marked_p (t->type);
184 }
185 };
186
187 /* Now here is the hash table. When recording a type, it is added to
188 the slot whose index is the hash code. Note that the hash table is
189 used for several kinds of types (function types, array types and
190 array index range types, for now). While all these live in the
191 same table, they are completely independent, and the hash code is
192 computed differently for each of these. */
193
194 static GTY ((cache)) hash_table<type_cache_hasher> *type_hash_table;
195
196 /* Hash table and temporary node for larger integer const values. */
197 static GTY (()) tree int_cst_node;
198
199 struct int_cst_hasher : ggc_cache_ptr_hash<tree_node>
200 {
201 static hashval_t hash (tree t);
202 static bool equal (tree x, tree y);
203 };
204
205 static GTY ((cache)) hash_table<int_cst_hasher> *int_cst_hash_table;
206
207 /* Class and variable for making sure that there is a single POLY_INT_CST
208 for a given value. */
209 struct poly_int_cst_hasher : ggc_cache_ptr_hash<tree_node>
210 {
211 typedef std::pair<tree, const poly_wide_int *> compare_type;
212 static hashval_t hash (tree t);
213 static bool equal (tree x, const compare_type &y);
214 };
215
216 static GTY ((cache)) hash_table<poly_int_cst_hasher> *poly_int_cst_hash_table;
217
218 /* Hash table for optimization flags and target option flags. Use the same
219 hash table for both sets of options. Nodes for building the current
220 optimization and target option nodes. The assumption is most of the time
221 the options created will already be in the hash table, so we avoid
222 allocating and freeing up a node repeatably. */
223 static GTY (()) tree cl_optimization_node;
224 static GTY (()) tree cl_target_option_node;
225
226 struct cl_option_hasher : ggc_cache_ptr_hash<tree_node>
227 {
228 static hashval_t hash (tree t);
229 static bool equal (tree x, tree y);
230 };
231
232 static GTY ((cache)) hash_table<cl_option_hasher> *cl_option_hash_table;
233
234 /* General tree->tree mapping structure for use in hash tables. */
235
236
237 static GTY ((cache))
238 hash_table<tree_decl_map_cache_hasher> *debug_expr_for_decl;
239
240 static GTY ((cache))
241 hash_table<tree_decl_map_cache_hasher> *value_expr_for_decl;
242
243 struct tree_vec_map_cache_hasher : ggc_cache_ptr_hash<tree_vec_map>
244 {
hashtree_vec_map_cache_hasher245 static hashval_t hash (tree_vec_map *m) { return DECL_UID (m->base.from); }
246
247 static bool
equaltree_vec_map_cache_hasher248 equal (tree_vec_map *a, tree_vec_map *b)
249 {
250 return a->base.from == b->base.from;
251 }
252
253 static int
keep_cache_entrytree_vec_map_cache_hasher254 keep_cache_entry (tree_vec_map *&m)
255 {
256 return ggc_marked_p (m->base.from);
257 }
258 };
259
260 static GTY ((cache))
261 hash_table<tree_vec_map_cache_hasher> *debug_args_for_decl;
262
263 static void set_type_quals (tree, int);
264 static void print_type_hash_statistics (void);
265 static void print_debug_expr_statistics (void);
266 static void print_value_expr_statistics (void);
267
268 tree global_trees[TI_MAX];
269 tree integer_types[itk_none];
270
271 bool int_n_enabled_p[NUM_INT_N_ENTS];
272 struct int_n_trees_t int_n_trees [NUM_INT_N_ENTS];
273
274 bool tree_contains_struct[MAX_TREE_CODES][64];
275
276 /* Number of operands for each OpenMP clause. */
277 unsigned const char omp_clause_num_ops[] =
278 {
279 0, /* OMP_CLAUSE_ERROR */
280 1, /* OMP_CLAUSE_PRIVATE */
281 1, /* OMP_CLAUSE_SHARED */
282 1, /* OMP_CLAUSE_FIRSTPRIVATE */
283 2, /* OMP_CLAUSE_LASTPRIVATE */
284 5, /* OMP_CLAUSE_REDUCTION */
285 1, /* OMP_CLAUSE_COPYIN */
286 1, /* OMP_CLAUSE_COPYPRIVATE */
287 3, /* OMP_CLAUSE_LINEAR */
288 2, /* OMP_CLAUSE_ALIGNED */
289 1, /* OMP_CLAUSE_DEPEND */
290 1, /* OMP_CLAUSE_UNIFORM */
291 1, /* OMP_CLAUSE_TO_DECLARE */
292 1, /* OMP_CLAUSE_LINK */
293 2, /* OMP_CLAUSE_FROM */
294 2, /* OMP_CLAUSE_TO */
295 2, /* OMP_CLAUSE_MAP */
296 1, /* OMP_CLAUSE_USE_DEVICE_PTR */
297 1, /* OMP_CLAUSE_IS_DEVICE_PTR */
298 2, /* OMP_CLAUSE__CACHE_ */
299 2, /* OMP_CLAUSE_GANG */
300 1, /* OMP_CLAUSE_ASYNC */
301 1, /* OMP_CLAUSE_WAIT */
302 0, /* OMP_CLAUSE_AUTO */
303 0, /* OMP_CLAUSE_SEQ */
304 1, /* OMP_CLAUSE__LOOPTEMP_ */
305 1, /* OMP_CLAUSE_IF */
306 1, /* OMP_CLAUSE_NUM_THREADS */
307 1, /* OMP_CLAUSE_SCHEDULE */
308 0, /* OMP_CLAUSE_NOWAIT */
309 1, /* OMP_CLAUSE_ORDERED */
310 0, /* OMP_CLAUSE_DEFAULT */
311 3, /* OMP_CLAUSE_COLLAPSE */
312 0, /* OMP_CLAUSE_UNTIED */
313 1, /* OMP_CLAUSE_FINAL */
314 0, /* OMP_CLAUSE_MERGEABLE */
315 1, /* OMP_CLAUSE_DEVICE */
316 1, /* OMP_CLAUSE_DIST_SCHEDULE */
317 0, /* OMP_CLAUSE_INBRANCH */
318 0, /* OMP_CLAUSE_NOTINBRANCH */
319 1, /* OMP_CLAUSE_NUM_TEAMS */
320 1, /* OMP_CLAUSE_THREAD_LIMIT */
321 0, /* OMP_CLAUSE_PROC_BIND */
322 1, /* OMP_CLAUSE_SAFELEN */
323 1, /* OMP_CLAUSE_SIMDLEN */
324 0, /* OMP_CLAUSE_FOR */
325 0, /* OMP_CLAUSE_PARALLEL */
326 0, /* OMP_CLAUSE_SECTIONS */
327 0, /* OMP_CLAUSE_TASKGROUP */
328 1, /* OMP_CLAUSE_PRIORITY */
329 1, /* OMP_CLAUSE_GRAINSIZE */
330 1, /* OMP_CLAUSE_NUM_TASKS */
331 0, /* OMP_CLAUSE_NOGROUP */
332 0, /* OMP_CLAUSE_THREADS */
333 0, /* OMP_CLAUSE_SIMD */
334 1, /* OMP_CLAUSE_HINT */
335 0, /* OMP_CLAUSE_DEFALTMAP */
336 1, /* OMP_CLAUSE__SIMDUID_ */
337 0, /* OMP_CLAUSE__SIMT_ */
338 0, /* OMP_CLAUSE_INDEPENDENT */
339 1, /* OMP_CLAUSE_WORKER */
340 1, /* OMP_CLAUSE_VECTOR */
341 1, /* OMP_CLAUSE_NUM_GANGS */
342 1, /* OMP_CLAUSE_NUM_WORKERS */
343 1, /* OMP_CLAUSE_VECTOR_LENGTH */
344 3, /* OMP_CLAUSE_TILE */
345 2, /* OMP_CLAUSE__GRIDDIM_ */
346 };
347
348 const char * const omp_clause_code_name[] =
349 {
350 "error_clause",
351 "private",
352 "shared",
353 "firstprivate",
354 "lastprivate",
355 "reduction",
356 "copyin",
357 "copyprivate",
358 "linear",
359 "aligned",
360 "depend",
361 "uniform",
362 "to",
363 "link",
364 "from",
365 "to",
366 "map",
367 "use_device_ptr",
368 "is_device_ptr",
369 "_cache_",
370 "gang",
371 "async",
372 "wait",
373 "auto",
374 "seq",
375 "_looptemp_",
376 "if",
377 "num_threads",
378 "schedule",
379 "nowait",
380 "ordered",
381 "default",
382 "collapse",
383 "untied",
384 "final",
385 "mergeable",
386 "device",
387 "dist_schedule",
388 "inbranch",
389 "notinbranch",
390 "num_teams",
391 "thread_limit",
392 "proc_bind",
393 "safelen",
394 "simdlen",
395 "for",
396 "parallel",
397 "sections",
398 "taskgroup",
399 "priority",
400 "grainsize",
401 "num_tasks",
402 "nogroup",
403 "threads",
404 "simd",
405 "hint",
406 "defaultmap",
407 "_simduid_",
408 "_simt_",
409 "independent",
410 "worker",
411 "vector",
412 "num_gangs",
413 "num_workers",
414 "vector_length",
415 "tile",
416 "_griddim_"
417 };
418
419
420 /* Return the tree node structure used by tree code CODE. */
421
422 static inline enum tree_node_structure_enum
tree_node_structure_for_code(enum tree_code code)423 tree_node_structure_for_code (enum tree_code code)
424 {
425 switch (TREE_CODE_CLASS (code))
426 {
427 case tcc_declaration:
428 {
429 switch (code)
430 {
431 case FIELD_DECL:
432 return TS_FIELD_DECL;
433 case PARM_DECL:
434 return TS_PARM_DECL;
435 case VAR_DECL:
436 return TS_VAR_DECL;
437 case LABEL_DECL:
438 return TS_LABEL_DECL;
439 case RESULT_DECL:
440 return TS_RESULT_DECL;
441 case DEBUG_EXPR_DECL:
442 return TS_DECL_WRTL;
443 case CONST_DECL:
444 return TS_CONST_DECL;
445 case TYPE_DECL:
446 return TS_TYPE_DECL;
447 case FUNCTION_DECL:
448 return TS_FUNCTION_DECL;
449 case TRANSLATION_UNIT_DECL:
450 return TS_TRANSLATION_UNIT_DECL;
451 default:
452 return TS_DECL_NON_COMMON;
453 }
454 }
455 case tcc_type:
456 return TS_TYPE_NON_COMMON;
457 case tcc_reference:
458 case tcc_comparison:
459 case tcc_unary:
460 case tcc_binary:
461 case tcc_expression:
462 case tcc_statement:
463 case tcc_vl_exp:
464 return TS_EXP;
465 default: /* tcc_constant and tcc_exceptional */
466 break;
467 }
468 switch (code)
469 {
470 /* tcc_constant cases. */
471 case VOID_CST: return TS_TYPED;
472 case INTEGER_CST: return TS_INT_CST;
473 case POLY_INT_CST: return TS_POLY_INT_CST;
474 case REAL_CST: return TS_REAL_CST;
475 case FIXED_CST: return TS_FIXED_CST;
476 case COMPLEX_CST: return TS_COMPLEX;
477 case VECTOR_CST: return TS_VECTOR;
478 case STRING_CST: return TS_STRING;
479 /* tcc_exceptional cases. */
480 case ERROR_MARK: return TS_COMMON;
481 case IDENTIFIER_NODE: return TS_IDENTIFIER;
482 case TREE_LIST: return TS_LIST;
483 case TREE_VEC: return TS_VEC;
484 case SSA_NAME: return TS_SSA_NAME;
485 case PLACEHOLDER_EXPR: return TS_COMMON;
486 case STATEMENT_LIST: return TS_STATEMENT_LIST;
487 case BLOCK: return TS_BLOCK;
488 case CONSTRUCTOR: return TS_CONSTRUCTOR;
489 case TREE_BINFO: return TS_BINFO;
490 case OMP_CLAUSE: return TS_OMP_CLAUSE;
491 case OPTIMIZATION_NODE: return TS_OPTIMIZATION;
492 case TARGET_OPTION_NODE: return TS_TARGET_OPTION;
493
494 default:
495 gcc_unreachable ();
496 }
497 }
498
499
500 /* Initialize tree_contains_struct to describe the hierarchy of tree
501 nodes. */
502
503 static void
initialize_tree_contains_struct(void)504 initialize_tree_contains_struct (void)
505 {
506 unsigned i;
507
508 for (i = ERROR_MARK; i < LAST_AND_UNUSED_TREE_CODE; i++)
509 {
510 enum tree_code code;
511 enum tree_node_structure_enum ts_code;
512
513 code = (enum tree_code) i;
514 ts_code = tree_node_structure_for_code (code);
515
516 /* Mark the TS structure itself. */
517 tree_contains_struct[code][ts_code] = 1;
518
519 /* Mark all the structures that TS is derived from. */
520 switch (ts_code)
521 {
522 case TS_TYPED:
523 case TS_BLOCK:
524 case TS_OPTIMIZATION:
525 case TS_TARGET_OPTION:
526 MARK_TS_BASE (code);
527 break;
528
529 case TS_COMMON:
530 case TS_INT_CST:
531 case TS_POLY_INT_CST:
532 case TS_REAL_CST:
533 case TS_FIXED_CST:
534 case TS_VECTOR:
535 case TS_STRING:
536 case TS_COMPLEX:
537 case TS_SSA_NAME:
538 case TS_CONSTRUCTOR:
539 case TS_EXP:
540 case TS_STATEMENT_LIST:
541 MARK_TS_TYPED (code);
542 break;
543
544 case TS_IDENTIFIER:
545 case TS_DECL_MINIMAL:
546 case TS_TYPE_COMMON:
547 case TS_LIST:
548 case TS_VEC:
549 case TS_BINFO:
550 case TS_OMP_CLAUSE:
551 MARK_TS_COMMON (code);
552 break;
553
554 case TS_TYPE_WITH_LANG_SPECIFIC:
555 MARK_TS_TYPE_COMMON (code);
556 break;
557
558 case TS_TYPE_NON_COMMON:
559 MARK_TS_TYPE_WITH_LANG_SPECIFIC (code);
560 break;
561
562 case TS_DECL_COMMON:
563 MARK_TS_DECL_MINIMAL (code);
564 break;
565
566 case TS_DECL_WRTL:
567 case TS_CONST_DECL:
568 MARK_TS_DECL_COMMON (code);
569 break;
570
571 case TS_DECL_NON_COMMON:
572 MARK_TS_DECL_WITH_VIS (code);
573 break;
574
575 case TS_DECL_WITH_VIS:
576 case TS_PARM_DECL:
577 case TS_LABEL_DECL:
578 case TS_RESULT_DECL:
579 MARK_TS_DECL_WRTL (code);
580 break;
581
582 case TS_FIELD_DECL:
583 MARK_TS_DECL_COMMON (code);
584 break;
585
586 case TS_VAR_DECL:
587 MARK_TS_DECL_WITH_VIS (code);
588 break;
589
590 case TS_TYPE_DECL:
591 case TS_FUNCTION_DECL:
592 MARK_TS_DECL_NON_COMMON (code);
593 break;
594
595 case TS_TRANSLATION_UNIT_DECL:
596 MARK_TS_DECL_COMMON (code);
597 break;
598
599 default:
600 gcc_unreachable ();
601 }
602 }
603
604 /* Basic consistency checks for attributes used in fold. */
605 gcc_assert (tree_contains_struct[FUNCTION_DECL][TS_DECL_NON_COMMON]);
606 gcc_assert (tree_contains_struct[TYPE_DECL][TS_DECL_NON_COMMON]);
607 gcc_assert (tree_contains_struct[CONST_DECL][TS_DECL_COMMON]);
608 gcc_assert (tree_contains_struct[VAR_DECL][TS_DECL_COMMON]);
609 gcc_assert (tree_contains_struct[PARM_DECL][TS_DECL_COMMON]);
610 gcc_assert (tree_contains_struct[RESULT_DECL][TS_DECL_COMMON]);
611 gcc_assert (tree_contains_struct[FUNCTION_DECL][TS_DECL_COMMON]);
612 gcc_assert (tree_contains_struct[TYPE_DECL][TS_DECL_COMMON]);
613 gcc_assert (tree_contains_struct[TRANSLATION_UNIT_DECL][TS_DECL_COMMON]);
614 gcc_assert (tree_contains_struct[LABEL_DECL][TS_DECL_COMMON]);
615 gcc_assert (tree_contains_struct[FIELD_DECL][TS_DECL_COMMON]);
616 gcc_assert (tree_contains_struct[VAR_DECL][TS_DECL_WRTL]);
617 gcc_assert (tree_contains_struct[PARM_DECL][TS_DECL_WRTL]);
618 gcc_assert (tree_contains_struct[RESULT_DECL][TS_DECL_WRTL]);
619 gcc_assert (tree_contains_struct[FUNCTION_DECL][TS_DECL_WRTL]);
620 gcc_assert (tree_contains_struct[LABEL_DECL][TS_DECL_WRTL]);
621 gcc_assert (tree_contains_struct[CONST_DECL][TS_DECL_MINIMAL]);
622 gcc_assert (tree_contains_struct[VAR_DECL][TS_DECL_MINIMAL]);
623 gcc_assert (tree_contains_struct[PARM_DECL][TS_DECL_MINIMAL]);
624 gcc_assert (tree_contains_struct[RESULT_DECL][TS_DECL_MINIMAL]);
625 gcc_assert (tree_contains_struct[FUNCTION_DECL][TS_DECL_MINIMAL]);
626 gcc_assert (tree_contains_struct[TYPE_DECL][TS_DECL_MINIMAL]);
627 gcc_assert (tree_contains_struct[TRANSLATION_UNIT_DECL][TS_DECL_MINIMAL]);
628 gcc_assert (tree_contains_struct[LABEL_DECL][TS_DECL_MINIMAL]);
629 gcc_assert (tree_contains_struct[FIELD_DECL][TS_DECL_MINIMAL]);
630 gcc_assert (tree_contains_struct[VAR_DECL][TS_DECL_WITH_VIS]);
631 gcc_assert (tree_contains_struct[FUNCTION_DECL][TS_DECL_WITH_VIS]);
632 gcc_assert (tree_contains_struct[TYPE_DECL][TS_DECL_WITH_VIS]);
633 gcc_assert (tree_contains_struct[VAR_DECL][TS_VAR_DECL]);
634 gcc_assert (tree_contains_struct[FIELD_DECL][TS_FIELD_DECL]);
635 gcc_assert (tree_contains_struct[PARM_DECL][TS_PARM_DECL]);
636 gcc_assert (tree_contains_struct[LABEL_DECL][TS_LABEL_DECL]);
637 gcc_assert (tree_contains_struct[RESULT_DECL][TS_RESULT_DECL]);
638 gcc_assert (tree_contains_struct[CONST_DECL][TS_CONST_DECL]);
639 gcc_assert (tree_contains_struct[TYPE_DECL][TS_TYPE_DECL]);
640 gcc_assert (tree_contains_struct[FUNCTION_DECL][TS_FUNCTION_DECL]);
641 gcc_assert (tree_contains_struct[IMPORTED_DECL][TS_DECL_MINIMAL]);
642 gcc_assert (tree_contains_struct[IMPORTED_DECL][TS_DECL_COMMON]);
643 gcc_assert (tree_contains_struct[NAMELIST_DECL][TS_DECL_MINIMAL]);
644 gcc_assert (tree_contains_struct[NAMELIST_DECL][TS_DECL_COMMON]);
645 }
646
647
648 /* Init tree.c. */
649
650 void
init_ttree(void)651 init_ttree (void)
652 {
653 /* Initialize the hash table of types. */
654 type_hash_table
655 = hash_table<type_cache_hasher>::create_ggc (TYPE_HASH_INITIAL_SIZE);
656
657 debug_expr_for_decl
658 = hash_table<tree_decl_map_cache_hasher>::create_ggc (512);
659
660 value_expr_for_decl
661 = hash_table<tree_decl_map_cache_hasher>::create_ggc (512);
662
663 int_cst_hash_table = hash_table<int_cst_hasher>::create_ggc (1024);
664
665 poly_int_cst_hash_table = hash_table<poly_int_cst_hasher>::create_ggc (64);
666
667 int_cst_node = make_int_cst (1, 1);
668
669 cl_option_hash_table = hash_table<cl_option_hasher>::create_ggc (64);
670
671 cl_optimization_node = make_node (OPTIMIZATION_NODE);
672 cl_target_option_node = make_node (TARGET_OPTION_NODE);
673
674 /* Initialize the tree_contains_struct array. */
675 initialize_tree_contains_struct ();
676 lang_hooks.init_ts ();
677 }
678
679
680 /* The name of the object as the assembler will see it (but before any
681 translations made by ASM_OUTPUT_LABELREF). Often this is the same
682 as DECL_NAME. It is an IDENTIFIER_NODE. */
683 tree
decl_assembler_name(tree decl)684 decl_assembler_name (tree decl)
685 {
686 if (!DECL_ASSEMBLER_NAME_SET_P (decl))
687 lang_hooks.set_decl_assembler_name (decl);
688 return DECL_ASSEMBLER_NAME_RAW (decl);
689 }
690
691 /* The DECL_ASSEMBLER_NAME_RAW of DECL is being explicitly set to NAME
692 (either of which may be NULL). Inform the FE, if this changes the
693 name. */
694
695 void
overwrite_decl_assembler_name(tree decl,tree name)696 overwrite_decl_assembler_name (tree decl, tree name)
697 {
698 if (DECL_ASSEMBLER_NAME_RAW (decl) != name)
699 lang_hooks.overwrite_decl_assembler_name (decl, name);
700 }
701
702 /* When the target supports COMDAT groups, this indicates which group the
703 DECL is associated with. This can be either an IDENTIFIER_NODE or a
704 decl, in which case its DECL_ASSEMBLER_NAME identifies the group. */
705 tree
decl_comdat_group(const_tree node)706 decl_comdat_group (const_tree node)
707 {
708 struct symtab_node *snode = symtab_node::get (node);
709 if (!snode)
710 return NULL;
711 return snode->get_comdat_group ();
712 }
713
714 /* Likewise, but make sure it's been reduced to an IDENTIFIER_NODE. */
715 tree
decl_comdat_group_id(const_tree node)716 decl_comdat_group_id (const_tree node)
717 {
718 struct symtab_node *snode = symtab_node::get (node);
719 if (!snode)
720 return NULL;
721 return snode->get_comdat_group_id ();
722 }
723
724 /* When the target supports named section, return its name as IDENTIFIER_NODE
725 or NULL if it is in no section. */
726 const char *
decl_section_name(const_tree node)727 decl_section_name (const_tree node)
728 {
729 struct symtab_node *snode = symtab_node::get (node);
730 if (!snode)
731 return NULL;
732 return snode->get_section ();
733 }
734
735 /* Set section name of NODE to VALUE (that is expected to be
736 identifier node) */
737 void
set_decl_section_name(tree node,const char * value)738 set_decl_section_name (tree node, const char *value)
739 {
740 struct symtab_node *snode;
741
742 if (value == NULL)
743 {
744 snode = symtab_node::get (node);
745 if (!snode)
746 return;
747 }
748 else if (VAR_P (node))
749 snode = varpool_node::get_create (node);
750 else
751 snode = cgraph_node::get_create (node);
752 snode->set_section (value);
753 }
754
755 /* Return TLS model of a variable NODE. */
756 enum tls_model
decl_tls_model(const_tree node)757 decl_tls_model (const_tree node)
758 {
759 struct varpool_node *snode = varpool_node::get (node);
760 if (!snode)
761 return TLS_MODEL_NONE;
762 return snode->tls_model;
763 }
764
765 /* Set TLS model of variable NODE to MODEL. */
766 void
set_decl_tls_model(tree node,enum tls_model model)767 set_decl_tls_model (tree node, enum tls_model model)
768 {
769 struct varpool_node *vnode;
770
771 if (model == TLS_MODEL_NONE)
772 {
773 vnode = varpool_node::get (node);
774 if (!vnode)
775 return;
776 }
777 else
778 vnode = varpool_node::get_create (node);
779 vnode->tls_model = model;
780 }
781
782 /* Compute the number of bytes occupied by a tree with code CODE.
783 This function cannot be used for nodes that have variable sizes,
784 including TREE_VEC, INTEGER_CST, STRING_CST, and CALL_EXPR. */
785 size_t
tree_code_size(enum tree_code code)786 tree_code_size (enum tree_code code)
787 {
788 switch (TREE_CODE_CLASS (code))
789 {
790 case tcc_declaration: /* A decl node */
791 switch (code)
792 {
793 case FIELD_DECL: return sizeof (tree_field_decl);
794 case PARM_DECL: return sizeof (tree_parm_decl);
795 case VAR_DECL: return sizeof (tree_var_decl);
796 case LABEL_DECL: return sizeof (tree_label_decl);
797 case RESULT_DECL: return sizeof (tree_result_decl);
798 case CONST_DECL: return sizeof (tree_const_decl);
799 case TYPE_DECL: return sizeof (tree_type_decl);
800 case FUNCTION_DECL: return sizeof (tree_function_decl);
801 case DEBUG_EXPR_DECL: return sizeof (tree_decl_with_rtl);
802 case TRANSLATION_UNIT_DECL: return sizeof (tree_translation_unit_decl);
803 case NAMESPACE_DECL:
804 case IMPORTED_DECL:
805 case NAMELIST_DECL: return sizeof (tree_decl_non_common);
806 default:
807 gcc_checking_assert (code >= NUM_TREE_CODES);
808 return lang_hooks.tree_size (code);
809 }
810
811 case tcc_type: /* a type node */
812 switch (code)
813 {
814 case OFFSET_TYPE:
815 case ENUMERAL_TYPE:
816 case BOOLEAN_TYPE:
817 case INTEGER_TYPE:
818 case REAL_TYPE:
819 case POINTER_TYPE:
820 case REFERENCE_TYPE:
821 case NULLPTR_TYPE:
822 case FIXED_POINT_TYPE:
823 case COMPLEX_TYPE:
824 case VECTOR_TYPE:
825 case ARRAY_TYPE:
826 case RECORD_TYPE:
827 case UNION_TYPE:
828 case QUAL_UNION_TYPE:
829 case VOID_TYPE:
830 case POINTER_BOUNDS_TYPE:
831 case FUNCTION_TYPE:
832 case METHOD_TYPE:
833 case LANG_TYPE: return sizeof (tree_type_non_common);
834 default:
835 gcc_checking_assert (code >= NUM_TREE_CODES);
836 return lang_hooks.tree_size (code);
837 }
838
839 case tcc_reference: /* a reference */
840 case tcc_expression: /* an expression */
841 case tcc_statement: /* an expression with side effects */
842 case tcc_comparison: /* a comparison expression */
843 case tcc_unary: /* a unary arithmetic expression */
844 case tcc_binary: /* a binary arithmetic expression */
845 return (sizeof (struct tree_exp)
846 + (TREE_CODE_LENGTH (code) - 1) * sizeof (tree));
847
848 case tcc_constant: /* a constant */
849 switch (code)
850 {
851 case VOID_CST: return sizeof (tree_typed);
852 case INTEGER_CST: gcc_unreachable ();
853 case POLY_INT_CST: return sizeof (tree_poly_int_cst);
854 case REAL_CST: return sizeof (tree_real_cst);
855 case FIXED_CST: return sizeof (tree_fixed_cst);
856 case COMPLEX_CST: return sizeof (tree_complex);
857 case VECTOR_CST: gcc_unreachable ();
858 case STRING_CST: gcc_unreachable ();
859 default:
860 gcc_checking_assert (code >= NUM_TREE_CODES);
861 return lang_hooks.tree_size (code);
862 }
863
864 case tcc_exceptional: /* something random, like an identifier. */
865 switch (code)
866 {
867 case IDENTIFIER_NODE: return lang_hooks.identifier_size;
868 case TREE_LIST: return sizeof (tree_list);
869
870 case ERROR_MARK:
871 case PLACEHOLDER_EXPR: return sizeof (tree_common);
872
873 case TREE_VEC: gcc_unreachable ();
874 case OMP_CLAUSE: gcc_unreachable ();
875
876 case SSA_NAME: return sizeof (tree_ssa_name);
877
878 case STATEMENT_LIST: return sizeof (tree_statement_list);
879 case BLOCK: return sizeof (struct tree_block);
880 case CONSTRUCTOR: return sizeof (tree_constructor);
881 case OPTIMIZATION_NODE: return sizeof (tree_optimization_option);
882 case TARGET_OPTION_NODE: return sizeof (tree_target_option);
883
884 default:
885 gcc_checking_assert (code >= NUM_TREE_CODES);
886 return lang_hooks.tree_size (code);
887 }
888
889 default:
890 gcc_unreachable ();
891 }
892 }
893
894 /* Compute the number of bytes occupied by NODE. This routine only
895 looks at TREE_CODE, except for those nodes that have variable sizes. */
896 size_t
tree_size(const_tree node)897 tree_size (const_tree node)
898 {
899 const enum tree_code code = TREE_CODE (node);
900 switch (code)
901 {
902 case INTEGER_CST:
903 return (sizeof (struct tree_int_cst)
904 + (TREE_INT_CST_EXT_NUNITS (node) - 1) * sizeof (HOST_WIDE_INT));
905
906 case TREE_BINFO:
907 return (offsetof (struct tree_binfo, base_binfos)
908 + vec<tree, va_gc>
909 ::embedded_size (BINFO_N_BASE_BINFOS (node)));
910
911 case TREE_VEC:
912 return (sizeof (struct tree_vec)
913 + (TREE_VEC_LENGTH (node) - 1) * sizeof (tree));
914
915 case VECTOR_CST:
916 return (sizeof (struct tree_vector)
917 + (vector_cst_encoded_nelts (node) - 1) * sizeof (tree));
918
919 case STRING_CST:
920 return TREE_STRING_LENGTH (node) + offsetof (struct tree_string, str) + 1;
921
922 case OMP_CLAUSE:
923 return (sizeof (struct tree_omp_clause)
924 + (omp_clause_num_ops[OMP_CLAUSE_CODE (node)] - 1)
925 * sizeof (tree));
926
927 default:
928 if (TREE_CODE_CLASS (code) == tcc_vl_exp)
929 return (sizeof (struct tree_exp)
930 + (VL_EXP_OPERAND_LENGTH (node) - 1) * sizeof (tree));
931 else
932 return tree_code_size (code);
933 }
934 }
935
936 /* Return tree node kind based on tree CODE. */
937
938 static tree_node_kind
get_stats_node_kind(enum tree_code code)939 get_stats_node_kind (enum tree_code code)
940 {
941 enum tree_code_class type = TREE_CODE_CLASS (code);
942
943 switch (type)
944 {
945 case tcc_declaration: /* A decl node */
946 return d_kind;
947 case tcc_type: /* a type node */
948 return t_kind;
949 case tcc_statement: /* an expression with side effects */
950 return s_kind;
951 case tcc_reference: /* a reference */
952 return r_kind;
953 case tcc_expression: /* an expression */
954 case tcc_comparison: /* a comparison expression */
955 case tcc_unary: /* a unary arithmetic expression */
956 case tcc_binary: /* a binary arithmetic expression */
957 return e_kind;
958 case tcc_constant: /* a constant */
959 return c_kind;
960 case tcc_exceptional: /* something random, like an identifier. */
961 switch (code)
962 {
963 case IDENTIFIER_NODE:
964 return id_kind;
965 case TREE_VEC:
966 return vec_kind;
967 case TREE_BINFO:
968 return binfo_kind;
969 case SSA_NAME:
970 return ssa_name_kind;
971 case BLOCK:
972 return b_kind;
973 case CONSTRUCTOR:
974 return constr_kind;
975 case OMP_CLAUSE:
976 return omp_clause_kind;
977 default:
978 return x_kind;
979 }
980 break;
981 case tcc_vl_exp:
982 return e_kind;
983 default:
984 gcc_unreachable ();
985 }
986 }
987
988 /* Record interesting allocation statistics for a tree node with CODE
989 and LENGTH. */
990
991 static void
record_node_allocation_statistics(enum tree_code code,size_t length)992 record_node_allocation_statistics (enum tree_code code, size_t length)
993 {
994 if (!GATHER_STATISTICS)
995 return;
996
997 tree_node_kind kind = get_stats_node_kind (code);
998
999 tree_code_counts[(int) code]++;
1000 tree_node_counts[(int) kind]++;
1001 tree_node_sizes[(int) kind] += length;
1002 }
1003
1004 /* Allocate and return a new UID from the DECL_UID namespace. */
1005
1006 int
allocate_decl_uid(void)1007 allocate_decl_uid (void)
1008 {
1009 return next_decl_uid++;
1010 }
1011
1012 /* Return a newly allocated node of code CODE. For decl and type
1013 nodes, some other fields are initialized. The rest of the node is
1014 initialized to zero. This function cannot be used for TREE_VEC,
1015 INTEGER_CST or OMP_CLAUSE nodes, which is enforced by asserts in
1016 tree_code_size.
1017
1018 Achoo! I got a code in the node. */
1019
1020 tree
make_node(enum tree_code code MEM_STAT_DECL)1021 make_node (enum tree_code code MEM_STAT_DECL)
1022 {
1023 tree t;
1024 enum tree_code_class type = TREE_CODE_CLASS (code);
1025 size_t length = tree_code_size (code);
1026
1027 record_node_allocation_statistics (code, length);
1028
1029 t = ggc_alloc_cleared_tree_node_stat (length PASS_MEM_STAT);
1030 TREE_SET_CODE (t, code);
1031
1032 switch (type)
1033 {
1034 case tcc_statement:
1035 if (code != DEBUG_BEGIN_STMT)
1036 TREE_SIDE_EFFECTS (t) = 1;
1037 break;
1038
1039 case tcc_declaration:
1040 if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
1041 {
1042 if (code == FUNCTION_DECL)
1043 {
1044 SET_DECL_ALIGN (t, FUNCTION_ALIGNMENT (FUNCTION_BOUNDARY));
1045 SET_DECL_MODE (t, FUNCTION_MODE);
1046 }
1047 else
1048 SET_DECL_ALIGN (t, 1);
1049 }
1050 DECL_SOURCE_LOCATION (t) = input_location;
1051 if (TREE_CODE (t) == DEBUG_EXPR_DECL)
1052 DECL_UID (t) = --next_debug_decl_uid;
1053 else
1054 {
1055 DECL_UID (t) = allocate_decl_uid ();
1056 SET_DECL_PT_UID (t, -1);
1057 }
1058 if (TREE_CODE (t) == LABEL_DECL)
1059 LABEL_DECL_UID (t) = -1;
1060
1061 break;
1062
1063 case tcc_type:
1064 TYPE_UID (t) = next_type_uid++;
1065 SET_TYPE_ALIGN (t, BITS_PER_UNIT);
1066 TYPE_USER_ALIGN (t) = 0;
1067 TYPE_MAIN_VARIANT (t) = t;
1068 TYPE_CANONICAL (t) = t;
1069
1070 /* Default to no attributes for type, but let target change that. */
1071 TYPE_ATTRIBUTES (t) = NULL_TREE;
1072 targetm.set_default_type_attributes (t);
1073
1074 /* We have not yet computed the alias set for this type. */
1075 TYPE_ALIAS_SET (t) = -1;
1076 break;
1077
1078 case tcc_constant:
1079 TREE_CONSTANT (t) = 1;
1080 break;
1081
1082 case tcc_expression:
1083 switch (code)
1084 {
1085 case INIT_EXPR:
1086 case MODIFY_EXPR:
1087 case VA_ARG_EXPR:
1088 case PREDECREMENT_EXPR:
1089 case PREINCREMENT_EXPR:
1090 case POSTDECREMENT_EXPR:
1091 case POSTINCREMENT_EXPR:
1092 /* All of these have side-effects, no matter what their
1093 operands are. */
1094 TREE_SIDE_EFFECTS (t) = 1;
1095 break;
1096
1097 default:
1098 break;
1099 }
1100 break;
1101
1102 case tcc_exceptional:
1103 switch (code)
1104 {
1105 case TARGET_OPTION_NODE:
1106 TREE_TARGET_OPTION(t)
1107 = ggc_cleared_alloc<struct cl_target_option> ();
1108 break;
1109
1110 case OPTIMIZATION_NODE:
1111 TREE_OPTIMIZATION (t)
1112 = ggc_cleared_alloc<struct cl_optimization> ();
1113 break;
1114
1115 default:
1116 break;
1117 }
1118 break;
1119
1120 default:
1121 /* Other classes need no special treatment. */
1122 break;
1123 }
1124
1125 return t;
1126 }
1127
1128 /* Free tree node. */
1129
1130 void
free_node(tree node)1131 free_node (tree node)
1132 {
1133 enum tree_code code = TREE_CODE (node);
1134 if (GATHER_STATISTICS)
1135 {
1136 enum tree_node_kind kind = get_stats_node_kind (code);
1137
1138 gcc_checking_assert (tree_code_counts[(int) TREE_CODE (node)] != 0);
1139 gcc_checking_assert (tree_node_counts[(int) kind] != 0);
1140 gcc_checking_assert (tree_node_sizes[(int) kind] >= tree_size (node));
1141
1142 tree_code_counts[(int) TREE_CODE (node)]--;
1143 tree_node_counts[(int) kind]--;
1144 tree_node_sizes[(int) kind] -= tree_size (node);
1145 }
1146 if (CODE_CONTAINS_STRUCT (code, TS_CONSTRUCTOR))
1147 vec_free (CONSTRUCTOR_ELTS (node));
1148 else if (code == BLOCK)
1149 vec_free (BLOCK_NONLOCALIZED_VARS (node));
1150 else if (code == TREE_BINFO)
1151 vec_free (BINFO_BASE_ACCESSES (node));
1152 ggc_free (node);
1153 }
1154
1155 /* Return a new node with the same contents as NODE except that its
1156 TREE_CHAIN, if it has one, is zero and it has a fresh uid. */
1157
1158 tree
copy_node(tree node MEM_STAT_DECL)1159 copy_node (tree node MEM_STAT_DECL)
1160 {
1161 tree t;
1162 enum tree_code code = TREE_CODE (node);
1163 size_t length;
1164
1165 gcc_assert (code != STATEMENT_LIST);
1166
1167 length = tree_size (node);
1168 record_node_allocation_statistics (code, length);
1169 t = ggc_alloc_tree_node_stat (length PASS_MEM_STAT);
1170 memcpy (t, node, length);
1171
1172 if (CODE_CONTAINS_STRUCT (code, TS_COMMON))
1173 TREE_CHAIN (t) = 0;
1174 TREE_ASM_WRITTEN (t) = 0;
1175 TREE_VISITED (t) = 0;
1176
1177 if (TREE_CODE_CLASS (code) == tcc_declaration)
1178 {
1179 if (code == DEBUG_EXPR_DECL)
1180 DECL_UID (t) = --next_debug_decl_uid;
1181 else
1182 {
1183 DECL_UID (t) = allocate_decl_uid ();
1184 if (DECL_PT_UID_SET_P (node))
1185 SET_DECL_PT_UID (t, DECL_PT_UID (node));
1186 }
1187 if ((TREE_CODE (node) == PARM_DECL || VAR_P (node))
1188 && DECL_HAS_VALUE_EXPR_P (node))
1189 {
1190 SET_DECL_VALUE_EXPR (t, DECL_VALUE_EXPR (node));
1191 DECL_HAS_VALUE_EXPR_P (t) = 1;
1192 }
1193 /* DECL_DEBUG_EXPR is copied explicitely by callers. */
1194 if (VAR_P (node))
1195 {
1196 DECL_HAS_DEBUG_EXPR_P (t) = 0;
1197 t->decl_with_vis.symtab_node = NULL;
1198 }
1199 if (VAR_P (node) && DECL_HAS_INIT_PRIORITY_P (node))
1200 {
1201 SET_DECL_INIT_PRIORITY (t, DECL_INIT_PRIORITY (node));
1202 DECL_HAS_INIT_PRIORITY_P (t) = 1;
1203 }
1204 if (TREE_CODE (node) == FUNCTION_DECL)
1205 {
1206 DECL_STRUCT_FUNCTION (t) = NULL;
1207 t->decl_with_vis.symtab_node = NULL;
1208 }
1209 }
1210 else if (TREE_CODE_CLASS (code) == tcc_type)
1211 {
1212 TYPE_UID (t) = next_type_uid++;
1213 /* The following is so that the debug code for
1214 the copy is different from the original type.
1215 The two statements usually duplicate each other
1216 (because they clear fields of the same union),
1217 but the optimizer should catch that. */
1218 TYPE_SYMTAB_ADDRESS (t) = 0;
1219 TYPE_SYMTAB_DIE (t) = 0;
1220
1221 /* Do not copy the values cache. */
1222 if (TYPE_CACHED_VALUES_P (t))
1223 {
1224 TYPE_CACHED_VALUES_P (t) = 0;
1225 TYPE_CACHED_VALUES (t) = NULL_TREE;
1226 }
1227 }
1228 else if (code == TARGET_OPTION_NODE)
1229 {
1230 TREE_TARGET_OPTION (t) = ggc_alloc<struct cl_target_option>();
1231 memcpy (TREE_TARGET_OPTION (t), TREE_TARGET_OPTION (node),
1232 sizeof (struct cl_target_option));
1233 }
1234 else if (code == OPTIMIZATION_NODE)
1235 {
1236 TREE_OPTIMIZATION (t) = ggc_alloc<struct cl_optimization>();
1237 memcpy (TREE_OPTIMIZATION (t), TREE_OPTIMIZATION (node),
1238 sizeof (struct cl_optimization));
1239 }
1240
1241 return t;
1242 }
1243
1244 /* Return a copy of a chain of nodes, chained through the TREE_CHAIN field.
1245 For example, this can copy a list made of TREE_LIST nodes. */
1246
1247 tree
copy_list(tree list)1248 copy_list (tree list)
1249 {
1250 tree head;
1251 tree prev, next;
1252
1253 if (list == 0)
1254 return 0;
1255
1256 head = prev = copy_node (list);
1257 next = TREE_CHAIN (list);
1258 while (next)
1259 {
1260 TREE_CHAIN (prev) = copy_node (next);
1261 prev = TREE_CHAIN (prev);
1262 next = TREE_CHAIN (next);
1263 }
1264 return head;
1265 }
1266
1267
1268 /* Return the value that TREE_INT_CST_EXT_NUNITS should have for an
1269 INTEGER_CST with value CST and type TYPE. */
1270
1271 static unsigned int
get_int_cst_ext_nunits(tree type,const wide_int & cst)1272 get_int_cst_ext_nunits (tree type, const wide_int &cst)
1273 {
1274 gcc_checking_assert (cst.get_precision () == TYPE_PRECISION (type));
1275 /* We need extra HWIs if CST is an unsigned integer with its
1276 upper bit set. */
1277 if (TYPE_UNSIGNED (type) && wi::neg_p (cst))
1278 return cst.get_precision () / HOST_BITS_PER_WIDE_INT + 1;
1279 return cst.get_len ();
1280 }
1281
1282 /* Return a new INTEGER_CST with value CST and type TYPE. */
1283
1284 static tree
build_new_int_cst(tree type,const wide_int & cst)1285 build_new_int_cst (tree type, const wide_int &cst)
1286 {
1287 unsigned int len = cst.get_len ();
1288 unsigned int ext_len = get_int_cst_ext_nunits (type, cst);
1289 tree nt = make_int_cst (len, ext_len);
1290
1291 if (len < ext_len)
1292 {
1293 --ext_len;
1294 TREE_INT_CST_ELT (nt, ext_len)
1295 = zext_hwi (-1, cst.get_precision () % HOST_BITS_PER_WIDE_INT);
1296 for (unsigned int i = len; i < ext_len; ++i)
1297 TREE_INT_CST_ELT (nt, i) = -1;
1298 }
1299 else if (TYPE_UNSIGNED (type)
1300 && cst.get_precision () < len * HOST_BITS_PER_WIDE_INT)
1301 {
1302 len--;
1303 TREE_INT_CST_ELT (nt, len)
1304 = zext_hwi (cst.elt (len),
1305 cst.get_precision () % HOST_BITS_PER_WIDE_INT);
1306 }
1307
1308 for (unsigned int i = 0; i < len; i++)
1309 TREE_INT_CST_ELT (nt, i) = cst.elt (i);
1310 TREE_TYPE (nt) = type;
1311 return nt;
1312 }
1313
1314 /* Return a new POLY_INT_CST with coefficients COEFFS and type TYPE. */
1315
1316 static tree
build_new_poly_int_cst(tree type,tree (& coeffs)[NUM_POLY_INT_COEFFS]CXX_MEM_STAT_INFO)1317 build_new_poly_int_cst (tree type, tree (&coeffs)[NUM_POLY_INT_COEFFS]
1318 CXX_MEM_STAT_INFO)
1319 {
1320 size_t length = sizeof (struct tree_poly_int_cst);
1321 record_node_allocation_statistics (POLY_INT_CST, length);
1322
1323 tree t = ggc_alloc_cleared_tree_node_stat (length PASS_MEM_STAT);
1324
1325 TREE_SET_CODE (t, POLY_INT_CST);
1326 TREE_CONSTANT (t) = 1;
1327 TREE_TYPE (t) = type;
1328 for (unsigned int i = 0; i < NUM_POLY_INT_COEFFS; ++i)
1329 POLY_INT_CST_COEFF (t, i) = coeffs[i];
1330 return t;
1331 }
1332
1333 /* Create a constant tree that contains CST sign-extended to TYPE. */
1334
1335 tree
build_int_cst(tree type,poly_int64 cst)1336 build_int_cst (tree type, poly_int64 cst)
1337 {
1338 /* Support legacy code. */
1339 if (!type)
1340 type = integer_type_node;
1341
1342 return wide_int_to_tree (type, wi::shwi (cst, TYPE_PRECISION (type)));
1343 }
1344
1345 /* Create a constant tree that contains CST zero-extended to TYPE. */
1346
1347 tree
build_int_cstu(tree type,poly_uint64 cst)1348 build_int_cstu (tree type, poly_uint64 cst)
1349 {
1350 return wide_int_to_tree (type, wi::uhwi (cst, TYPE_PRECISION (type)));
1351 }
1352
1353 /* Create a constant tree that contains CST sign-extended to TYPE. */
1354
1355 tree
build_int_cst_type(tree type,poly_int64 cst)1356 build_int_cst_type (tree type, poly_int64 cst)
1357 {
1358 gcc_assert (type);
1359 return wide_int_to_tree (type, wi::shwi (cst, TYPE_PRECISION (type)));
1360 }
1361
1362 /* Constructs tree in type TYPE from with value given by CST. Signedness
1363 of CST is assumed to be the same as the signedness of TYPE. */
1364
1365 tree
double_int_to_tree(tree type,double_int cst)1366 double_int_to_tree (tree type, double_int cst)
1367 {
1368 return wide_int_to_tree (type, widest_int::from (cst, TYPE_SIGN (type)));
1369 }
1370
1371 /* We force the wide_int CST to the range of the type TYPE by sign or
1372 zero extending it. OVERFLOWABLE indicates if we are interested in
1373 overflow of the value, when >0 we are only interested in signed
1374 overflow, for <0 we are interested in any overflow. OVERFLOWED
1375 indicates whether overflow has already occurred. CONST_OVERFLOWED
1376 indicates whether constant overflow has already occurred. We force
1377 T's value to be within range of T's type (by setting to 0 or 1 all
1378 the bits outside the type's range). We set TREE_OVERFLOWED if,
1379 OVERFLOWED is nonzero,
1380 or OVERFLOWABLE is >0 and signed overflow occurs
1381 or OVERFLOWABLE is <0 and any overflow occurs
1382 We return a new tree node for the extended wide_int. The node
1383 is shared if no overflow flags are set. */
1384
1385
1386 tree
force_fit_type(tree type,const poly_wide_int_ref & cst,int overflowable,bool overflowed)1387 force_fit_type (tree type, const poly_wide_int_ref &cst,
1388 int overflowable, bool overflowed)
1389 {
1390 signop sign = TYPE_SIGN (type);
1391
1392 /* If we need to set overflow flags, return a new unshared node. */
1393 if (overflowed || !wi::fits_to_tree_p (cst, type))
1394 {
1395 if (overflowed
1396 || overflowable < 0
1397 || (overflowable > 0 && sign == SIGNED))
1398 {
1399 poly_wide_int tmp = poly_wide_int::from (cst, TYPE_PRECISION (type),
1400 sign);
1401 tree t;
1402 if (tmp.is_constant ())
1403 t = build_new_int_cst (type, tmp.coeffs[0]);
1404 else
1405 {
1406 tree coeffs[NUM_POLY_INT_COEFFS];
1407 for (unsigned int i = 0; i < NUM_POLY_INT_COEFFS; ++i)
1408 {
1409 coeffs[i] = build_new_int_cst (type, tmp.coeffs[i]);
1410 TREE_OVERFLOW (coeffs[i]) = 1;
1411 }
1412 t = build_new_poly_int_cst (type, coeffs);
1413 }
1414 TREE_OVERFLOW (t) = 1;
1415 return t;
1416 }
1417 }
1418
1419 /* Else build a shared node. */
1420 return wide_int_to_tree (type, cst);
1421 }
1422
1423 /* These are the hash table functions for the hash table of INTEGER_CST
1424 nodes of a sizetype. */
1425
1426 /* Return the hash code X, an INTEGER_CST. */
1427
1428 hashval_t
hash(tree x)1429 int_cst_hasher::hash (tree x)
1430 {
1431 const_tree const t = x;
1432 hashval_t code = TYPE_UID (TREE_TYPE (t));
1433 int i;
1434
1435 for (i = 0; i < TREE_INT_CST_NUNITS (t); i++)
1436 code = iterative_hash_host_wide_int (TREE_INT_CST_ELT(t, i), code);
1437
1438 return code;
1439 }
1440
1441 /* Return nonzero if the value represented by *X (an INTEGER_CST tree node)
1442 is the same as that given by *Y, which is the same. */
1443
1444 bool
equal(tree x,tree y)1445 int_cst_hasher::equal (tree x, tree y)
1446 {
1447 const_tree const xt = x;
1448 const_tree const yt = y;
1449
1450 if (TREE_TYPE (xt) != TREE_TYPE (yt)
1451 || TREE_INT_CST_NUNITS (xt) != TREE_INT_CST_NUNITS (yt)
1452 || TREE_INT_CST_EXT_NUNITS (xt) != TREE_INT_CST_EXT_NUNITS (yt))
1453 return false;
1454
1455 for (int i = 0; i < TREE_INT_CST_NUNITS (xt); i++)
1456 if (TREE_INT_CST_ELT (xt, i) != TREE_INT_CST_ELT (yt, i))
1457 return false;
1458
1459 return true;
1460 }
1461
1462 /* Create an INT_CST node of TYPE and value CST.
1463 The returned node is always shared. For small integers we use a
1464 per-type vector cache, for larger ones we use a single hash table.
1465 The value is extended from its precision according to the sign of
1466 the type to be a multiple of HOST_BITS_PER_WIDE_INT. This defines
1467 the upper bits and ensures that hashing and value equality based
1468 upon the underlying HOST_WIDE_INTs works without masking. */
1469
1470 static tree
wide_int_to_tree_1(tree type,const wide_int_ref & pcst)1471 wide_int_to_tree_1 (tree type, const wide_int_ref &pcst)
1472 {
1473 tree t;
1474 int ix = -1;
1475 int limit = 0;
1476
1477 gcc_assert (type);
1478 unsigned int prec = TYPE_PRECISION (type);
1479 signop sgn = TYPE_SIGN (type);
1480
1481 /* Verify that everything is canonical. */
1482 int l = pcst.get_len ();
1483 if (l > 1)
1484 {
1485 if (pcst.elt (l - 1) == 0)
1486 gcc_checking_assert (pcst.elt (l - 2) < 0);
1487 if (pcst.elt (l - 1) == HOST_WIDE_INT_M1)
1488 gcc_checking_assert (pcst.elt (l - 2) >= 0);
1489 }
1490
1491 wide_int cst = wide_int::from (pcst, prec, sgn);
1492 unsigned int ext_len = get_int_cst_ext_nunits (type, cst);
1493
1494 if (ext_len == 1)
1495 {
1496 /* We just need to store a single HOST_WIDE_INT. */
1497 HOST_WIDE_INT hwi;
1498 if (TYPE_UNSIGNED (type))
1499 hwi = cst.to_uhwi ();
1500 else
1501 hwi = cst.to_shwi ();
1502
1503 switch (TREE_CODE (type))
1504 {
1505 case NULLPTR_TYPE:
1506 gcc_assert (hwi == 0);
1507 /* Fallthru. */
1508
1509 case POINTER_TYPE:
1510 case REFERENCE_TYPE:
1511 case POINTER_BOUNDS_TYPE:
1512 /* Cache NULL pointer and zero bounds. */
1513 if (hwi == 0)
1514 {
1515 limit = 1;
1516 ix = 0;
1517 }
1518 break;
1519
1520 case BOOLEAN_TYPE:
1521 /* Cache false or true. */
1522 limit = 2;
1523 if (IN_RANGE (hwi, 0, 1))
1524 ix = hwi;
1525 break;
1526
1527 case INTEGER_TYPE:
1528 case OFFSET_TYPE:
1529 if (TYPE_SIGN (type) == UNSIGNED)
1530 {
1531 /* Cache [0, N). */
1532 limit = INTEGER_SHARE_LIMIT;
1533 if (IN_RANGE (hwi, 0, INTEGER_SHARE_LIMIT - 1))
1534 ix = hwi;
1535 }
1536 else
1537 {
1538 /* Cache [-1, N). */
1539 limit = INTEGER_SHARE_LIMIT + 1;
1540 if (IN_RANGE (hwi, -1, INTEGER_SHARE_LIMIT - 1))
1541 ix = hwi + 1;
1542 }
1543 break;
1544
1545 case ENUMERAL_TYPE:
1546 break;
1547
1548 default:
1549 gcc_unreachable ();
1550 }
1551
1552 if (ix >= 0)
1553 {
1554 /* Look for it in the type's vector of small shared ints. */
1555 if (!TYPE_CACHED_VALUES_P (type))
1556 {
1557 TYPE_CACHED_VALUES_P (type) = 1;
1558 TYPE_CACHED_VALUES (type) = make_tree_vec (limit);
1559 }
1560
1561 t = TREE_VEC_ELT (TYPE_CACHED_VALUES (type), ix);
1562 if (t)
1563 /* Make sure no one is clobbering the shared constant. */
1564 gcc_checking_assert (TREE_TYPE (t) == type
1565 && TREE_INT_CST_NUNITS (t) == 1
1566 && TREE_INT_CST_OFFSET_NUNITS (t) == 1
1567 && TREE_INT_CST_EXT_NUNITS (t) == 1
1568 && TREE_INT_CST_ELT (t, 0) == hwi);
1569 else
1570 {
1571 /* Create a new shared int. */
1572 t = build_new_int_cst (type, cst);
1573 TREE_VEC_ELT (TYPE_CACHED_VALUES (type), ix) = t;
1574 }
1575 }
1576 else
1577 {
1578 /* Use the cache of larger shared ints, using int_cst_node as
1579 a temporary. */
1580
1581 TREE_INT_CST_ELT (int_cst_node, 0) = hwi;
1582 TREE_TYPE (int_cst_node) = type;
1583
1584 tree *slot = int_cst_hash_table->find_slot (int_cst_node, INSERT);
1585 t = *slot;
1586 if (!t)
1587 {
1588 /* Insert this one into the hash table. */
1589 t = int_cst_node;
1590 *slot = t;
1591 /* Make a new node for next time round. */
1592 int_cst_node = make_int_cst (1, 1);
1593 }
1594 }
1595 }
1596 else
1597 {
1598 /* The value either hashes properly or we drop it on the floor
1599 for the gc to take care of. There will not be enough of them
1600 to worry about. */
1601
1602 tree nt = build_new_int_cst (type, cst);
1603 tree *slot = int_cst_hash_table->find_slot (nt, INSERT);
1604 t = *slot;
1605 if (!t)
1606 {
1607 /* Insert this one into the hash table. */
1608 t = nt;
1609 *slot = t;
1610 }
1611 else
1612 ggc_free (nt);
1613 }
1614
1615 return t;
1616 }
1617
1618 hashval_t
hash(tree t)1619 poly_int_cst_hasher::hash (tree t)
1620 {
1621 inchash::hash hstate;
1622
1623 hstate.add_int (TYPE_UID (TREE_TYPE (t)));
1624 for (unsigned int i = 0; i < NUM_POLY_INT_COEFFS; ++i)
1625 hstate.add_wide_int (wi::to_wide (POLY_INT_CST_COEFF (t, i)));
1626
1627 return hstate.end ();
1628 }
1629
1630 bool
equal(tree x,const compare_type & y)1631 poly_int_cst_hasher::equal (tree x, const compare_type &y)
1632 {
1633 if (TREE_TYPE (x) != y.first)
1634 return false;
1635 for (unsigned int i = 0; i < NUM_POLY_INT_COEFFS; ++i)
1636 if (wi::to_wide (POLY_INT_CST_COEFF (x, i)) != y.second->coeffs[i])
1637 return false;
1638 return true;
1639 }
1640
1641 /* Build a POLY_INT_CST node with type TYPE and with the elements in VALUES.
1642 The elements must also have type TYPE. */
1643
1644 tree
build_poly_int_cst(tree type,const poly_wide_int_ref & values)1645 build_poly_int_cst (tree type, const poly_wide_int_ref &values)
1646 {
1647 unsigned int prec = TYPE_PRECISION (type);
1648 gcc_assert (prec <= values.coeffs[0].get_precision ());
1649 poly_wide_int c = poly_wide_int::from (values, prec, SIGNED);
1650
1651 inchash::hash h;
1652 h.add_int (TYPE_UID (type));
1653 for (unsigned int i = 0; i < NUM_POLY_INT_COEFFS; ++i)
1654 h.add_wide_int (c.coeffs[i]);
1655 poly_int_cst_hasher::compare_type comp (type, &c);
1656 tree *slot = poly_int_cst_hash_table->find_slot_with_hash (comp, h.end (),
1657 INSERT);
1658 if (*slot == NULL_TREE)
1659 {
1660 tree coeffs[NUM_POLY_INT_COEFFS];
1661 for (unsigned int i = 0; i < NUM_POLY_INT_COEFFS; ++i)
1662 coeffs[i] = wide_int_to_tree_1 (type, c.coeffs[i]);
1663 *slot = build_new_poly_int_cst (type, coeffs);
1664 }
1665 return *slot;
1666 }
1667
1668 /* Create a constant tree with value VALUE in type TYPE. */
1669
1670 tree
wide_int_to_tree(tree type,const poly_wide_int_ref & value)1671 wide_int_to_tree (tree type, const poly_wide_int_ref &value)
1672 {
1673 if (value.is_constant ())
1674 return wide_int_to_tree_1 (type, value.coeffs[0]);
1675 return build_poly_int_cst (type, value);
1676 }
1677
1678 void
cache_integer_cst(tree t)1679 cache_integer_cst (tree t)
1680 {
1681 tree type = TREE_TYPE (t);
1682 int ix = -1;
1683 int limit = 0;
1684 int prec = TYPE_PRECISION (type);
1685
1686 gcc_assert (!TREE_OVERFLOW (t));
1687
1688 switch (TREE_CODE (type))
1689 {
1690 case NULLPTR_TYPE:
1691 gcc_assert (integer_zerop (t));
1692 /* Fallthru. */
1693
1694 case POINTER_TYPE:
1695 case REFERENCE_TYPE:
1696 /* Cache NULL pointer. */
1697 if (integer_zerop (t))
1698 {
1699 limit = 1;
1700 ix = 0;
1701 }
1702 break;
1703
1704 case BOOLEAN_TYPE:
1705 /* Cache false or true. */
1706 limit = 2;
1707 if (wi::ltu_p (wi::to_wide (t), 2))
1708 ix = TREE_INT_CST_ELT (t, 0);
1709 break;
1710
1711 case INTEGER_TYPE:
1712 case OFFSET_TYPE:
1713 if (TYPE_UNSIGNED (type))
1714 {
1715 /* Cache 0..N */
1716 limit = INTEGER_SHARE_LIMIT;
1717
1718 /* This is a little hokie, but if the prec is smaller than
1719 what is necessary to hold INTEGER_SHARE_LIMIT, then the
1720 obvious test will not get the correct answer. */
1721 if (prec < HOST_BITS_PER_WIDE_INT)
1722 {
1723 if (tree_to_uhwi (t) < (unsigned HOST_WIDE_INT) INTEGER_SHARE_LIMIT)
1724 ix = tree_to_uhwi (t);
1725 }
1726 else if (wi::ltu_p (wi::to_wide (t), INTEGER_SHARE_LIMIT))
1727 ix = tree_to_uhwi (t);
1728 }
1729 else
1730 {
1731 /* Cache -1..N */
1732 limit = INTEGER_SHARE_LIMIT + 1;
1733
1734 if (integer_minus_onep (t))
1735 ix = 0;
1736 else if (!wi::neg_p (wi::to_wide (t)))
1737 {
1738 if (prec < HOST_BITS_PER_WIDE_INT)
1739 {
1740 if (tree_to_shwi (t) < INTEGER_SHARE_LIMIT)
1741 ix = tree_to_shwi (t) + 1;
1742 }
1743 else if (wi::ltu_p (wi::to_wide (t), INTEGER_SHARE_LIMIT))
1744 ix = tree_to_shwi (t) + 1;
1745 }
1746 }
1747 break;
1748
1749 case ENUMERAL_TYPE:
1750 break;
1751
1752 default:
1753 gcc_unreachable ();
1754 }
1755
1756 if (ix >= 0)
1757 {
1758 /* Look for it in the type's vector of small shared ints. */
1759 if (!TYPE_CACHED_VALUES_P (type))
1760 {
1761 TYPE_CACHED_VALUES_P (type) = 1;
1762 TYPE_CACHED_VALUES (type) = make_tree_vec (limit);
1763 }
1764
1765 gcc_assert (TREE_VEC_ELT (TYPE_CACHED_VALUES (type), ix) == NULL_TREE);
1766 TREE_VEC_ELT (TYPE_CACHED_VALUES (type), ix) = t;
1767 }
1768 else
1769 {
1770 /* Use the cache of larger shared ints. */
1771 tree *slot = int_cst_hash_table->find_slot (t, INSERT);
1772 /* If there is already an entry for the number verify it's the
1773 same. */
1774 if (*slot)
1775 gcc_assert (wi::to_wide (tree (*slot)) == wi::to_wide (t));
1776 else
1777 /* Otherwise insert this one into the hash table. */
1778 *slot = t;
1779 }
1780 }
1781
1782
1783 /* Builds an integer constant in TYPE such that lowest BITS bits are ones
1784 and the rest are zeros. */
1785
1786 tree
build_low_bits_mask(tree type,unsigned bits)1787 build_low_bits_mask (tree type, unsigned bits)
1788 {
1789 gcc_assert (bits <= TYPE_PRECISION (type));
1790
1791 return wide_int_to_tree (type, wi::mask (bits, false,
1792 TYPE_PRECISION (type)));
1793 }
1794
1795 /* Checks that X is integer constant that can be expressed in (unsigned)
1796 HOST_WIDE_INT without loss of precision. */
1797
1798 bool
cst_and_fits_in_hwi(const_tree x)1799 cst_and_fits_in_hwi (const_tree x)
1800 {
1801 return (TREE_CODE (x) == INTEGER_CST
1802 && (tree_fits_shwi_p (x) || tree_fits_uhwi_p (x)));
1803 }
1804
1805 /* Build a newly constructed VECTOR_CST with the given values of
1806 (VECTOR_CST_)LOG2_NPATTERNS and (VECTOR_CST_)NELTS_PER_PATTERN. */
1807
1808 tree
make_vector(unsigned log2_npatterns,unsigned int nelts_per_pattern MEM_STAT_DECL)1809 make_vector (unsigned log2_npatterns,
1810 unsigned int nelts_per_pattern MEM_STAT_DECL)
1811 {
1812 gcc_assert (IN_RANGE (nelts_per_pattern, 1, 3));
1813 tree t;
1814 unsigned npatterns = 1 << log2_npatterns;
1815 unsigned encoded_nelts = npatterns * nelts_per_pattern;
1816 unsigned length = (sizeof (struct tree_vector)
1817 + (encoded_nelts - 1) * sizeof (tree));
1818
1819 record_node_allocation_statistics (VECTOR_CST, length);
1820
1821 t = ggc_alloc_cleared_tree_node_stat (length PASS_MEM_STAT);
1822
1823 TREE_SET_CODE (t, VECTOR_CST);
1824 TREE_CONSTANT (t) = 1;
1825 VECTOR_CST_LOG2_NPATTERNS (t) = log2_npatterns;
1826 VECTOR_CST_NELTS_PER_PATTERN (t) = nelts_per_pattern;
1827
1828 return t;
1829 }
1830
1831 /* Return a new VECTOR_CST node whose type is TYPE and whose values
1832 are extracted from V, a vector of CONSTRUCTOR_ELT. */
1833
1834 tree
build_vector_from_ctor(tree type,vec<constructor_elt,va_gc> * v)1835 build_vector_from_ctor (tree type, vec<constructor_elt, va_gc> *v)
1836 {
1837 unsigned HOST_WIDE_INT idx, nelts;
1838 tree value;
1839
1840 /* We can't construct a VECTOR_CST for a variable number of elements. */
1841 nelts = TYPE_VECTOR_SUBPARTS (type).to_constant ();
1842 tree_vector_builder vec (type, nelts, 1);
1843 FOR_EACH_CONSTRUCTOR_VALUE (v, idx, value)
1844 {
1845 if (TREE_CODE (value) == VECTOR_CST)
1846 {
1847 /* If NELTS is constant then this must be too. */
1848 unsigned int sub_nelts = VECTOR_CST_NELTS (value).to_constant ();
1849 for (unsigned i = 0; i < sub_nelts; ++i)
1850 vec.quick_push (VECTOR_CST_ELT (value, i));
1851 }
1852 else
1853 vec.quick_push (value);
1854 }
1855 while (vec.length () < nelts)
1856 vec.quick_push (build_zero_cst (TREE_TYPE (type)));
1857
1858 return vec.build ();
1859 }
1860
1861 /* Build a vector of type VECTYPE where all the elements are SCs. */
1862 tree
build_vector_from_val(tree vectype,tree sc)1863 build_vector_from_val (tree vectype, tree sc)
1864 {
1865 unsigned HOST_WIDE_INT i, nunits;
1866
1867 if (sc == error_mark_node)
1868 return sc;
1869
1870 /* Verify that the vector type is suitable for SC. Note that there
1871 is some inconsistency in the type-system with respect to restrict
1872 qualifications of pointers. Vector types always have a main-variant
1873 element type and the qualification is applied to the vector-type.
1874 So TREE_TYPE (vector-type) does not return a properly qualified
1875 vector element-type. */
1876 gcc_checking_assert (types_compatible_p (TYPE_MAIN_VARIANT (TREE_TYPE (sc)),
1877 TREE_TYPE (vectype)));
1878
1879 if (CONSTANT_CLASS_P (sc))
1880 {
1881 tree_vector_builder v (vectype, 1, 1);
1882 v.quick_push (sc);
1883 return v.build ();
1884 }
1885 else if (!TYPE_VECTOR_SUBPARTS (vectype).is_constant (&nunits))
1886 return fold_build1 (VEC_DUPLICATE_EXPR, vectype, sc);
1887 else
1888 {
1889 vec<constructor_elt, va_gc> *v;
1890 vec_alloc (v, nunits);
1891 for (i = 0; i < nunits; ++i)
1892 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, sc);
1893 return build_constructor (vectype, v);
1894 }
1895 }
1896
1897 /* Build a vector series of type TYPE in which element I has the value
1898 BASE + I * STEP. The result is a constant if BASE and STEP are constant
1899 and a VEC_SERIES_EXPR otherwise. */
1900
1901 tree
build_vec_series(tree type,tree base,tree step)1902 build_vec_series (tree type, tree base, tree step)
1903 {
1904 if (integer_zerop (step))
1905 return build_vector_from_val (type, base);
1906 if (TREE_CODE (base) == INTEGER_CST && TREE_CODE (step) == INTEGER_CST)
1907 {
1908 tree_vector_builder builder (type, 1, 3);
1909 tree elt1 = wide_int_to_tree (TREE_TYPE (base),
1910 wi::to_wide (base) + wi::to_wide (step));
1911 tree elt2 = wide_int_to_tree (TREE_TYPE (base),
1912 wi::to_wide (elt1) + wi::to_wide (step));
1913 builder.quick_push (base);
1914 builder.quick_push (elt1);
1915 builder.quick_push (elt2);
1916 return builder.build ();
1917 }
1918 return build2 (VEC_SERIES_EXPR, type, base, step);
1919 }
1920
1921 /* Return a vector with the same number of units and number of bits
1922 as VEC_TYPE, but in which the elements are a linear series of unsigned
1923 integers { BASE, BASE + STEP, BASE + STEP * 2, ... }. */
1924
1925 tree
build_index_vector(tree vec_type,poly_uint64 base,poly_uint64 step)1926 build_index_vector (tree vec_type, poly_uint64 base, poly_uint64 step)
1927 {
1928 tree index_vec_type = vec_type;
1929 tree index_elt_type = TREE_TYPE (vec_type);
1930 poly_uint64 nunits = TYPE_VECTOR_SUBPARTS (vec_type);
1931 if (!INTEGRAL_TYPE_P (index_elt_type) || !TYPE_UNSIGNED (index_elt_type))
1932 {
1933 index_elt_type = build_nonstandard_integer_type
1934 (GET_MODE_BITSIZE (SCALAR_TYPE_MODE (index_elt_type)), true);
1935 index_vec_type = build_vector_type (index_elt_type, nunits);
1936 }
1937
1938 tree_vector_builder v (index_vec_type, 1, 3);
1939 for (unsigned int i = 0; i < 3; ++i)
1940 v.quick_push (build_int_cstu (index_elt_type, base + i * step));
1941 return v.build ();
1942 }
1943
1944 /* Something has messed with the elements of CONSTRUCTOR C after it was built;
1945 calculate TREE_CONSTANT and TREE_SIDE_EFFECTS. */
1946
1947 void
recompute_constructor_flags(tree c)1948 recompute_constructor_flags (tree c)
1949 {
1950 unsigned int i;
1951 tree val;
1952 bool constant_p = true;
1953 bool side_effects_p = false;
1954 vec<constructor_elt, va_gc> *vals = CONSTRUCTOR_ELTS (c);
1955
1956 FOR_EACH_CONSTRUCTOR_VALUE (vals, i, val)
1957 {
1958 /* Mostly ctors will have elts that don't have side-effects, so
1959 the usual case is to scan all the elements. Hence a single
1960 loop for both const and side effects, rather than one loop
1961 each (with early outs). */
1962 if (!TREE_CONSTANT (val))
1963 constant_p = false;
1964 if (TREE_SIDE_EFFECTS (val))
1965 side_effects_p = true;
1966 }
1967
1968 TREE_SIDE_EFFECTS (c) = side_effects_p;
1969 TREE_CONSTANT (c) = constant_p;
1970 }
1971
1972 /* Make sure that TREE_CONSTANT and TREE_SIDE_EFFECTS are correct for
1973 CONSTRUCTOR C. */
1974
1975 void
verify_constructor_flags(tree c)1976 verify_constructor_flags (tree c)
1977 {
1978 unsigned int i;
1979 tree val;
1980 bool constant_p = TREE_CONSTANT (c);
1981 bool side_effects_p = TREE_SIDE_EFFECTS (c);
1982 vec<constructor_elt, va_gc> *vals = CONSTRUCTOR_ELTS (c);
1983
1984 FOR_EACH_CONSTRUCTOR_VALUE (vals, i, val)
1985 {
1986 if (constant_p && !TREE_CONSTANT (val))
1987 internal_error ("non-constant element in constant CONSTRUCTOR");
1988 if (!side_effects_p && TREE_SIDE_EFFECTS (val))
1989 internal_error ("side-effects element in no-side-effects CONSTRUCTOR");
1990 }
1991 }
1992
1993 /* Return a new CONSTRUCTOR node whose type is TYPE and whose values
1994 are in the vec pointed to by VALS. */
1995 tree
build_constructor(tree type,vec<constructor_elt,va_gc> * vals)1996 build_constructor (tree type, vec<constructor_elt, va_gc> *vals)
1997 {
1998 tree c = make_node (CONSTRUCTOR);
1999
2000 TREE_TYPE (c) = type;
2001 CONSTRUCTOR_ELTS (c) = vals;
2002
2003 recompute_constructor_flags (c);
2004
2005 return c;
2006 }
2007
2008 /* Build a CONSTRUCTOR node made of a single initializer, with the specified
2009 INDEX and VALUE. */
2010 tree
build_constructor_single(tree type,tree index,tree value)2011 build_constructor_single (tree type, tree index, tree value)
2012 {
2013 vec<constructor_elt, va_gc> *v;
2014 constructor_elt elt = {index, value};
2015
2016 vec_alloc (v, 1);
2017 v->quick_push (elt);
2018
2019 return build_constructor (type, v);
2020 }
2021
2022
2023 /* Return a new CONSTRUCTOR node whose type is TYPE and whose values
2024 are in a list pointed to by VALS. */
2025 tree
build_constructor_from_list(tree type,tree vals)2026 build_constructor_from_list (tree type, tree vals)
2027 {
2028 tree t;
2029 vec<constructor_elt, va_gc> *v = NULL;
2030
2031 if (vals)
2032 {
2033 vec_alloc (v, list_length (vals));
2034 for (t = vals; t; t = TREE_CHAIN (t))
2035 CONSTRUCTOR_APPEND_ELT (v, TREE_PURPOSE (t), TREE_VALUE (t));
2036 }
2037
2038 return build_constructor (type, v);
2039 }
2040
2041 /* Return a new CONSTRUCTOR node whose type is TYPE. NELTS is the number
2042 of elements, provided as index/value pairs. */
2043
2044 tree
build_constructor_va(tree type,int nelts,...)2045 build_constructor_va (tree type, int nelts, ...)
2046 {
2047 vec<constructor_elt, va_gc> *v = NULL;
2048 va_list p;
2049
2050 va_start (p, nelts);
2051 vec_alloc (v, nelts);
2052 while (nelts--)
2053 {
2054 tree index = va_arg (p, tree);
2055 tree value = va_arg (p, tree);
2056 CONSTRUCTOR_APPEND_ELT (v, index, value);
2057 }
2058 va_end (p);
2059 return build_constructor (type, v);
2060 }
2061
2062 /* Return a new FIXED_CST node whose type is TYPE and value is F. */
2063
2064 tree
build_fixed(tree type,FIXED_VALUE_TYPE f)2065 build_fixed (tree type, FIXED_VALUE_TYPE f)
2066 {
2067 tree v;
2068 FIXED_VALUE_TYPE *fp;
2069
2070 v = make_node (FIXED_CST);
2071 fp = ggc_alloc<fixed_value> ();
2072 memcpy (fp, &f, sizeof (FIXED_VALUE_TYPE));
2073
2074 TREE_TYPE (v) = type;
2075 TREE_FIXED_CST_PTR (v) = fp;
2076 return v;
2077 }
2078
2079 /* Return a new REAL_CST node whose type is TYPE and value is D. */
2080
2081 tree
build_real(tree type,REAL_VALUE_TYPE d)2082 build_real (tree type, REAL_VALUE_TYPE d)
2083 {
2084 tree v;
2085 REAL_VALUE_TYPE *dp;
2086 int overflow = 0;
2087
2088 /* ??? Used to check for overflow here via CHECK_FLOAT_TYPE.
2089 Consider doing it via real_convert now. */
2090
2091 v = make_node (REAL_CST);
2092 dp = ggc_alloc<real_value> ();
2093 memcpy (dp, &d, sizeof (REAL_VALUE_TYPE));
2094
2095 TREE_TYPE (v) = type;
2096 TREE_REAL_CST_PTR (v) = dp;
2097 TREE_OVERFLOW (v) = overflow;
2098 return v;
2099 }
2100
2101 /* Like build_real, but first truncate D to the type. */
2102
2103 tree
build_real_truncate(tree type,REAL_VALUE_TYPE d)2104 build_real_truncate (tree type, REAL_VALUE_TYPE d)
2105 {
2106 return build_real (type, real_value_truncate (TYPE_MODE (type), d));
2107 }
2108
2109 /* Return a new REAL_CST node whose type is TYPE
2110 and whose value is the integer value of the INTEGER_CST node I. */
2111
2112 REAL_VALUE_TYPE
real_value_from_int_cst(const_tree type,const_tree i)2113 real_value_from_int_cst (const_tree type, const_tree i)
2114 {
2115 REAL_VALUE_TYPE d;
2116
2117 /* Clear all bits of the real value type so that we can later do
2118 bitwise comparisons to see if two values are the same. */
2119 memset (&d, 0, sizeof d);
2120
2121 real_from_integer (&d, type ? TYPE_MODE (type) : VOIDmode, wi::to_wide (i),
2122 TYPE_SIGN (TREE_TYPE (i)));
2123 return d;
2124 }
2125
2126 /* Given a tree representing an integer constant I, return a tree
2127 representing the same value as a floating-point constant of type TYPE. */
2128
2129 tree
build_real_from_int_cst(tree type,const_tree i)2130 build_real_from_int_cst (tree type, const_tree i)
2131 {
2132 tree v;
2133 int overflow = TREE_OVERFLOW (i);
2134
2135 v = build_real (type, real_value_from_int_cst (type, i));
2136
2137 TREE_OVERFLOW (v) |= overflow;
2138 return v;
2139 }
2140
2141 /* Return a newly constructed STRING_CST node whose value is
2142 the LEN characters at STR.
2143 Note that for a C string literal, LEN should include the trailing NUL.
2144 The TREE_TYPE is not initialized. */
2145
2146 tree
build_string(int len,const char * str)2147 build_string (int len, const char *str)
2148 {
2149 tree s;
2150 size_t length;
2151
2152 /* Do not waste bytes provided by padding of struct tree_string. */
2153 length = len + offsetof (struct tree_string, str) + 1;
2154
2155 record_node_allocation_statistics (STRING_CST, length);
2156
2157 s = (tree) ggc_internal_alloc (length);
2158
2159 memset (s, 0, sizeof (struct tree_typed));
2160 TREE_SET_CODE (s, STRING_CST);
2161 TREE_CONSTANT (s) = 1;
2162 TREE_STRING_LENGTH (s) = len;
2163 memcpy (s->string.str, str, len);
2164 s->string.str[len] = '\0';
2165
2166 return s;
2167 }
2168
2169 /* Return a newly constructed COMPLEX_CST node whose value is
2170 specified by the real and imaginary parts REAL and IMAG.
2171 Both REAL and IMAG should be constant nodes. TYPE, if specified,
2172 will be the type of the COMPLEX_CST; otherwise a new type will be made. */
2173
2174 tree
build_complex(tree type,tree real,tree imag)2175 build_complex (tree type, tree real, tree imag)
2176 {
2177 tree t = make_node (COMPLEX_CST);
2178
2179 TREE_REALPART (t) = real;
2180 TREE_IMAGPART (t) = imag;
2181 TREE_TYPE (t) = type ? type : build_complex_type (TREE_TYPE (real));
2182 TREE_OVERFLOW (t) = TREE_OVERFLOW (real) | TREE_OVERFLOW (imag);
2183 return t;
2184 }
2185
2186 /* Build a complex (inf +- 0i), such as for the result of cproj.
2187 TYPE is the complex tree type of the result. If NEG is true, the
2188 imaginary zero is negative. */
2189
2190 tree
build_complex_inf(tree type,bool neg)2191 build_complex_inf (tree type, bool neg)
2192 {
2193 REAL_VALUE_TYPE rinf, rzero = dconst0;
2194
2195 real_inf (&rinf);
2196 rzero.sign = neg;
2197 return build_complex (type, build_real (TREE_TYPE (type), rinf),
2198 build_real (TREE_TYPE (type), rzero));
2199 }
2200
2201 /* Return the constant 1 in type TYPE. If TYPE has several elements, each
2202 element is set to 1. In particular, this is 1 + i for complex types. */
2203
2204 tree
build_each_one_cst(tree type)2205 build_each_one_cst (tree type)
2206 {
2207 if (TREE_CODE (type) == COMPLEX_TYPE)
2208 {
2209 tree scalar = build_one_cst (TREE_TYPE (type));
2210 return build_complex (type, scalar, scalar);
2211 }
2212 else
2213 return build_one_cst (type);
2214 }
2215
2216 /* Return a constant of arithmetic type TYPE which is the
2217 multiplicative identity of the set TYPE. */
2218
2219 tree
build_one_cst(tree type)2220 build_one_cst (tree type)
2221 {
2222 switch (TREE_CODE (type))
2223 {
2224 case INTEGER_TYPE: case ENUMERAL_TYPE: case BOOLEAN_TYPE:
2225 case POINTER_TYPE: case REFERENCE_TYPE:
2226 case OFFSET_TYPE:
2227 return build_int_cst (type, 1);
2228
2229 case REAL_TYPE:
2230 return build_real (type, dconst1);
2231
2232 case FIXED_POINT_TYPE:
2233 /* We can only generate 1 for accum types. */
2234 gcc_assert (ALL_SCALAR_ACCUM_MODE_P (TYPE_MODE (type)));
2235 return build_fixed (type, FCONST1 (TYPE_MODE (type)));
2236
2237 case VECTOR_TYPE:
2238 {
2239 tree scalar = build_one_cst (TREE_TYPE (type));
2240
2241 return build_vector_from_val (type, scalar);
2242 }
2243
2244 case COMPLEX_TYPE:
2245 return build_complex (type,
2246 build_one_cst (TREE_TYPE (type)),
2247 build_zero_cst (TREE_TYPE (type)));
2248
2249 default:
2250 gcc_unreachable ();
2251 }
2252 }
2253
2254 /* Return an integer of type TYPE containing all 1's in as much precision as
2255 it contains, or a complex or vector whose subparts are such integers. */
2256
2257 tree
build_all_ones_cst(tree type)2258 build_all_ones_cst (tree type)
2259 {
2260 if (TREE_CODE (type) == COMPLEX_TYPE)
2261 {
2262 tree scalar = build_all_ones_cst (TREE_TYPE (type));
2263 return build_complex (type, scalar, scalar);
2264 }
2265 else
2266 return build_minus_one_cst (type);
2267 }
2268
2269 /* Return a constant of arithmetic type TYPE which is the
2270 opposite of the multiplicative identity of the set TYPE. */
2271
2272 tree
build_minus_one_cst(tree type)2273 build_minus_one_cst (tree type)
2274 {
2275 switch (TREE_CODE (type))
2276 {
2277 case INTEGER_TYPE: case ENUMERAL_TYPE: case BOOLEAN_TYPE:
2278 case POINTER_TYPE: case REFERENCE_TYPE:
2279 case OFFSET_TYPE:
2280 return build_int_cst (type, -1);
2281
2282 case REAL_TYPE:
2283 return build_real (type, dconstm1);
2284
2285 case FIXED_POINT_TYPE:
2286 /* We can only generate 1 for accum types. */
2287 gcc_assert (ALL_SCALAR_ACCUM_MODE_P (TYPE_MODE (type)));
2288 return build_fixed (type,
2289 fixed_from_double_int (double_int_minus_one,
2290 SCALAR_TYPE_MODE (type)));
2291
2292 case VECTOR_TYPE:
2293 {
2294 tree scalar = build_minus_one_cst (TREE_TYPE (type));
2295
2296 return build_vector_from_val (type, scalar);
2297 }
2298
2299 case COMPLEX_TYPE:
2300 return build_complex (type,
2301 build_minus_one_cst (TREE_TYPE (type)),
2302 build_zero_cst (TREE_TYPE (type)));
2303
2304 default:
2305 gcc_unreachable ();
2306 }
2307 }
2308
2309 /* Build 0 constant of type TYPE. This is used by constructor folding
2310 and thus the constant should be represented in memory by
2311 zero(es). */
2312
2313 tree
build_zero_cst(tree type)2314 build_zero_cst (tree type)
2315 {
2316 switch (TREE_CODE (type))
2317 {
2318 case INTEGER_TYPE: case ENUMERAL_TYPE: case BOOLEAN_TYPE:
2319 case POINTER_TYPE: case REFERENCE_TYPE:
2320 case OFFSET_TYPE: case NULLPTR_TYPE:
2321 return build_int_cst (type, 0);
2322
2323 case REAL_TYPE:
2324 return build_real (type, dconst0);
2325
2326 case FIXED_POINT_TYPE:
2327 return build_fixed (type, FCONST0 (TYPE_MODE (type)));
2328
2329 case VECTOR_TYPE:
2330 {
2331 tree scalar = build_zero_cst (TREE_TYPE (type));
2332
2333 return build_vector_from_val (type, scalar);
2334 }
2335
2336 case COMPLEX_TYPE:
2337 {
2338 tree zero = build_zero_cst (TREE_TYPE (type));
2339
2340 return build_complex (type, zero, zero);
2341 }
2342
2343 default:
2344 if (!AGGREGATE_TYPE_P (type))
2345 return fold_convert (type, integer_zero_node);
2346 return build_constructor (type, NULL);
2347 }
2348 }
2349
2350
2351 /* Build a BINFO with LEN language slots. */
2352
2353 tree
make_tree_binfo(unsigned base_binfos MEM_STAT_DECL)2354 make_tree_binfo (unsigned base_binfos MEM_STAT_DECL)
2355 {
2356 tree t;
2357 size_t length = (offsetof (struct tree_binfo, base_binfos)
2358 + vec<tree, va_gc>::embedded_size (base_binfos));
2359
2360 record_node_allocation_statistics (TREE_BINFO, length);
2361
2362 t = ggc_alloc_tree_node_stat (length PASS_MEM_STAT);
2363
2364 memset (t, 0, offsetof (struct tree_binfo, base_binfos));
2365
2366 TREE_SET_CODE (t, TREE_BINFO);
2367
2368 BINFO_BASE_BINFOS (t)->embedded_init (base_binfos);
2369
2370 return t;
2371 }
2372
2373 /* Create a CASE_LABEL_EXPR tree node and return it. */
2374
2375 tree
build_case_label(tree low_value,tree high_value,tree label_decl)2376 build_case_label (tree low_value, tree high_value, tree label_decl)
2377 {
2378 tree t = make_node (CASE_LABEL_EXPR);
2379
2380 TREE_TYPE (t) = void_type_node;
2381 SET_EXPR_LOCATION (t, DECL_SOURCE_LOCATION (label_decl));
2382
2383 CASE_LOW (t) = low_value;
2384 CASE_HIGH (t) = high_value;
2385 CASE_LABEL (t) = label_decl;
2386 CASE_CHAIN (t) = NULL_TREE;
2387
2388 return t;
2389 }
2390
2391 /* Build a newly constructed INTEGER_CST node. LEN and EXT_LEN are the
2392 values of TREE_INT_CST_NUNITS and TREE_INT_CST_EXT_NUNITS respectively.
2393 The latter determines the length of the HOST_WIDE_INT vector. */
2394
2395 tree
make_int_cst(int len,int ext_len MEM_STAT_DECL)2396 make_int_cst (int len, int ext_len MEM_STAT_DECL)
2397 {
2398 tree t;
2399 int length = ((ext_len - 1) * sizeof (HOST_WIDE_INT)
2400 + sizeof (struct tree_int_cst));
2401
2402 gcc_assert (len);
2403 record_node_allocation_statistics (INTEGER_CST, length);
2404
2405 t = ggc_alloc_cleared_tree_node_stat (length PASS_MEM_STAT);
2406
2407 TREE_SET_CODE (t, INTEGER_CST);
2408 TREE_INT_CST_NUNITS (t) = len;
2409 TREE_INT_CST_EXT_NUNITS (t) = ext_len;
2410 /* to_offset can only be applied to trees that are offset_int-sized
2411 or smaller. EXT_LEN is correct if it fits, otherwise the constant
2412 must be exactly the precision of offset_int and so LEN is correct. */
2413 if (ext_len <= OFFSET_INT_ELTS)
2414 TREE_INT_CST_OFFSET_NUNITS (t) = ext_len;
2415 else
2416 TREE_INT_CST_OFFSET_NUNITS (t) = len;
2417
2418 TREE_CONSTANT (t) = 1;
2419
2420 return t;
2421 }
2422
2423 /* Build a newly constructed TREE_VEC node of length LEN. */
2424
2425 tree
make_tree_vec(int len MEM_STAT_DECL)2426 make_tree_vec (int len MEM_STAT_DECL)
2427 {
2428 tree t;
2429 size_t length = (len - 1) * sizeof (tree) + sizeof (struct tree_vec);
2430
2431 record_node_allocation_statistics (TREE_VEC, length);
2432
2433 t = ggc_alloc_cleared_tree_node_stat (length PASS_MEM_STAT);
2434
2435 TREE_SET_CODE (t, TREE_VEC);
2436 TREE_VEC_LENGTH (t) = len;
2437
2438 return t;
2439 }
2440
2441 /* Grow a TREE_VEC node to new length LEN. */
2442
2443 tree
grow_tree_vec(tree v,int len MEM_STAT_DECL)2444 grow_tree_vec (tree v, int len MEM_STAT_DECL)
2445 {
2446 gcc_assert (TREE_CODE (v) == TREE_VEC);
2447
2448 int oldlen = TREE_VEC_LENGTH (v);
2449 gcc_assert (len > oldlen);
2450
2451 size_t oldlength = (oldlen - 1) * sizeof (tree) + sizeof (struct tree_vec);
2452 size_t length = (len - 1) * sizeof (tree) + sizeof (struct tree_vec);
2453
2454 record_node_allocation_statistics (TREE_VEC, length - oldlength);
2455
2456 v = (tree) ggc_realloc (v, length PASS_MEM_STAT);
2457
2458 TREE_VEC_LENGTH (v) = len;
2459
2460 return v;
2461 }
2462
2463 /* Return 1 if EXPR is the constant zero, whether it is integral, float or
2464 fixed, and scalar, complex or vector. */
2465
2466 int
zerop(const_tree expr)2467 zerop (const_tree expr)
2468 {
2469 return (integer_zerop (expr)
2470 || real_zerop (expr)
2471 || fixed_zerop (expr));
2472 }
2473
2474 /* Return 1 if EXPR is the integer constant zero or a complex constant
2475 of zero. */
2476
2477 int
integer_zerop(const_tree expr)2478 integer_zerop (const_tree expr)
2479 {
2480 switch (TREE_CODE (expr))
2481 {
2482 case INTEGER_CST:
2483 return wi::to_wide (expr) == 0;
2484 case COMPLEX_CST:
2485 return (integer_zerop (TREE_REALPART (expr))
2486 && integer_zerop (TREE_IMAGPART (expr)));
2487 case VECTOR_CST:
2488 return (VECTOR_CST_NPATTERNS (expr) == 1
2489 && VECTOR_CST_DUPLICATE_P (expr)
2490 && integer_zerop (VECTOR_CST_ENCODED_ELT (expr, 0)));
2491 default:
2492 return false;
2493 }
2494 }
2495
2496 /* Return 1 if EXPR is the integer constant one or the corresponding
2497 complex constant. */
2498
2499 int
integer_onep(const_tree expr)2500 integer_onep (const_tree expr)
2501 {
2502 switch (TREE_CODE (expr))
2503 {
2504 case INTEGER_CST:
2505 return wi::eq_p (wi::to_widest (expr), 1);
2506 case COMPLEX_CST:
2507 return (integer_onep (TREE_REALPART (expr))
2508 && integer_zerop (TREE_IMAGPART (expr)));
2509 case VECTOR_CST:
2510 return (VECTOR_CST_NPATTERNS (expr) == 1
2511 && VECTOR_CST_DUPLICATE_P (expr)
2512 && integer_onep (VECTOR_CST_ENCODED_ELT (expr, 0)));
2513 default:
2514 return false;
2515 }
2516 }
2517
2518 /* Return 1 if EXPR is the integer constant one. For complex and vector,
2519 return 1 if every piece is the integer constant one. */
2520
2521 int
integer_each_onep(const_tree expr)2522 integer_each_onep (const_tree expr)
2523 {
2524 if (TREE_CODE (expr) == COMPLEX_CST)
2525 return (integer_onep (TREE_REALPART (expr))
2526 && integer_onep (TREE_IMAGPART (expr)));
2527 else
2528 return integer_onep (expr);
2529 }
2530
2531 /* Return 1 if EXPR is an integer containing all 1's in as much precision as
2532 it contains, or a complex or vector whose subparts are such integers. */
2533
2534 int
integer_all_onesp(const_tree expr)2535 integer_all_onesp (const_tree expr)
2536 {
2537 if (TREE_CODE (expr) == COMPLEX_CST
2538 && integer_all_onesp (TREE_REALPART (expr))
2539 && integer_all_onesp (TREE_IMAGPART (expr)))
2540 return 1;
2541
2542 else if (TREE_CODE (expr) == VECTOR_CST)
2543 return (VECTOR_CST_NPATTERNS (expr) == 1
2544 && VECTOR_CST_DUPLICATE_P (expr)
2545 && integer_all_onesp (VECTOR_CST_ENCODED_ELT (expr, 0)));
2546
2547 else if (TREE_CODE (expr) != INTEGER_CST)
2548 return 0;
2549
2550 return (wi::max_value (TYPE_PRECISION (TREE_TYPE (expr)), UNSIGNED)
2551 == wi::to_wide (expr));
2552 }
2553
2554 /* Return 1 if EXPR is the integer constant minus one. */
2555
2556 int
integer_minus_onep(const_tree expr)2557 integer_minus_onep (const_tree expr)
2558 {
2559 if (TREE_CODE (expr) == COMPLEX_CST)
2560 return (integer_all_onesp (TREE_REALPART (expr))
2561 && integer_zerop (TREE_IMAGPART (expr)));
2562 else
2563 return integer_all_onesp (expr);
2564 }
2565
2566 /* Return 1 if EXPR is an integer constant that is a power of 2 (i.e., has only
2567 one bit on). */
2568
2569 int
integer_pow2p(const_tree expr)2570 integer_pow2p (const_tree expr)
2571 {
2572 if (TREE_CODE (expr) == COMPLEX_CST
2573 && integer_pow2p (TREE_REALPART (expr))
2574 && integer_zerop (TREE_IMAGPART (expr)))
2575 return 1;
2576
2577 if (TREE_CODE (expr) != INTEGER_CST)
2578 return 0;
2579
2580 return wi::popcount (wi::to_wide (expr)) == 1;
2581 }
2582
2583 /* Return 1 if EXPR is an integer constant other than zero or a
2584 complex constant other than zero. */
2585
2586 int
integer_nonzerop(const_tree expr)2587 integer_nonzerop (const_tree expr)
2588 {
2589 return ((TREE_CODE (expr) == INTEGER_CST
2590 && wi::to_wide (expr) != 0)
2591 || (TREE_CODE (expr) == COMPLEX_CST
2592 && (integer_nonzerop (TREE_REALPART (expr))
2593 || integer_nonzerop (TREE_IMAGPART (expr)))));
2594 }
2595
2596 /* Return 1 if EXPR is the integer constant one. For vector,
2597 return 1 if every piece is the integer constant minus one
2598 (representing the value TRUE). */
2599
2600 int
integer_truep(const_tree expr)2601 integer_truep (const_tree expr)
2602 {
2603 if (TREE_CODE (expr) == VECTOR_CST)
2604 return integer_all_onesp (expr);
2605 return integer_onep (expr);
2606 }
2607
2608 /* Return 1 if EXPR is the fixed-point constant zero. */
2609
2610 int
fixed_zerop(const_tree expr)2611 fixed_zerop (const_tree expr)
2612 {
2613 return (TREE_CODE (expr) == FIXED_CST
2614 && TREE_FIXED_CST (expr).data.is_zero ());
2615 }
2616
2617 /* Return the power of two represented by a tree node known to be a
2618 power of two. */
2619
2620 int
tree_log2(const_tree expr)2621 tree_log2 (const_tree expr)
2622 {
2623 if (TREE_CODE (expr) == COMPLEX_CST)
2624 return tree_log2 (TREE_REALPART (expr));
2625
2626 return wi::exact_log2 (wi::to_wide (expr));
2627 }
2628
2629 /* Similar, but return the largest integer Y such that 2 ** Y is less
2630 than or equal to EXPR. */
2631
2632 int
tree_floor_log2(const_tree expr)2633 tree_floor_log2 (const_tree expr)
2634 {
2635 if (TREE_CODE (expr) == COMPLEX_CST)
2636 return tree_log2 (TREE_REALPART (expr));
2637
2638 return wi::floor_log2 (wi::to_wide (expr));
2639 }
2640
2641 /* Return number of known trailing zero bits in EXPR, or, if the value of
2642 EXPR is known to be zero, the precision of it's type. */
2643
2644 unsigned int
tree_ctz(const_tree expr)2645 tree_ctz (const_tree expr)
2646 {
2647 if (!INTEGRAL_TYPE_P (TREE_TYPE (expr))
2648 && !POINTER_TYPE_P (TREE_TYPE (expr)))
2649 return 0;
2650
2651 unsigned int ret1, ret2, prec = TYPE_PRECISION (TREE_TYPE (expr));
2652 switch (TREE_CODE (expr))
2653 {
2654 case INTEGER_CST:
2655 ret1 = wi::ctz (wi::to_wide (expr));
2656 return MIN (ret1, prec);
2657 case SSA_NAME:
2658 ret1 = wi::ctz (get_nonzero_bits (expr));
2659 return MIN (ret1, prec);
2660 case PLUS_EXPR:
2661 case MINUS_EXPR:
2662 case BIT_IOR_EXPR:
2663 case BIT_XOR_EXPR:
2664 case MIN_EXPR:
2665 case MAX_EXPR:
2666 ret1 = tree_ctz (TREE_OPERAND (expr, 0));
2667 if (ret1 == 0)
2668 return ret1;
2669 ret2 = tree_ctz (TREE_OPERAND (expr, 1));
2670 return MIN (ret1, ret2);
2671 case POINTER_PLUS_EXPR:
2672 ret1 = tree_ctz (TREE_OPERAND (expr, 0));
2673 ret2 = tree_ctz (TREE_OPERAND (expr, 1));
2674 /* Second operand is sizetype, which could be in theory
2675 wider than pointer's precision. Make sure we never
2676 return more than prec. */
2677 ret2 = MIN (ret2, prec);
2678 return MIN (ret1, ret2);
2679 case BIT_AND_EXPR:
2680 ret1 = tree_ctz (TREE_OPERAND (expr, 0));
2681 ret2 = tree_ctz (TREE_OPERAND (expr, 1));
2682 return MAX (ret1, ret2);
2683 case MULT_EXPR:
2684 ret1 = tree_ctz (TREE_OPERAND (expr, 0));
2685 ret2 = tree_ctz (TREE_OPERAND (expr, 1));
2686 return MIN (ret1 + ret2, prec);
2687 case LSHIFT_EXPR:
2688 ret1 = tree_ctz (TREE_OPERAND (expr, 0));
2689 if (tree_fits_uhwi_p (TREE_OPERAND (expr, 1))
2690 && (tree_to_uhwi (TREE_OPERAND (expr, 1)) < prec))
2691 {
2692 ret2 = tree_to_uhwi (TREE_OPERAND (expr, 1));
2693 return MIN (ret1 + ret2, prec);
2694 }
2695 return ret1;
2696 case RSHIFT_EXPR:
2697 if (tree_fits_uhwi_p (TREE_OPERAND (expr, 1))
2698 && (tree_to_uhwi (TREE_OPERAND (expr, 1)) < prec))
2699 {
2700 ret1 = tree_ctz (TREE_OPERAND (expr, 0));
2701 ret2 = tree_to_uhwi (TREE_OPERAND (expr, 1));
2702 if (ret1 > ret2)
2703 return ret1 - ret2;
2704 }
2705 return 0;
2706 case TRUNC_DIV_EXPR:
2707 case CEIL_DIV_EXPR:
2708 case FLOOR_DIV_EXPR:
2709 case ROUND_DIV_EXPR:
2710 case EXACT_DIV_EXPR:
2711 if (TREE_CODE (TREE_OPERAND (expr, 1)) == INTEGER_CST
2712 && tree_int_cst_sgn (TREE_OPERAND (expr, 1)) == 1)
2713 {
2714 int l = tree_log2 (TREE_OPERAND (expr, 1));
2715 if (l >= 0)
2716 {
2717 ret1 = tree_ctz (TREE_OPERAND (expr, 0));
2718 ret2 = l;
2719 if (ret1 > ret2)
2720 return ret1 - ret2;
2721 }
2722 }
2723 return 0;
2724 CASE_CONVERT:
2725 ret1 = tree_ctz (TREE_OPERAND (expr, 0));
2726 if (ret1 && ret1 == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (expr, 0))))
2727 ret1 = prec;
2728 return MIN (ret1, prec);
2729 case SAVE_EXPR:
2730 return tree_ctz (TREE_OPERAND (expr, 0));
2731 case COND_EXPR:
2732 ret1 = tree_ctz (TREE_OPERAND (expr, 1));
2733 if (ret1 == 0)
2734 return 0;
2735 ret2 = tree_ctz (TREE_OPERAND (expr, 2));
2736 return MIN (ret1, ret2);
2737 case COMPOUND_EXPR:
2738 return tree_ctz (TREE_OPERAND (expr, 1));
2739 case ADDR_EXPR:
2740 ret1 = get_pointer_alignment (CONST_CAST_TREE (expr));
2741 if (ret1 > BITS_PER_UNIT)
2742 {
2743 ret1 = ctz_hwi (ret1 / BITS_PER_UNIT);
2744 return MIN (ret1, prec);
2745 }
2746 return 0;
2747 default:
2748 return 0;
2749 }
2750 }
2751
2752 /* Return 1 if EXPR is the real constant zero. Trailing zeroes matter for
2753 decimal float constants, so don't return 1 for them. */
2754
2755 int
real_zerop(const_tree expr)2756 real_zerop (const_tree expr)
2757 {
2758 switch (TREE_CODE (expr))
2759 {
2760 case REAL_CST:
2761 return real_equal (&TREE_REAL_CST (expr), &dconst0)
2762 && !(DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (expr))));
2763 case COMPLEX_CST:
2764 return real_zerop (TREE_REALPART (expr))
2765 && real_zerop (TREE_IMAGPART (expr));
2766 case VECTOR_CST:
2767 {
2768 /* Don't simply check for a duplicate because the predicate
2769 accepts both +0.0 and -0.0. */
2770 unsigned count = vector_cst_encoded_nelts (expr);
2771 for (unsigned int i = 0; i < count; ++i)
2772 if (!real_zerop (VECTOR_CST_ENCODED_ELT (expr, i)))
2773 return false;
2774 return true;
2775 }
2776 default:
2777 return false;
2778 }
2779 }
2780
2781 /* Return 1 if EXPR is the real constant one in real or complex form.
2782 Trailing zeroes matter for decimal float constants, so don't return
2783 1 for them. */
2784
2785 int
real_onep(const_tree expr)2786 real_onep (const_tree expr)
2787 {
2788 switch (TREE_CODE (expr))
2789 {
2790 case REAL_CST:
2791 return real_equal (&TREE_REAL_CST (expr), &dconst1)
2792 && !(DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (expr))));
2793 case COMPLEX_CST:
2794 return real_onep (TREE_REALPART (expr))
2795 && real_zerop (TREE_IMAGPART (expr));
2796 case VECTOR_CST:
2797 return (VECTOR_CST_NPATTERNS (expr) == 1
2798 && VECTOR_CST_DUPLICATE_P (expr)
2799 && real_onep (VECTOR_CST_ENCODED_ELT (expr, 0)));
2800 default:
2801 return false;
2802 }
2803 }
2804
2805 /* Return 1 if EXPR is the real constant minus one. Trailing zeroes
2806 matter for decimal float constants, so don't return 1 for them. */
2807
2808 int
real_minus_onep(const_tree expr)2809 real_minus_onep (const_tree expr)
2810 {
2811 switch (TREE_CODE (expr))
2812 {
2813 case REAL_CST:
2814 return real_equal (&TREE_REAL_CST (expr), &dconstm1)
2815 && !(DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (expr))));
2816 case COMPLEX_CST:
2817 return real_minus_onep (TREE_REALPART (expr))
2818 && real_zerop (TREE_IMAGPART (expr));
2819 case VECTOR_CST:
2820 return (VECTOR_CST_NPATTERNS (expr) == 1
2821 && VECTOR_CST_DUPLICATE_P (expr)
2822 && real_minus_onep (VECTOR_CST_ENCODED_ELT (expr, 0)));
2823 default:
2824 return false;
2825 }
2826 }
2827
2828 /* Nonzero if EXP is a constant or a cast of a constant. */
2829
2830 int
really_constant_p(const_tree exp)2831 really_constant_p (const_tree exp)
2832 {
2833 /* This is not quite the same as STRIP_NOPS. It does more. */
2834 while (CONVERT_EXPR_P (exp)
2835 || TREE_CODE (exp) == NON_LVALUE_EXPR)
2836 exp = TREE_OPERAND (exp, 0);
2837 return TREE_CONSTANT (exp);
2838 }
2839
2840 /* Return true if T holds a polynomial pointer difference, storing it in
2841 *VALUE if so. A true return means that T's precision is no greater
2842 than 64 bits, which is the largest address space we support, so *VALUE
2843 never loses precision. However, the signedness of the result does
2844 not necessarily match the signedness of T: sometimes an unsigned type
2845 like sizetype is used to encode a value that is actually negative. */
2846
2847 bool
ptrdiff_tree_p(const_tree t,poly_int64_pod * value)2848 ptrdiff_tree_p (const_tree t, poly_int64_pod *value)
2849 {
2850 if (!t)
2851 return false;
2852 if (TREE_CODE (t) == INTEGER_CST)
2853 {
2854 if (!cst_and_fits_in_hwi (t))
2855 return false;
2856 *value = int_cst_value (t);
2857 return true;
2858 }
2859 if (POLY_INT_CST_P (t))
2860 {
2861 for (unsigned int i = 0; i < NUM_POLY_INT_COEFFS; ++i)
2862 if (!cst_and_fits_in_hwi (POLY_INT_CST_COEFF (t, i)))
2863 return false;
2864 for (unsigned int i = 0; i < NUM_POLY_INT_COEFFS; ++i)
2865 value->coeffs[i] = int_cst_value (POLY_INT_CST_COEFF (t, i));
2866 return true;
2867 }
2868 return false;
2869 }
2870
2871 poly_int64
tree_to_poly_int64(const_tree t)2872 tree_to_poly_int64 (const_tree t)
2873 {
2874 gcc_assert (tree_fits_poly_int64_p (t));
2875 if (POLY_INT_CST_P (t))
2876 return poly_int_cst_value (t).force_shwi ();
2877 return TREE_INT_CST_LOW (t);
2878 }
2879
2880 poly_uint64
tree_to_poly_uint64(const_tree t)2881 tree_to_poly_uint64 (const_tree t)
2882 {
2883 gcc_assert (tree_fits_poly_uint64_p (t));
2884 if (POLY_INT_CST_P (t))
2885 return poly_int_cst_value (t).force_uhwi ();
2886 return TREE_INT_CST_LOW (t);
2887 }
2888
2889 /* Return first list element whose TREE_VALUE is ELEM.
2890 Return 0 if ELEM is not in LIST. */
2891
2892 tree
value_member(tree elem,tree list)2893 value_member (tree elem, tree list)
2894 {
2895 while (list)
2896 {
2897 if (elem == TREE_VALUE (list))
2898 return list;
2899 list = TREE_CHAIN (list);
2900 }
2901 return NULL_TREE;
2902 }
2903
2904 /* Return first list element whose TREE_PURPOSE is ELEM.
2905 Return 0 if ELEM is not in LIST. */
2906
2907 tree
purpose_member(const_tree elem,tree list)2908 purpose_member (const_tree elem, tree list)
2909 {
2910 while (list)
2911 {
2912 if (elem == TREE_PURPOSE (list))
2913 return list;
2914 list = TREE_CHAIN (list);
2915 }
2916 return NULL_TREE;
2917 }
2918
2919 /* Return true if ELEM is in V. */
2920
2921 bool
vec_member(const_tree elem,vec<tree,va_gc> * v)2922 vec_member (const_tree elem, vec<tree, va_gc> *v)
2923 {
2924 unsigned ix;
2925 tree t;
2926 FOR_EACH_VEC_SAFE_ELT (v, ix, t)
2927 if (elem == t)
2928 return true;
2929 return false;
2930 }
2931
2932 /* Returns element number IDX (zero-origin) of chain CHAIN, or
2933 NULL_TREE. */
2934
2935 tree
chain_index(int idx,tree chain)2936 chain_index (int idx, tree chain)
2937 {
2938 for (; chain && idx > 0; --idx)
2939 chain = TREE_CHAIN (chain);
2940 return chain;
2941 }
2942
2943 /* Return nonzero if ELEM is part of the chain CHAIN. */
2944
2945 int
chain_member(const_tree elem,const_tree chain)2946 chain_member (const_tree elem, const_tree chain)
2947 {
2948 while (chain)
2949 {
2950 if (elem == chain)
2951 return 1;
2952 chain = DECL_CHAIN (chain);
2953 }
2954
2955 return 0;
2956 }
2957
2958 /* Return the length of a chain of nodes chained through TREE_CHAIN.
2959 We expect a null pointer to mark the end of the chain.
2960 This is the Lisp primitive `length'. */
2961
2962 int
list_length(const_tree t)2963 list_length (const_tree t)
2964 {
2965 const_tree p = t;
2966 #ifdef ENABLE_TREE_CHECKING
2967 const_tree q = t;
2968 #endif
2969 int len = 0;
2970
2971 while (p)
2972 {
2973 p = TREE_CHAIN (p);
2974 #ifdef ENABLE_TREE_CHECKING
2975 if (len % 2)
2976 q = TREE_CHAIN (q);
2977 gcc_assert (p != q);
2978 #endif
2979 len++;
2980 }
2981
2982 return len;
2983 }
2984
2985 /* Returns the first FIELD_DECL in the TYPE_FIELDS of the RECORD_TYPE or
2986 UNION_TYPE TYPE, or NULL_TREE if none. */
2987
2988 tree
first_field(const_tree type)2989 first_field (const_tree type)
2990 {
2991 tree t = TYPE_FIELDS (type);
2992 while (t && TREE_CODE (t) != FIELD_DECL)
2993 t = TREE_CHAIN (t);
2994 return t;
2995 }
2996
2997 /* Concatenate two chains of nodes (chained through TREE_CHAIN)
2998 by modifying the last node in chain 1 to point to chain 2.
2999 This is the Lisp primitive `nconc'. */
3000
3001 tree
chainon(tree op1,tree op2)3002 chainon (tree op1, tree op2)
3003 {
3004 tree t1;
3005
3006 if (!op1)
3007 return op2;
3008 if (!op2)
3009 return op1;
3010
3011 for (t1 = op1; TREE_CHAIN (t1); t1 = TREE_CHAIN (t1))
3012 continue;
3013 TREE_CHAIN (t1) = op2;
3014
3015 #ifdef ENABLE_TREE_CHECKING
3016 {
3017 tree t2;
3018 for (t2 = op2; t2; t2 = TREE_CHAIN (t2))
3019 gcc_assert (t2 != t1);
3020 }
3021 #endif
3022
3023 return op1;
3024 }
3025
3026 /* Return the last node in a chain of nodes (chained through TREE_CHAIN). */
3027
3028 tree
tree_last(tree chain)3029 tree_last (tree chain)
3030 {
3031 tree next;
3032 if (chain)
3033 while ((next = TREE_CHAIN (chain)))
3034 chain = next;
3035 return chain;
3036 }
3037
3038 /* Reverse the order of elements in the chain T,
3039 and return the new head of the chain (old last element). */
3040
3041 tree
nreverse(tree t)3042 nreverse (tree t)
3043 {
3044 tree prev = 0, decl, next;
3045 for (decl = t; decl; decl = next)
3046 {
3047 /* We shouldn't be using this function to reverse BLOCK chains; we
3048 have blocks_nreverse for that. */
3049 gcc_checking_assert (TREE_CODE (decl) != BLOCK);
3050 next = TREE_CHAIN (decl);
3051 TREE_CHAIN (decl) = prev;
3052 prev = decl;
3053 }
3054 return prev;
3055 }
3056
3057 /* Return a newly created TREE_LIST node whose
3058 purpose and value fields are PARM and VALUE. */
3059
3060 tree
build_tree_list(tree parm,tree value MEM_STAT_DECL)3061 build_tree_list (tree parm, tree value MEM_STAT_DECL)
3062 {
3063 tree t = make_node (TREE_LIST PASS_MEM_STAT);
3064 TREE_PURPOSE (t) = parm;
3065 TREE_VALUE (t) = value;
3066 return t;
3067 }
3068
3069 /* Build a chain of TREE_LIST nodes from a vector. */
3070
3071 tree
build_tree_list_vec(const vec<tree,va_gc> * vec MEM_STAT_DECL)3072 build_tree_list_vec (const vec<tree, va_gc> *vec MEM_STAT_DECL)
3073 {
3074 tree ret = NULL_TREE;
3075 tree *pp = &ret;
3076 unsigned int i;
3077 tree t;
3078 FOR_EACH_VEC_SAFE_ELT (vec, i, t)
3079 {
3080 *pp = build_tree_list (NULL, t PASS_MEM_STAT);
3081 pp = &TREE_CHAIN (*pp);
3082 }
3083 return ret;
3084 }
3085
3086 /* Return a newly created TREE_LIST node whose
3087 purpose and value fields are PURPOSE and VALUE
3088 and whose TREE_CHAIN is CHAIN. */
3089
3090 tree
tree_cons(tree purpose,tree value,tree chain MEM_STAT_DECL)3091 tree_cons (tree purpose, tree value, tree chain MEM_STAT_DECL)
3092 {
3093 tree node;
3094
3095 node = ggc_alloc_tree_node_stat (sizeof (struct tree_list) PASS_MEM_STAT);
3096 memset (node, 0, sizeof (struct tree_common));
3097
3098 record_node_allocation_statistics (TREE_LIST, sizeof (struct tree_list));
3099
3100 TREE_SET_CODE (node, TREE_LIST);
3101 TREE_CHAIN (node) = chain;
3102 TREE_PURPOSE (node) = purpose;
3103 TREE_VALUE (node) = value;
3104 return node;
3105 }
3106
3107 /* Return the values of the elements of a CONSTRUCTOR as a vector of
3108 trees. */
3109
3110 vec<tree, va_gc> *
ctor_to_vec(tree ctor)3111 ctor_to_vec (tree ctor)
3112 {
3113 vec<tree, va_gc> *vec;
3114 vec_alloc (vec, CONSTRUCTOR_NELTS (ctor));
3115 unsigned int ix;
3116 tree val;
3117
3118 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (ctor), ix, val)
3119 vec->quick_push (val);
3120
3121 return vec;
3122 }
3123
3124 /* Return the size nominally occupied by an object of type TYPE
3125 when it resides in memory. The value is measured in units of bytes,
3126 and its data type is that normally used for type sizes
3127 (which is the first type created by make_signed_type or
3128 make_unsigned_type). */
3129
3130 tree
size_in_bytes_loc(location_t loc,const_tree type)3131 size_in_bytes_loc (location_t loc, const_tree type)
3132 {
3133 tree t;
3134
3135 if (type == error_mark_node)
3136 return integer_zero_node;
3137
3138 type = TYPE_MAIN_VARIANT (type);
3139 t = TYPE_SIZE_UNIT (type);
3140
3141 if (t == 0)
3142 {
3143 lang_hooks.types.incomplete_type_error (loc, NULL_TREE, type);
3144 return size_zero_node;
3145 }
3146
3147 return t;
3148 }
3149
3150 /* Return the size of TYPE (in bytes) as a wide integer
3151 or return -1 if the size can vary or is larger than an integer. */
3152
3153 HOST_WIDE_INT
int_size_in_bytes(const_tree type)3154 int_size_in_bytes (const_tree type)
3155 {
3156 tree t;
3157
3158 if (type == error_mark_node)
3159 return 0;
3160
3161 type = TYPE_MAIN_VARIANT (type);
3162 t = TYPE_SIZE_UNIT (type);
3163
3164 if (t && tree_fits_uhwi_p (t))
3165 return TREE_INT_CST_LOW (t);
3166 else
3167 return -1;
3168 }
3169
3170 /* Return the maximum size of TYPE (in bytes) as a wide integer
3171 or return -1 if the size can vary or is larger than an integer. */
3172
3173 HOST_WIDE_INT
max_int_size_in_bytes(const_tree type)3174 max_int_size_in_bytes (const_tree type)
3175 {
3176 HOST_WIDE_INT size = -1;
3177 tree size_tree;
3178
3179 /* If this is an array type, check for a possible MAX_SIZE attached. */
3180
3181 if (TREE_CODE (type) == ARRAY_TYPE)
3182 {
3183 size_tree = TYPE_ARRAY_MAX_SIZE (type);
3184
3185 if (size_tree && tree_fits_uhwi_p (size_tree))
3186 size = tree_to_uhwi (size_tree);
3187 }
3188
3189 /* If we still haven't been able to get a size, see if the language
3190 can compute a maximum size. */
3191
3192 if (size == -1)
3193 {
3194 size_tree = lang_hooks.types.max_size (type);
3195
3196 if (size_tree && tree_fits_uhwi_p (size_tree))
3197 size = tree_to_uhwi (size_tree);
3198 }
3199
3200 return size;
3201 }
3202
3203 /* Return the bit position of FIELD, in bits from the start of the record.
3204 This is a tree of type bitsizetype. */
3205
3206 tree
bit_position(const_tree field)3207 bit_position (const_tree field)
3208 {
3209 return bit_from_pos (DECL_FIELD_OFFSET (field),
3210 DECL_FIELD_BIT_OFFSET (field));
3211 }
3212
3213 /* Return the byte position of FIELD, in bytes from the start of the record.
3214 This is a tree of type sizetype. */
3215
3216 tree
byte_position(const_tree field)3217 byte_position (const_tree field)
3218 {
3219 return byte_from_pos (DECL_FIELD_OFFSET (field),
3220 DECL_FIELD_BIT_OFFSET (field));
3221 }
3222
3223 /* Likewise, but return as an integer. It must be representable in
3224 that way (since it could be a signed value, we don't have the
3225 option of returning -1 like int_size_in_byte can. */
3226
3227 HOST_WIDE_INT
int_byte_position(const_tree field)3228 int_byte_position (const_tree field)
3229 {
3230 return tree_to_shwi (byte_position (field));
3231 }
3232
3233 /* Return the strictest alignment, in bits, that T is known to have. */
3234
3235 unsigned int
expr_align(const_tree t)3236 expr_align (const_tree t)
3237 {
3238 unsigned int align0, align1;
3239
3240 switch (TREE_CODE (t))
3241 {
3242 CASE_CONVERT: case NON_LVALUE_EXPR:
3243 /* If we have conversions, we know that the alignment of the
3244 object must meet each of the alignments of the types. */
3245 align0 = expr_align (TREE_OPERAND (t, 0));
3246 align1 = TYPE_ALIGN (TREE_TYPE (t));
3247 return MAX (align0, align1);
3248
3249 case SAVE_EXPR: case COMPOUND_EXPR: case MODIFY_EXPR:
3250 case INIT_EXPR: case TARGET_EXPR: case WITH_CLEANUP_EXPR:
3251 case CLEANUP_POINT_EXPR:
3252 /* These don't change the alignment of an object. */
3253 return expr_align (TREE_OPERAND (t, 0));
3254
3255 case COND_EXPR:
3256 /* The best we can do is say that the alignment is the least aligned
3257 of the two arms. */
3258 align0 = expr_align (TREE_OPERAND (t, 1));
3259 align1 = expr_align (TREE_OPERAND (t, 2));
3260 return MIN (align0, align1);
3261
3262 /* FIXME: LABEL_DECL and CONST_DECL never have DECL_ALIGN set
3263 meaningfully, it's always 1. */
3264 case LABEL_DECL: case CONST_DECL:
3265 case VAR_DECL: case PARM_DECL: case RESULT_DECL:
3266 case FUNCTION_DECL:
3267 gcc_assert (DECL_ALIGN (t) != 0);
3268 return DECL_ALIGN (t);
3269
3270 default:
3271 break;
3272 }
3273
3274 /* Otherwise take the alignment from that of the type. */
3275 return TYPE_ALIGN (TREE_TYPE (t));
3276 }
3277
3278 /* Return, as a tree node, the number of elements for TYPE (which is an
3279 ARRAY_TYPE) minus one. This counts only elements of the top array. */
3280
3281 tree
array_type_nelts(const_tree type)3282 array_type_nelts (const_tree type)
3283 {
3284 tree index_type, min, max;
3285
3286 /* If they did it with unspecified bounds, then we should have already
3287 given an error about it before we got here. */
3288 if (! TYPE_DOMAIN (type))
3289 return error_mark_node;
3290
3291 index_type = TYPE_DOMAIN (type);
3292 min = TYPE_MIN_VALUE (index_type);
3293 max = TYPE_MAX_VALUE (index_type);
3294
3295 /* TYPE_MAX_VALUE may not be set if the array has unknown length. */
3296 if (!max)
3297 return error_mark_node;
3298
3299 return (integer_zerop (min)
3300 ? max
3301 : fold_build2 (MINUS_EXPR, TREE_TYPE (max), max, min));
3302 }
3303
3304 /* If arg is static -- a reference to an object in static storage -- then
3305 return the object. This is not the same as the C meaning of `static'.
3306 If arg isn't static, return NULL. */
3307
3308 tree
staticp(tree arg)3309 staticp (tree arg)
3310 {
3311 switch (TREE_CODE (arg))
3312 {
3313 case FUNCTION_DECL:
3314 /* Nested functions are static, even though taking their address will
3315 involve a trampoline as we unnest the nested function and create
3316 the trampoline on the tree level. */
3317 return arg;
3318
3319 case VAR_DECL:
3320 return ((TREE_STATIC (arg) || DECL_EXTERNAL (arg))
3321 && ! DECL_THREAD_LOCAL_P (arg)
3322 && ! DECL_DLLIMPORT_P (arg)
3323 ? arg : NULL);
3324
3325 case CONST_DECL:
3326 return ((TREE_STATIC (arg) || DECL_EXTERNAL (arg))
3327 ? arg : NULL);
3328
3329 case CONSTRUCTOR:
3330 return TREE_STATIC (arg) ? arg : NULL;
3331
3332 case LABEL_DECL:
3333 case STRING_CST:
3334 return arg;
3335
3336 case COMPONENT_REF:
3337 /* If the thing being referenced is not a field, then it is
3338 something language specific. */
3339 gcc_assert (TREE_CODE (TREE_OPERAND (arg, 1)) == FIELD_DECL);
3340
3341 /* If we are referencing a bitfield, we can't evaluate an
3342 ADDR_EXPR at compile time and so it isn't a constant. */
3343 if (DECL_BIT_FIELD (TREE_OPERAND (arg, 1)))
3344 return NULL;
3345
3346 return staticp (TREE_OPERAND (arg, 0));
3347
3348 case BIT_FIELD_REF:
3349 return NULL;
3350
3351 case INDIRECT_REF:
3352 return TREE_CONSTANT (TREE_OPERAND (arg, 0)) ? arg : NULL;
3353
3354 case ARRAY_REF:
3355 case ARRAY_RANGE_REF:
3356 if (TREE_CODE (TYPE_SIZE (TREE_TYPE (arg))) == INTEGER_CST
3357 && TREE_CODE (TREE_OPERAND (arg, 1)) == INTEGER_CST)
3358 return staticp (TREE_OPERAND (arg, 0));
3359 else
3360 return NULL;
3361
3362 case COMPOUND_LITERAL_EXPR:
3363 return TREE_STATIC (COMPOUND_LITERAL_EXPR_DECL (arg)) ? arg : NULL;
3364
3365 default:
3366 return NULL;
3367 }
3368 }
3369
3370
3371
3372
3373 /* Return whether OP is a DECL whose address is function-invariant. */
3374
3375 bool
decl_address_invariant_p(const_tree op)3376 decl_address_invariant_p (const_tree op)
3377 {
3378 /* The conditions below are slightly less strict than the one in
3379 staticp. */
3380
3381 switch (TREE_CODE (op))
3382 {
3383 case PARM_DECL:
3384 case RESULT_DECL:
3385 case LABEL_DECL:
3386 case FUNCTION_DECL:
3387 return true;
3388
3389 case VAR_DECL:
3390 if ((TREE_STATIC (op) || DECL_EXTERNAL (op))
3391 || DECL_THREAD_LOCAL_P (op)
3392 || DECL_CONTEXT (op) == current_function_decl
3393 || decl_function_context (op) == current_function_decl)
3394 return true;
3395 break;
3396
3397 case CONST_DECL:
3398 if ((TREE_STATIC (op) || DECL_EXTERNAL (op))
3399 || decl_function_context (op) == current_function_decl)
3400 return true;
3401 break;
3402
3403 default:
3404 break;
3405 }
3406
3407 return false;
3408 }
3409
3410 /* Return whether OP is a DECL whose address is interprocedural-invariant. */
3411
3412 bool
decl_address_ip_invariant_p(const_tree op)3413 decl_address_ip_invariant_p (const_tree op)
3414 {
3415 /* The conditions below are slightly less strict than the one in
3416 staticp. */
3417
3418 switch (TREE_CODE (op))
3419 {
3420 case LABEL_DECL:
3421 case FUNCTION_DECL:
3422 case STRING_CST:
3423 return true;
3424
3425 case VAR_DECL:
3426 if (((TREE_STATIC (op) || DECL_EXTERNAL (op))
3427 && !DECL_DLLIMPORT_P (op))
3428 || DECL_THREAD_LOCAL_P (op))
3429 return true;
3430 break;
3431
3432 case CONST_DECL:
3433 if ((TREE_STATIC (op) || DECL_EXTERNAL (op)))
3434 return true;
3435 break;
3436
3437 default:
3438 break;
3439 }
3440
3441 return false;
3442 }
3443
3444
3445 /* Return true if T is function-invariant (internal function, does
3446 not handle arithmetic; that's handled in skip_simple_arithmetic and
3447 tree_invariant_p). */
3448
3449 static bool
tree_invariant_p_1(tree t)3450 tree_invariant_p_1 (tree t)
3451 {
3452 tree op;
3453
3454 if (TREE_CONSTANT (t)
3455 || (TREE_READONLY (t) && !TREE_SIDE_EFFECTS (t)))
3456 return true;
3457
3458 switch (TREE_CODE (t))
3459 {
3460 case SAVE_EXPR:
3461 return true;
3462
3463 case ADDR_EXPR:
3464 op = TREE_OPERAND (t, 0);
3465 while (handled_component_p (op))
3466 {
3467 switch (TREE_CODE (op))
3468 {
3469 case ARRAY_REF:
3470 case ARRAY_RANGE_REF:
3471 if (!tree_invariant_p (TREE_OPERAND (op, 1))
3472 || TREE_OPERAND (op, 2) != NULL_TREE
3473 || TREE_OPERAND (op, 3) != NULL_TREE)
3474 return false;
3475 break;
3476
3477 case COMPONENT_REF:
3478 if (TREE_OPERAND (op, 2) != NULL_TREE)
3479 return false;
3480 break;
3481
3482 default:;
3483 }
3484 op = TREE_OPERAND (op, 0);
3485 }
3486
3487 return CONSTANT_CLASS_P (op) || decl_address_invariant_p (op);
3488
3489 default:
3490 break;
3491 }
3492
3493 return false;
3494 }
3495
3496 /* Return true if T is function-invariant. */
3497
3498 bool
tree_invariant_p(tree t)3499 tree_invariant_p (tree t)
3500 {
3501 tree inner = skip_simple_arithmetic (t);
3502 return tree_invariant_p_1 (inner);
3503 }
3504
3505 /* Wrap a SAVE_EXPR around EXPR, if appropriate.
3506 Do this to any expression which may be used in more than one place,
3507 but must be evaluated only once.
3508
3509 Normally, expand_expr would reevaluate the expression each time.
3510 Calling save_expr produces something that is evaluated and recorded
3511 the first time expand_expr is called on it. Subsequent calls to
3512 expand_expr just reuse the recorded value.
3513
3514 The call to expand_expr that generates code that actually computes
3515 the value is the first call *at compile time*. Subsequent calls
3516 *at compile time* generate code to use the saved value.
3517 This produces correct result provided that *at run time* control
3518 always flows through the insns made by the first expand_expr
3519 before reaching the other places where the save_expr was evaluated.
3520 You, the caller of save_expr, must make sure this is so.
3521
3522 Constants, and certain read-only nodes, are returned with no
3523 SAVE_EXPR because that is safe. Expressions containing placeholders
3524 are not touched; see tree.def for an explanation of what these
3525 are used for. */
3526
3527 tree
save_expr(tree expr)3528 save_expr (tree expr)
3529 {
3530 tree inner;
3531
3532 /* If the tree evaluates to a constant, then we don't want to hide that
3533 fact (i.e. this allows further folding, and direct checks for constants).
3534 However, a read-only object that has side effects cannot be bypassed.
3535 Since it is no problem to reevaluate literals, we just return the
3536 literal node. */
3537 inner = skip_simple_arithmetic (expr);
3538 if (TREE_CODE (inner) == ERROR_MARK)
3539 return inner;
3540
3541 if (tree_invariant_p_1 (inner))
3542 return expr;
3543
3544 /* If INNER contains a PLACEHOLDER_EXPR, we must evaluate it each time, since
3545 it means that the size or offset of some field of an object depends on
3546 the value within another field.
3547
3548 Note that it must not be the case that EXPR contains both a PLACEHOLDER_EXPR
3549 and some variable since it would then need to be both evaluated once and
3550 evaluated more than once. Front-ends must assure this case cannot
3551 happen by surrounding any such subexpressions in their own SAVE_EXPR
3552 and forcing evaluation at the proper time. */
3553 if (contains_placeholder_p (inner))
3554 return expr;
3555
3556 expr = build1_loc (EXPR_LOCATION (expr), SAVE_EXPR, TREE_TYPE (expr), expr);
3557
3558 /* This expression might be placed ahead of a jump to ensure that the
3559 value was computed on both sides of the jump. So make sure it isn't
3560 eliminated as dead. */
3561 TREE_SIDE_EFFECTS (expr) = 1;
3562 return expr;
3563 }
3564
3565 /* Look inside EXPR into any simple arithmetic operations. Return the
3566 outermost non-arithmetic or non-invariant node. */
3567
3568 tree
skip_simple_arithmetic(tree expr)3569 skip_simple_arithmetic (tree expr)
3570 {
3571 /* We don't care about whether this can be used as an lvalue in this
3572 context. */
3573 while (TREE_CODE (expr) == NON_LVALUE_EXPR)
3574 expr = TREE_OPERAND (expr, 0);
3575
3576 /* If we have simple operations applied to a SAVE_EXPR or to a SAVE_EXPR and
3577 a constant, it will be more efficient to not make another SAVE_EXPR since
3578 it will allow better simplification and GCSE will be able to merge the
3579 computations if they actually occur. */
3580 while (true)
3581 {
3582 if (UNARY_CLASS_P (expr))
3583 expr = TREE_OPERAND (expr, 0);
3584 else if (BINARY_CLASS_P (expr))
3585 {
3586 if (tree_invariant_p (TREE_OPERAND (expr, 1)))
3587 expr = TREE_OPERAND (expr, 0);
3588 else if (tree_invariant_p (TREE_OPERAND (expr, 0)))
3589 expr = TREE_OPERAND (expr, 1);
3590 else
3591 break;
3592 }
3593 else
3594 break;
3595 }
3596
3597 return expr;
3598 }
3599
3600 /* Look inside EXPR into simple arithmetic operations involving constants.
3601 Return the outermost non-arithmetic or non-constant node. */
3602
3603 tree
skip_simple_constant_arithmetic(tree expr)3604 skip_simple_constant_arithmetic (tree expr)
3605 {
3606 while (TREE_CODE (expr) == NON_LVALUE_EXPR)
3607 expr = TREE_OPERAND (expr, 0);
3608
3609 while (true)
3610 {
3611 if (UNARY_CLASS_P (expr))
3612 expr = TREE_OPERAND (expr, 0);
3613 else if (BINARY_CLASS_P (expr))
3614 {
3615 if (TREE_CONSTANT (TREE_OPERAND (expr, 1)))
3616 expr = TREE_OPERAND (expr, 0);
3617 else if (TREE_CONSTANT (TREE_OPERAND (expr, 0)))
3618 expr = TREE_OPERAND (expr, 1);
3619 else
3620 break;
3621 }
3622 else
3623 break;
3624 }
3625
3626 return expr;
3627 }
3628
3629 /* Return which tree structure is used by T. */
3630
3631 enum tree_node_structure_enum
tree_node_structure(const_tree t)3632 tree_node_structure (const_tree t)
3633 {
3634 const enum tree_code code = TREE_CODE (t);
3635 return tree_node_structure_for_code (code);
3636 }
3637
3638 /* Set various status flags when building a CALL_EXPR object T. */
3639
3640 static void
process_call_operands(tree t)3641 process_call_operands (tree t)
3642 {
3643 bool side_effects = TREE_SIDE_EFFECTS (t);
3644 bool read_only = false;
3645 int i = call_expr_flags (t);
3646
3647 /* Calls have side-effects, except those to const or pure functions. */
3648 if ((i & ECF_LOOPING_CONST_OR_PURE) || !(i & (ECF_CONST | ECF_PURE)))
3649 side_effects = true;
3650 /* Propagate TREE_READONLY of arguments for const functions. */
3651 if (i & ECF_CONST)
3652 read_only = true;
3653
3654 if (!side_effects || read_only)
3655 for (i = 1; i < TREE_OPERAND_LENGTH (t); i++)
3656 {
3657 tree op = TREE_OPERAND (t, i);
3658 if (op && TREE_SIDE_EFFECTS (op))
3659 side_effects = true;
3660 if (op && !TREE_READONLY (op) && !CONSTANT_CLASS_P (op))
3661 read_only = false;
3662 }
3663
3664 TREE_SIDE_EFFECTS (t) = side_effects;
3665 TREE_READONLY (t) = read_only;
3666 }
3667
3668 /* Return true if EXP contains a PLACEHOLDER_EXPR, i.e. if it represents a
3669 size or offset that depends on a field within a record. */
3670
3671 bool
contains_placeholder_p(const_tree exp)3672 contains_placeholder_p (const_tree exp)
3673 {
3674 enum tree_code code;
3675
3676 if (!exp)
3677 return 0;
3678
3679 code = TREE_CODE (exp);
3680 if (code == PLACEHOLDER_EXPR)
3681 return 1;
3682
3683 switch (TREE_CODE_CLASS (code))
3684 {
3685 case tcc_reference:
3686 /* Don't look at any PLACEHOLDER_EXPRs that might be in index or bit
3687 position computations since they will be converted into a
3688 WITH_RECORD_EXPR involving the reference, which will assume
3689 here will be valid. */
3690 return CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 0));
3691
3692 case tcc_exceptional:
3693 if (code == TREE_LIST)
3694 return (CONTAINS_PLACEHOLDER_P (TREE_VALUE (exp))
3695 || CONTAINS_PLACEHOLDER_P (TREE_CHAIN (exp)));
3696 break;
3697
3698 case tcc_unary:
3699 case tcc_binary:
3700 case tcc_comparison:
3701 case tcc_expression:
3702 switch (code)
3703 {
3704 case COMPOUND_EXPR:
3705 /* Ignoring the first operand isn't quite right, but works best. */
3706 return CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 1));
3707
3708 case COND_EXPR:
3709 return (CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 0))
3710 || CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 1))
3711 || CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 2)));
3712
3713 case SAVE_EXPR:
3714 /* The save_expr function never wraps anything containing
3715 a PLACEHOLDER_EXPR. */
3716 return 0;
3717
3718 default:
3719 break;
3720 }
3721
3722 switch (TREE_CODE_LENGTH (code))
3723 {
3724 case 1:
3725 return CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 0));
3726 case 2:
3727 return (CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 0))
3728 || CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 1)));
3729 default:
3730 return 0;
3731 }
3732
3733 case tcc_vl_exp:
3734 switch (code)
3735 {
3736 case CALL_EXPR:
3737 {
3738 const_tree arg;
3739 const_call_expr_arg_iterator iter;
3740 FOR_EACH_CONST_CALL_EXPR_ARG (arg, iter, exp)
3741 if (CONTAINS_PLACEHOLDER_P (arg))
3742 return 1;
3743 return 0;
3744 }
3745 default:
3746 return 0;
3747 }
3748
3749 default:
3750 return 0;
3751 }
3752 return 0;
3753 }
3754
3755 /* Return true if any part of the structure of TYPE involves a PLACEHOLDER_EXPR
3756 directly. This includes size, bounds, qualifiers (for QUAL_UNION_TYPE) and
3757 field positions. */
3758
3759 static bool
type_contains_placeholder_1(const_tree type)3760 type_contains_placeholder_1 (const_tree type)
3761 {
3762 /* If the size contains a placeholder or the parent type (component type in
3763 the case of arrays) type involves a placeholder, this type does. */
3764 if (CONTAINS_PLACEHOLDER_P (TYPE_SIZE (type))
3765 || CONTAINS_PLACEHOLDER_P (TYPE_SIZE_UNIT (type))
3766 || (!POINTER_TYPE_P (type)
3767 && TREE_TYPE (type)
3768 && type_contains_placeholder_p (TREE_TYPE (type))))
3769 return true;
3770
3771 /* Now do type-specific checks. Note that the last part of the check above
3772 greatly limits what we have to do below. */
3773 switch (TREE_CODE (type))
3774 {
3775 case VOID_TYPE:
3776 case POINTER_BOUNDS_TYPE:
3777 case COMPLEX_TYPE:
3778 case ENUMERAL_TYPE:
3779 case BOOLEAN_TYPE:
3780 case POINTER_TYPE:
3781 case OFFSET_TYPE:
3782 case REFERENCE_TYPE:
3783 case METHOD_TYPE:
3784 case FUNCTION_TYPE:
3785 case VECTOR_TYPE:
3786 case NULLPTR_TYPE:
3787 return false;
3788
3789 case INTEGER_TYPE:
3790 case REAL_TYPE:
3791 case FIXED_POINT_TYPE:
3792 /* Here we just check the bounds. */
3793 return (CONTAINS_PLACEHOLDER_P (TYPE_MIN_VALUE (type))
3794 || CONTAINS_PLACEHOLDER_P (TYPE_MAX_VALUE (type)));
3795
3796 case ARRAY_TYPE:
3797 /* We have already checked the component type above, so just check
3798 the domain type. Flexible array members have a null domain. */
3799 return TYPE_DOMAIN (type) ?
3800 type_contains_placeholder_p (TYPE_DOMAIN (type)) : false;
3801
3802 case RECORD_TYPE:
3803 case UNION_TYPE:
3804 case QUAL_UNION_TYPE:
3805 {
3806 tree field;
3807
3808 for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
3809 if (TREE_CODE (field) == FIELD_DECL
3810 && (CONTAINS_PLACEHOLDER_P (DECL_FIELD_OFFSET (field))
3811 || (TREE_CODE (type) == QUAL_UNION_TYPE
3812 && CONTAINS_PLACEHOLDER_P (DECL_QUALIFIER (field)))
3813 || type_contains_placeholder_p (TREE_TYPE (field))))
3814 return true;
3815
3816 return false;
3817 }
3818
3819 default:
3820 gcc_unreachable ();
3821 }
3822 }
3823
3824 /* Wrapper around above function used to cache its result. */
3825
3826 bool
type_contains_placeholder_p(tree type)3827 type_contains_placeholder_p (tree type)
3828 {
3829 bool result;
3830
3831 /* If the contains_placeholder_bits field has been initialized,
3832 then we know the answer. */
3833 if (TYPE_CONTAINS_PLACEHOLDER_INTERNAL (type) > 0)
3834 return TYPE_CONTAINS_PLACEHOLDER_INTERNAL (type) - 1;
3835
3836 /* Indicate that we've seen this type node, and the answer is false.
3837 This is what we want to return if we run into recursion via fields. */
3838 TYPE_CONTAINS_PLACEHOLDER_INTERNAL (type) = 1;
3839
3840 /* Compute the real value. */
3841 result = type_contains_placeholder_1 (type);
3842
3843 /* Store the real value. */
3844 TYPE_CONTAINS_PLACEHOLDER_INTERNAL (type) = result + 1;
3845
3846 return result;
3847 }
3848
3849 /* Push tree EXP onto vector QUEUE if it is not already present. */
3850
3851 static void
push_without_duplicates(tree exp,vec<tree> * queue)3852 push_without_duplicates (tree exp, vec<tree> *queue)
3853 {
3854 unsigned int i;
3855 tree iter;
3856
3857 FOR_EACH_VEC_ELT (*queue, i, iter)
3858 if (simple_cst_equal (iter, exp) == 1)
3859 break;
3860
3861 if (!iter)
3862 queue->safe_push (exp);
3863 }
3864
3865 /* Given a tree EXP, find all occurrences of references to fields
3866 in a PLACEHOLDER_EXPR and place them in vector REFS without
3867 duplicates. Also record VAR_DECLs and CONST_DECLs. Note that
3868 we assume here that EXP contains only arithmetic expressions
3869 or CALL_EXPRs with PLACEHOLDER_EXPRs occurring only in their
3870 argument list. */
3871
3872 void
find_placeholder_in_expr(tree exp,vec<tree> * refs)3873 find_placeholder_in_expr (tree exp, vec<tree> *refs)
3874 {
3875 enum tree_code code = TREE_CODE (exp);
3876 tree inner;
3877 int i;
3878
3879 /* We handle TREE_LIST and COMPONENT_REF separately. */
3880 if (code == TREE_LIST)
3881 {
3882 FIND_PLACEHOLDER_IN_EXPR (TREE_CHAIN (exp), refs);
3883 FIND_PLACEHOLDER_IN_EXPR (TREE_VALUE (exp), refs);
3884 }
3885 else if (code == COMPONENT_REF)
3886 {
3887 for (inner = TREE_OPERAND (exp, 0);
3888 REFERENCE_CLASS_P (inner);
3889 inner = TREE_OPERAND (inner, 0))
3890 ;
3891
3892 if (TREE_CODE (inner) == PLACEHOLDER_EXPR)
3893 push_without_duplicates (exp, refs);
3894 else
3895 FIND_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 0), refs);
3896 }
3897 else
3898 switch (TREE_CODE_CLASS (code))
3899 {
3900 case tcc_constant:
3901 break;
3902
3903 case tcc_declaration:
3904 /* Variables allocated to static storage can stay. */
3905 if (!TREE_STATIC (exp))
3906 push_without_duplicates (exp, refs);
3907 break;
3908
3909 case tcc_expression:
3910 /* This is the pattern built in ada/make_aligning_type. */
3911 if (code == ADDR_EXPR
3912 && TREE_CODE (TREE_OPERAND (exp, 0)) == PLACEHOLDER_EXPR)
3913 {
3914 push_without_duplicates (exp, refs);
3915 break;
3916 }
3917
3918 /* Fall through. */
3919
3920 case tcc_exceptional:
3921 case tcc_unary:
3922 case tcc_binary:
3923 case tcc_comparison:
3924 case tcc_reference:
3925 for (i = 0; i < TREE_CODE_LENGTH (code); i++)
3926 FIND_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, i), refs);
3927 break;
3928
3929 case tcc_vl_exp:
3930 for (i = 1; i < TREE_OPERAND_LENGTH (exp); i++)
3931 FIND_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, i), refs);
3932 break;
3933
3934 default:
3935 gcc_unreachable ();
3936 }
3937 }
3938
3939 /* Given a tree EXP, a FIELD_DECL F, and a replacement value R,
3940 return a tree with all occurrences of references to F in a
3941 PLACEHOLDER_EXPR replaced by R. Also handle VAR_DECLs and
3942 CONST_DECLs. Note that we assume here that EXP contains only
3943 arithmetic expressions or CALL_EXPRs with PLACEHOLDER_EXPRs
3944 occurring only in their argument list. */
3945
3946 tree
substitute_in_expr(tree exp,tree f,tree r)3947 substitute_in_expr (tree exp, tree f, tree r)
3948 {
3949 enum tree_code code = TREE_CODE (exp);
3950 tree op0, op1, op2, op3;
3951 tree new_tree;
3952
3953 /* We handle TREE_LIST and COMPONENT_REF separately. */
3954 if (code == TREE_LIST)
3955 {
3956 op0 = SUBSTITUTE_IN_EXPR (TREE_CHAIN (exp), f, r);
3957 op1 = SUBSTITUTE_IN_EXPR (TREE_VALUE (exp), f, r);
3958 if (op0 == TREE_CHAIN (exp) && op1 == TREE_VALUE (exp))
3959 return exp;
3960
3961 return tree_cons (TREE_PURPOSE (exp), op1, op0);
3962 }
3963 else if (code == COMPONENT_REF)
3964 {
3965 tree inner;
3966
3967 /* If this expression is getting a value from a PLACEHOLDER_EXPR
3968 and it is the right field, replace it with R. */
3969 for (inner = TREE_OPERAND (exp, 0);
3970 REFERENCE_CLASS_P (inner);
3971 inner = TREE_OPERAND (inner, 0))
3972 ;
3973
3974 /* The field. */
3975 op1 = TREE_OPERAND (exp, 1);
3976
3977 if (TREE_CODE (inner) == PLACEHOLDER_EXPR && op1 == f)
3978 return r;
3979
3980 /* If this expression hasn't been completed let, leave it alone. */
3981 if (TREE_CODE (inner) == PLACEHOLDER_EXPR && !TREE_TYPE (inner))
3982 return exp;
3983
3984 op0 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 0), f, r);
3985 if (op0 == TREE_OPERAND (exp, 0))
3986 return exp;
3987
3988 new_tree
3989 = fold_build3 (COMPONENT_REF, TREE_TYPE (exp), op0, op1, NULL_TREE);
3990 }
3991 else
3992 switch (TREE_CODE_CLASS (code))
3993 {
3994 case tcc_constant:
3995 return exp;
3996
3997 case tcc_declaration:
3998 if (exp == f)
3999 return r;
4000 else
4001 return exp;
4002
4003 case tcc_expression:
4004 if (exp == f)
4005 return r;
4006
4007 /* Fall through. */
4008
4009 case tcc_exceptional:
4010 case tcc_unary:
4011 case tcc_binary:
4012 case tcc_comparison:
4013 case tcc_reference:
4014 switch (TREE_CODE_LENGTH (code))
4015 {
4016 case 0:
4017 return exp;
4018
4019 case 1:
4020 op0 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 0), f, r);
4021 if (op0 == TREE_OPERAND (exp, 0))
4022 return exp;
4023
4024 new_tree = fold_build1 (code, TREE_TYPE (exp), op0);
4025 break;
4026
4027 case 2:
4028 op0 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 0), f, r);
4029 op1 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 1), f, r);
4030
4031 if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1))
4032 return exp;
4033
4034 new_tree = fold_build2 (code, TREE_TYPE (exp), op0, op1);
4035 break;
4036
4037 case 3:
4038 op0 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 0), f, r);
4039 op1 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 1), f, r);
4040 op2 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 2), f, r);
4041
4042 if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1)
4043 && op2 == TREE_OPERAND (exp, 2))
4044 return exp;
4045
4046 new_tree = fold_build3 (code, TREE_TYPE (exp), op0, op1, op2);
4047 break;
4048
4049 case 4:
4050 op0 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 0), f, r);
4051 op1 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 1), f, r);
4052 op2 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 2), f, r);
4053 op3 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 3), f, r);
4054
4055 if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1)
4056 && op2 == TREE_OPERAND (exp, 2)
4057 && op3 == TREE_OPERAND (exp, 3))
4058 return exp;
4059
4060 new_tree
4061 = fold (build4 (code, TREE_TYPE (exp), op0, op1, op2, op3));
4062 break;
4063
4064 default:
4065 gcc_unreachable ();
4066 }
4067 break;
4068
4069 case tcc_vl_exp:
4070 {
4071 int i;
4072
4073 new_tree = NULL_TREE;
4074
4075 /* If we are trying to replace F with a constant or with another
4076 instance of one of the arguments of the call, inline back
4077 functions which do nothing else than computing a value from
4078 the arguments they are passed. This makes it possible to
4079 fold partially or entirely the replacement expression. */
4080 if (code == CALL_EXPR)
4081 {
4082 bool maybe_inline = false;
4083 if (CONSTANT_CLASS_P (r))
4084 maybe_inline = true;
4085 else
4086 for (i = 3; i < TREE_OPERAND_LENGTH (exp); i++)
4087 if (operand_equal_p (TREE_OPERAND (exp, i), r, 0))
4088 {
4089 maybe_inline = true;
4090 break;
4091 }
4092 if (maybe_inline)
4093 {
4094 tree t = maybe_inline_call_in_expr (exp);
4095 if (t)
4096 return SUBSTITUTE_IN_EXPR (t, f, r);
4097 }
4098 }
4099
4100 for (i = 1; i < TREE_OPERAND_LENGTH (exp); i++)
4101 {
4102 tree op = TREE_OPERAND (exp, i);
4103 tree new_op = SUBSTITUTE_IN_EXPR (op, f, r);
4104 if (new_op != op)
4105 {
4106 if (!new_tree)
4107 new_tree = copy_node (exp);
4108 TREE_OPERAND (new_tree, i) = new_op;
4109 }
4110 }
4111
4112 if (new_tree)
4113 {
4114 new_tree = fold (new_tree);
4115 if (TREE_CODE (new_tree) == CALL_EXPR)
4116 process_call_operands (new_tree);
4117 }
4118 else
4119 return exp;
4120 }
4121 break;
4122
4123 default:
4124 gcc_unreachable ();
4125 }
4126
4127 TREE_READONLY (new_tree) |= TREE_READONLY (exp);
4128
4129 if (code == INDIRECT_REF || code == ARRAY_REF || code == ARRAY_RANGE_REF)
4130 TREE_THIS_NOTRAP (new_tree) |= TREE_THIS_NOTRAP (exp);
4131
4132 return new_tree;
4133 }
4134
4135 /* Similar, but look for a PLACEHOLDER_EXPR in EXP and find a replacement
4136 for it within OBJ, a tree that is an object or a chain of references. */
4137
4138 tree
substitute_placeholder_in_expr(tree exp,tree obj)4139 substitute_placeholder_in_expr (tree exp, tree obj)
4140 {
4141 enum tree_code code = TREE_CODE (exp);
4142 tree op0, op1, op2, op3;
4143 tree new_tree;
4144
4145 /* If this is a PLACEHOLDER_EXPR, see if we find a corresponding type
4146 in the chain of OBJ. */
4147 if (code == PLACEHOLDER_EXPR)
4148 {
4149 tree need_type = TYPE_MAIN_VARIANT (TREE_TYPE (exp));
4150 tree elt;
4151
4152 for (elt = obj; elt != 0;
4153 elt = ((TREE_CODE (elt) == COMPOUND_EXPR
4154 || TREE_CODE (elt) == COND_EXPR)
4155 ? TREE_OPERAND (elt, 1)
4156 : (REFERENCE_CLASS_P (elt)
4157 || UNARY_CLASS_P (elt)
4158 || BINARY_CLASS_P (elt)
4159 || VL_EXP_CLASS_P (elt)
4160 || EXPRESSION_CLASS_P (elt))
4161 ? TREE_OPERAND (elt, 0) : 0))
4162 if (TYPE_MAIN_VARIANT (TREE_TYPE (elt)) == need_type)
4163 return elt;
4164
4165 for (elt = obj; elt != 0;
4166 elt = ((TREE_CODE (elt) == COMPOUND_EXPR
4167 || TREE_CODE (elt) == COND_EXPR)
4168 ? TREE_OPERAND (elt, 1)
4169 : (REFERENCE_CLASS_P (elt)
4170 || UNARY_CLASS_P (elt)
4171 || BINARY_CLASS_P (elt)
4172 || VL_EXP_CLASS_P (elt)
4173 || EXPRESSION_CLASS_P (elt))
4174 ? TREE_OPERAND (elt, 0) : 0))
4175 if (POINTER_TYPE_P (TREE_TYPE (elt))
4176 && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (elt)))
4177 == need_type))
4178 return fold_build1 (INDIRECT_REF, need_type, elt);
4179
4180 /* If we didn't find it, return the original PLACEHOLDER_EXPR. If it
4181 survives until RTL generation, there will be an error. */
4182 return exp;
4183 }
4184
4185 /* TREE_LIST is special because we need to look at TREE_VALUE
4186 and TREE_CHAIN, not TREE_OPERANDS. */
4187 else if (code == TREE_LIST)
4188 {
4189 op0 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_CHAIN (exp), obj);
4190 op1 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_VALUE (exp), obj);
4191 if (op0 == TREE_CHAIN (exp) && op1 == TREE_VALUE (exp))
4192 return exp;
4193
4194 return tree_cons (TREE_PURPOSE (exp), op1, op0);
4195 }
4196 else
4197 switch (TREE_CODE_CLASS (code))
4198 {
4199 case tcc_constant:
4200 case tcc_declaration:
4201 return exp;
4202
4203 case tcc_exceptional:
4204 case tcc_unary:
4205 case tcc_binary:
4206 case tcc_comparison:
4207 case tcc_expression:
4208 case tcc_reference:
4209 case tcc_statement:
4210 switch (TREE_CODE_LENGTH (code))
4211 {
4212 case 0:
4213 return exp;
4214
4215 case 1:
4216 op0 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 0), obj);
4217 if (op0 == TREE_OPERAND (exp, 0))
4218 return exp;
4219
4220 new_tree = fold_build1 (code, TREE_TYPE (exp), op0);
4221 break;
4222
4223 case 2:
4224 op0 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 0), obj);
4225 op1 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 1), obj);
4226
4227 if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1))
4228 return exp;
4229
4230 new_tree = fold_build2 (code, TREE_TYPE (exp), op0, op1);
4231 break;
4232
4233 case 3:
4234 op0 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 0), obj);
4235 op1 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 1), obj);
4236 op2 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 2), obj);
4237
4238 if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1)
4239 && op2 == TREE_OPERAND (exp, 2))
4240 return exp;
4241
4242 new_tree = fold_build3 (code, TREE_TYPE (exp), op0, op1, op2);
4243 break;
4244
4245 case 4:
4246 op0 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 0), obj);
4247 op1 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 1), obj);
4248 op2 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 2), obj);
4249 op3 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 3), obj);
4250
4251 if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1)
4252 && op2 == TREE_OPERAND (exp, 2)
4253 && op3 == TREE_OPERAND (exp, 3))
4254 return exp;
4255
4256 new_tree
4257 = fold (build4 (code, TREE_TYPE (exp), op0, op1, op2, op3));
4258 break;
4259
4260 default:
4261 gcc_unreachable ();
4262 }
4263 break;
4264
4265 case tcc_vl_exp:
4266 {
4267 int i;
4268
4269 new_tree = NULL_TREE;
4270
4271 for (i = 1; i < TREE_OPERAND_LENGTH (exp); i++)
4272 {
4273 tree op = TREE_OPERAND (exp, i);
4274 tree new_op = SUBSTITUTE_PLACEHOLDER_IN_EXPR (op, obj);
4275 if (new_op != op)
4276 {
4277 if (!new_tree)
4278 new_tree = copy_node (exp);
4279 TREE_OPERAND (new_tree, i) = new_op;
4280 }
4281 }
4282
4283 if (new_tree)
4284 {
4285 new_tree = fold (new_tree);
4286 if (TREE_CODE (new_tree) == CALL_EXPR)
4287 process_call_operands (new_tree);
4288 }
4289 else
4290 return exp;
4291 }
4292 break;
4293
4294 default:
4295 gcc_unreachable ();
4296 }
4297
4298 TREE_READONLY (new_tree) |= TREE_READONLY (exp);
4299
4300 if (code == INDIRECT_REF || code == ARRAY_REF || code == ARRAY_RANGE_REF)
4301 TREE_THIS_NOTRAP (new_tree) |= TREE_THIS_NOTRAP (exp);
4302
4303 return new_tree;
4304 }
4305
4306
4307 /* Subroutine of stabilize_reference; this is called for subtrees of
4308 references. Any expression with side-effects must be put in a SAVE_EXPR
4309 to ensure that it is only evaluated once.
4310
4311 We don't put SAVE_EXPR nodes around everything, because assigning very
4312 simple expressions to temporaries causes us to miss good opportunities
4313 for optimizations. Among other things, the opportunity to fold in the
4314 addition of a constant into an addressing mode often gets lost, e.g.
4315 "y[i+1] += x;". In general, we take the approach that we should not make
4316 an assignment unless we are forced into it - i.e., that any non-side effect
4317 operator should be allowed, and that cse should take care of coalescing
4318 multiple utterances of the same expression should that prove fruitful. */
4319
4320 static tree
stabilize_reference_1(tree e)4321 stabilize_reference_1 (tree e)
4322 {
4323 tree result;
4324 enum tree_code code = TREE_CODE (e);
4325
4326 /* We cannot ignore const expressions because it might be a reference
4327 to a const array but whose index contains side-effects. But we can
4328 ignore things that are actual constant or that already have been
4329 handled by this function. */
4330
4331 if (tree_invariant_p (e))
4332 return e;
4333
4334 switch (TREE_CODE_CLASS (code))
4335 {
4336 case tcc_exceptional:
4337 /* Always wrap STATEMENT_LIST into SAVE_EXPR, even if it doesn't
4338 have side-effects. */
4339 if (code == STATEMENT_LIST)
4340 return save_expr (e);
4341 /* FALLTHRU */
4342 case tcc_type:
4343 case tcc_declaration:
4344 case tcc_comparison:
4345 case tcc_statement:
4346 case tcc_expression:
4347 case tcc_reference:
4348 case tcc_vl_exp:
4349 /* If the expression has side-effects, then encase it in a SAVE_EXPR
4350 so that it will only be evaluated once. */
4351 /* The reference (r) and comparison (<) classes could be handled as
4352 below, but it is generally faster to only evaluate them once. */
4353 if (TREE_SIDE_EFFECTS (e))
4354 return save_expr (e);
4355 return e;
4356
4357 case tcc_constant:
4358 /* Constants need no processing. In fact, we should never reach
4359 here. */
4360 return e;
4361
4362 case tcc_binary:
4363 /* Division is slow and tends to be compiled with jumps,
4364 especially the division by powers of 2 that is often
4365 found inside of an array reference. So do it just once. */
4366 if (code == TRUNC_DIV_EXPR || code == TRUNC_MOD_EXPR
4367 || code == FLOOR_DIV_EXPR || code == FLOOR_MOD_EXPR
4368 || code == CEIL_DIV_EXPR || code == CEIL_MOD_EXPR
4369 || code == ROUND_DIV_EXPR || code == ROUND_MOD_EXPR)
4370 return save_expr (e);
4371 /* Recursively stabilize each operand. */
4372 result = build_nt (code, stabilize_reference_1 (TREE_OPERAND (e, 0)),
4373 stabilize_reference_1 (TREE_OPERAND (e, 1)));
4374 break;
4375
4376 case tcc_unary:
4377 /* Recursively stabilize each operand. */
4378 result = build_nt (code, stabilize_reference_1 (TREE_OPERAND (e, 0)));
4379 break;
4380
4381 default:
4382 gcc_unreachable ();
4383 }
4384
4385 TREE_TYPE (result) = TREE_TYPE (e);
4386 TREE_READONLY (result) = TREE_READONLY (e);
4387 TREE_SIDE_EFFECTS (result) = TREE_SIDE_EFFECTS (e);
4388 TREE_THIS_VOLATILE (result) = TREE_THIS_VOLATILE (e);
4389
4390 return result;
4391 }
4392
4393 /* Stabilize a reference so that we can use it any number of times
4394 without causing its operands to be evaluated more than once.
4395 Returns the stabilized reference. This works by means of save_expr,
4396 so see the caveats in the comments about save_expr.
4397
4398 Also allows conversion expressions whose operands are references.
4399 Any other kind of expression is returned unchanged. */
4400
4401 tree
stabilize_reference(tree ref)4402 stabilize_reference (tree ref)
4403 {
4404 tree result;
4405 enum tree_code code = TREE_CODE (ref);
4406
4407 switch (code)
4408 {
4409 case VAR_DECL:
4410 case PARM_DECL:
4411 case RESULT_DECL:
4412 /* No action is needed in this case. */
4413 return ref;
4414
4415 CASE_CONVERT:
4416 case FLOAT_EXPR:
4417 case FIX_TRUNC_EXPR:
4418 result = build_nt (code, stabilize_reference (TREE_OPERAND (ref, 0)));
4419 break;
4420
4421 case INDIRECT_REF:
4422 result = build_nt (INDIRECT_REF,
4423 stabilize_reference_1 (TREE_OPERAND (ref, 0)));
4424 break;
4425
4426 case COMPONENT_REF:
4427 result = build_nt (COMPONENT_REF,
4428 stabilize_reference (TREE_OPERAND (ref, 0)),
4429 TREE_OPERAND (ref, 1), NULL_TREE);
4430 break;
4431
4432 case BIT_FIELD_REF:
4433 result = build_nt (BIT_FIELD_REF,
4434 stabilize_reference (TREE_OPERAND (ref, 0)),
4435 TREE_OPERAND (ref, 1), TREE_OPERAND (ref, 2));
4436 REF_REVERSE_STORAGE_ORDER (result) = REF_REVERSE_STORAGE_ORDER (ref);
4437 break;
4438
4439 case ARRAY_REF:
4440 result = build_nt (ARRAY_REF,
4441 stabilize_reference (TREE_OPERAND (ref, 0)),
4442 stabilize_reference_1 (TREE_OPERAND (ref, 1)),
4443 TREE_OPERAND (ref, 2), TREE_OPERAND (ref, 3));
4444 break;
4445
4446 case ARRAY_RANGE_REF:
4447 result = build_nt (ARRAY_RANGE_REF,
4448 stabilize_reference (TREE_OPERAND (ref, 0)),
4449 stabilize_reference_1 (TREE_OPERAND (ref, 1)),
4450 TREE_OPERAND (ref, 2), TREE_OPERAND (ref, 3));
4451 break;
4452
4453 case COMPOUND_EXPR:
4454 /* We cannot wrap the first expression in a SAVE_EXPR, as then
4455 it wouldn't be ignored. This matters when dealing with
4456 volatiles. */
4457 return stabilize_reference_1 (ref);
4458
4459 /* If arg isn't a kind of lvalue we recognize, make no change.
4460 Caller should recognize the error for an invalid lvalue. */
4461 default:
4462 return ref;
4463
4464 case ERROR_MARK:
4465 return error_mark_node;
4466 }
4467
4468 TREE_TYPE (result) = TREE_TYPE (ref);
4469 TREE_READONLY (result) = TREE_READONLY (ref);
4470 TREE_SIDE_EFFECTS (result) = TREE_SIDE_EFFECTS (ref);
4471 TREE_THIS_VOLATILE (result) = TREE_THIS_VOLATILE (ref);
4472
4473 return result;
4474 }
4475
4476 /* Low-level constructors for expressions. */
4477
4478 /* A helper function for build1 and constant folders. Set TREE_CONSTANT,
4479 and TREE_SIDE_EFFECTS for an ADDR_EXPR. */
4480
4481 void
recompute_tree_invariant_for_addr_expr(tree t)4482 recompute_tree_invariant_for_addr_expr (tree t)
4483 {
4484 tree node;
4485 bool tc = true, se = false;
4486
4487 gcc_assert (TREE_CODE (t) == ADDR_EXPR);
4488
4489 /* We started out assuming this address is both invariant and constant, but
4490 does not have side effects. Now go down any handled components and see if
4491 any of them involve offsets that are either non-constant or non-invariant.
4492 Also check for side-effects.
4493
4494 ??? Note that this code makes no attempt to deal with the case where
4495 taking the address of something causes a copy due to misalignment. */
4496
4497 #define UPDATE_FLAGS(NODE) \
4498 do { tree _node = (NODE); \
4499 if (_node && !TREE_CONSTANT (_node)) tc = false; \
4500 if (_node && TREE_SIDE_EFFECTS (_node)) se = true; } while (0)
4501
4502 for (node = TREE_OPERAND (t, 0); handled_component_p (node);
4503 node = TREE_OPERAND (node, 0))
4504 {
4505 /* If the first operand doesn't have an ARRAY_TYPE, this is a bogus
4506 array reference (probably made temporarily by the G++ front end),
4507 so ignore all the operands. */
4508 if ((TREE_CODE (node) == ARRAY_REF
4509 || TREE_CODE (node) == ARRAY_RANGE_REF)
4510 && TREE_CODE (TREE_TYPE (TREE_OPERAND (node, 0))) == ARRAY_TYPE)
4511 {
4512 UPDATE_FLAGS (TREE_OPERAND (node, 1));
4513 if (TREE_OPERAND (node, 2))
4514 UPDATE_FLAGS (TREE_OPERAND (node, 2));
4515 if (TREE_OPERAND (node, 3))
4516 UPDATE_FLAGS (TREE_OPERAND (node, 3));
4517 }
4518 /* Likewise, just because this is a COMPONENT_REF doesn't mean we have a
4519 FIELD_DECL, apparently. The G++ front end can put something else
4520 there, at least temporarily. */
4521 else if (TREE_CODE (node) == COMPONENT_REF
4522 && TREE_CODE (TREE_OPERAND (node, 1)) == FIELD_DECL)
4523 {
4524 if (TREE_OPERAND (node, 2))
4525 UPDATE_FLAGS (TREE_OPERAND (node, 2));
4526 }
4527 }
4528
4529 node = lang_hooks.expr_to_decl (node, &tc, &se);
4530
4531 /* Now see what's inside. If it's an INDIRECT_REF, copy our properties from
4532 the address, since &(*a)->b is a form of addition. If it's a constant, the
4533 address is constant too. If it's a decl, its address is constant if the
4534 decl is static. Everything else is not constant and, furthermore,
4535 taking the address of a volatile variable is not volatile. */
4536 if (TREE_CODE (node) == INDIRECT_REF
4537 || TREE_CODE (node) == MEM_REF)
4538 UPDATE_FLAGS (TREE_OPERAND (node, 0));
4539 else if (CONSTANT_CLASS_P (node))
4540 ;
4541 else if (DECL_P (node))
4542 tc &= (staticp (node) != NULL_TREE);
4543 else
4544 {
4545 tc = false;
4546 se |= TREE_SIDE_EFFECTS (node);
4547 }
4548
4549
4550 TREE_CONSTANT (t) = tc;
4551 TREE_SIDE_EFFECTS (t) = se;
4552 #undef UPDATE_FLAGS
4553 }
4554
4555 /* Build an expression of code CODE, data type TYPE, and operands as
4556 specified. Expressions and reference nodes can be created this way.
4557 Constants, decls, types and misc nodes cannot be.
4558
4559 We define 5 non-variadic functions, from 0 to 4 arguments. This is
4560 enough for all extant tree codes. */
4561
4562 tree
build0(enum tree_code code,tree tt MEM_STAT_DECL)4563 build0 (enum tree_code code, tree tt MEM_STAT_DECL)
4564 {
4565 tree t;
4566
4567 gcc_assert (TREE_CODE_LENGTH (code) == 0);
4568
4569 t = make_node (code PASS_MEM_STAT);
4570 TREE_TYPE (t) = tt;
4571
4572 return t;
4573 }
4574
4575 tree
build1(enum tree_code code,tree type,tree node MEM_STAT_DECL)4576 build1 (enum tree_code code, tree type, tree node MEM_STAT_DECL)
4577 {
4578 int length = sizeof (struct tree_exp);
4579 tree t;
4580
4581 record_node_allocation_statistics (code, length);
4582
4583 gcc_assert (TREE_CODE_LENGTH (code) == 1);
4584
4585 t = ggc_alloc_tree_node_stat (length PASS_MEM_STAT);
4586
4587 memset (t, 0, sizeof (struct tree_common));
4588
4589 TREE_SET_CODE (t, code);
4590
4591 TREE_TYPE (t) = type;
4592 SET_EXPR_LOCATION (t, UNKNOWN_LOCATION);
4593 TREE_OPERAND (t, 0) = node;
4594 if (node && !TYPE_P (node))
4595 {
4596 TREE_SIDE_EFFECTS (t) = TREE_SIDE_EFFECTS (node);
4597 TREE_READONLY (t) = TREE_READONLY (node);
4598 }
4599
4600 if (TREE_CODE_CLASS (code) == tcc_statement)
4601 {
4602 if (code != DEBUG_BEGIN_STMT)
4603 TREE_SIDE_EFFECTS (t) = 1;
4604 }
4605 else switch (code)
4606 {
4607 case VA_ARG_EXPR:
4608 /* All of these have side-effects, no matter what their
4609 operands are. */
4610 TREE_SIDE_EFFECTS (t) = 1;
4611 TREE_READONLY (t) = 0;
4612 break;
4613
4614 case INDIRECT_REF:
4615 /* Whether a dereference is readonly has nothing to do with whether
4616 its operand is readonly. */
4617 TREE_READONLY (t) = 0;
4618 break;
4619
4620 case ADDR_EXPR:
4621 if (node)
4622 recompute_tree_invariant_for_addr_expr (t);
4623 break;
4624
4625 default:
4626 if ((TREE_CODE_CLASS (code) == tcc_unary || code == VIEW_CONVERT_EXPR)
4627 && node && !TYPE_P (node)
4628 && TREE_CONSTANT (node))
4629 TREE_CONSTANT (t) = 1;
4630 if (TREE_CODE_CLASS (code) == tcc_reference
4631 && node && TREE_THIS_VOLATILE (node))
4632 TREE_THIS_VOLATILE (t) = 1;
4633 break;
4634 }
4635
4636 return t;
4637 }
4638
4639 #define PROCESS_ARG(N) \
4640 do { \
4641 TREE_OPERAND (t, N) = arg##N; \
4642 if (arg##N &&!TYPE_P (arg##N)) \
4643 { \
4644 if (TREE_SIDE_EFFECTS (arg##N)) \
4645 side_effects = 1; \
4646 if (!TREE_READONLY (arg##N) \
4647 && !CONSTANT_CLASS_P (arg##N)) \
4648 (void) (read_only = 0); \
4649 if (!TREE_CONSTANT (arg##N)) \
4650 (void) (constant = 0); \
4651 } \
4652 } while (0)
4653
4654 tree
build2(enum tree_code code,tree tt,tree arg0,tree arg1 MEM_STAT_DECL)4655 build2 (enum tree_code code, tree tt, tree arg0, tree arg1 MEM_STAT_DECL)
4656 {
4657 bool constant, read_only, side_effects, div_by_zero;
4658 tree t;
4659
4660 gcc_assert (TREE_CODE_LENGTH (code) == 2);
4661
4662 if ((code == MINUS_EXPR || code == PLUS_EXPR || code == MULT_EXPR)
4663 && arg0 && arg1 && tt && POINTER_TYPE_P (tt)
4664 /* When sizetype precision doesn't match that of pointers
4665 we need to be able to build explicit extensions or truncations
4666 of the offset argument. */
4667 && TYPE_PRECISION (sizetype) == TYPE_PRECISION (tt))
4668 gcc_assert (TREE_CODE (arg0) == INTEGER_CST
4669 && TREE_CODE (arg1) == INTEGER_CST);
4670
4671 if (code == POINTER_PLUS_EXPR && arg0 && arg1 && tt)
4672 gcc_assert (POINTER_TYPE_P (tt) && POINTER_TYPE_P (TREE_TYPE (arg0))
4673 && ptrofftype_p (TREE_TYPE (arg1)));
4674
4675 t = make_node (code PASS_MEM_STAT);
4676 TREE_TYPE (t) = tt;
4677
4678 /* Below, we automatically set TREE_SIDE_EFFECTS and TREE_READONLY for the
4679 result based on those same flags for the arguments. But if the
4680 arguments aren't really even `tree' expressions, we shouldn't be trying
4681 to do this. */
4682
4683 /* Expressions without side effects may be constant if their
4684 arguments are as well. */
4685 constant = (TREE_CODE_CLASS (code) == tcc_comparison
4686 || TREE_CODE_CLASS (code) == tcc_binary);
4687 read_only = 1;
4688 side_effects = TREE_SIDE_EFFECTS (t);
4689
4690 switch (code)
4691 {
4692 case TRUNC_DIV_EXPR:
4693 case CEIL_DIV_EXPR:
4694 case FLOOR_DIV_EXPR:
4695 case ROUND_DIV_EXPR:
4696 case EXACT_DIV_EXPR:
4697 case CEIL_MOD_EXPR:
4698 case FLOOR_MOD_EXPR:
4699 case ROUND_MOD_EXPR:
4700 case TRUNC_MOD_EXPR:
4701 div_by_zero = integer_zerop (arg1);
4702 break;
4703 default:
4704 div_by_zero = false;
4705 }
4706
4707 PROCESS_ARG (0);
4708 PROCESS_ARG (1);
4709
4710 TREE_SIDE_EFFECTS (t) = side_effects;
4711 if (code == MEM_REF)
4712 {
4713 if (arg0 && TREE_CODE (arg0) == ADDR_EXPR)
4714 {
4715 tree o = TREE_OPERAND (arg0, 0);
4716 TREE_READONLY (t) = TREE_READONLY (o);
4717 TREE_THIS_VOLATILE (t) = TREE_THIS_VOLATILE (o);
4718 }
4719 }
4720 else
4721 {
4722 TREE_READONLY (t) = read_only;
4723 /* Don't mark X / 0 as constant. */
4724 TREE_CONSTANT (t) = constant && !div_by_zero;
4725 TREE_THIS_VOLATILE (t)
4726 = (TREE_CODE_CLASS (code) == tcc_reference
4727 && arg0 && TREE_THIS_VOLATILE (arg0));
4728 }
4729
4730 return t;
4731 }
4732
4733
4734 tree
build3(enum tree_code code,tree tt,tree arg0,tree arg1,tree arg2 MEM_STAT_DECL)4735 build3 (enum tree_code code, tree tt, tree arg0, tree arg1,
4736 tree arg2 MEM_STAT_DECL)
4737 {
4738 bool constant, read_only, side_effects;
4739 tree t;
4740
4741 gcc_assert (TREE_CODE_LENGTH (code) == 3);
4742 gcc_assert (TREE_CODE_CLASS (code) != tcc_vl_exp);
4743
4744 t = make_node (code PASS_MEM_STAT);
4745 TREE_TYPE (t) = tt;
4746
4747 read_only = 1;
4748
4749 /* As a special exception, if COND_EXPR has NULL branches, we
4750 assume that it is a gimple statement and always consider
4751 it to have side effects. */
4752 if (code == COND_EXPR
4753 && tt == void_type_node
4754 && arg1 == NULL_TREE
4755 && arg2 == NULL_TREE)
4756 side_effects = true;
4757 else
4758 side_effects = TREE_SIDE_EFFECTS (t);
4759
4760 PROCESS_ARG (0);
4761 PROCESS_ARG (1);
4762 PROCESS_ARG (2);
4763
4764 if (code == COND_EXPR)
4765 TREE_READONLY (t) = read_only;
4766
4767 TREE_SIDE_EFFECTS (t) = side_effects;
4768 TREE_THIS_VOLATILE (t)
4769 = (TREE_CODE_CLASS (code) == tcc_reference
4770 && arg0 && TREE_THIS_VOLATILE (arg0));
4771
4772 return t;
4773 }
4774
4775 tree
build4(enum tree_code code,tree tt,tree arg0,tree arg1,tree arg2,tree arg3 MEM_STAT_DECL)4776 build4 (enum tree_code code, tree tt, tree arg0, tree arg1,
4777 tree arg2, tree arg3 MEM_STAT_DECL)
4778 {
4779 bool constant, read_only, side_effects;
4780 tree t;
4781
4782 gcc_assert (TREE_CODE_LENGTH (code) == 4);
4783
4784 t = make_node (code PASS_MEM_STAT);
4785 TREE_TYPE (t) = tt;
4786
4787 side_effects = TREE_SIDE_EFFECTS (t);
4788
4789 PROCESS_ARG (0);
4790 PROCESS_ARG (1);
4791 PROCESS_ARG (2);
4792 PROCESS_ARG (3);
4793
4794 TREE_SIDE_EFFECTS (t) = side_effects;
4795 TREE_THIS_VOLATILE (t)
4796 = (TREE_CODE_CLASS (code) == tcc_reference
4797 && arg0 && TREE_THIS_VOLATILE (arg0));
4798
4799 return t;
4800 }
4801
4802 tree
build5(enum tree_code code,tree tt,tree arg0,tree arg1,tree arg2,tree arg3,tree arg4 MEM_STAT_DECL)4803 build5 (enum tree_code code, tree tt, tree arg0, tree arg1,
4804 tree arg2, tree arg3, tree arg4 MEM_STAT_DECL)
4805 {
4806 bool constant, read_only, side_effects;
4807 tree t;
4808
4809 gcc_assert (TREE_CODE_LENGTH (code) == 5);
4810
4811 t = make_node (code PASS_MEM_STAT);
4812 TREE_TYPE (t) = tt;
4813
4814 side_effects = TREE_SIDE_EFFECTS (t);
4815
4816 PROCESS_ARG (0);
4817 PROCESS_ARG (1);
4818 PROCESS_ARG (2);
4819 PROCESS_ARG (3);
4820 PROCESS_ARG (4);
4821
4822 TREE_SIDE_EFFECTS (t) = side_effects;
4823 if (code == TARGET_MEM_REF)
4824 {
4825 if (arg0 && TREE_CODE (arg0) == ADDR_EXPR)
4826 {
4827 tree o = TREE_OPERAND (arg0, 0);
4828 TREE_READONLY (t) = TREE_READONLY (o);
4829 TREE_THIS_VOLATILE (t) = TREE_THIS_VOLATILE (o);
4830 }
4831 }
4832 else
4833 TREE_THIS_VOLATILE (t)
4834 = (TREE_CODE_CLASS (code) == tcc_reference
4835 && arg0 && TREE_THIS_VOLATILE (arg0));
4836
4837 return t;
4838 }
4839
4840 /* Build a simple MEM_REF tree with the sematics of a plain INDIRECT_REF
4841 on the pointer PTR. */
4842
4843 tree
build_simple_mem_ref_loc(location_t loc,tree ptr)4844 build_simple_mem_ref_loc (location_t loc, tree ptr)
4845 {
4846 poly_int64 offset = 0;
4847 tree ptype = TREE_TYPE (ptr);
4848 tree tem;
4849 /* For convenience allow addresses that collapse to a simple base
4850 and offset. */
4851 if (TREE_CODE (ptr) == ADDR_EXPR
4852 && (handled_component_p (TREE_OPERAND (ptr, 0))
4853 || TREE_CODE (TREE_OPERAND (ptr, 0)) == MEM_REF))
4854 {
4855 ptr = get_addr_base_and_unit_offset (TREE_OPERAND (ptr, 0), &offset);
4856 gcc_assert (ptr);
4857 if (TREE_CODE (ptr) == MEM_REF)
4858 {
4859 offset += mem_ref_offset (ptr).force_shwi ();
4860 ptr = TREE_OPERAND (ptr, 0);
4861 }
4862 else
4863 ptr = build_fold_addr_expr (ptr);
4864 gcc_assert (is_gimple_reg (ptr) || is_gimple_min_invariant (ptr));
4865 }
4866 tem = build2 (MEM_REF, TREE_TYPE (ptype),
4867 ptr, build_int_cst (ptype, offset));
4868 SET_EXPR_LOCATION (tem, loc);
4869 return tem;
4870 }
4871
4872 /* Return the constant offset of a MEM_REF or TARGET_MEM_REF tree T. */
4873
4874 poly_offset_int
mem_ref_offset(const_tree t)4875 mem_ref_offset (const_tree t)
4876 {
4877 return poly_offset_int::from (wi::to_poly_wide (TREE_OPERAND (t, 1)),
4878 SIGNED);
4879 }
4880
4881 /* Return an invariant ADDR_EXPR of type TYPE taking the address of BASE
4882 offsetted by OFFSET units. */
4883
4884 tree
build_invariant_address(tree type,tree base,poly_int64 offset)4885 build_invariant_address (tree type, tree base, poly_int64 offset)
4886 {
4887 tree ref = fold_build2 (MEM_REF, TREE_TYPE (type),
4888 build_fold_addr_expr (base),
4889 build_int_cst (ptr_type_node, offset));
4890 tree addr = build1 (ADDR_EXPR, type, ref);
4891 recompute_tree_invariant_for_addr_expr (addr);
4892 return addr;
4893 }
4894
4895 /* Similar except don't specify the TREE_TYPE
4896 and leave the TREE_SIDE_EFFECTS as 0.
4897 It is permissible for arguments to be null,
4898 or even garbage if their values do not matter. */
4899
4900 tree
build_nt(enum tree_code code,...)4901 build_nt (enum tree_code code, ...)
4902 {
4903 tree t;
4904 int length;
4905 int i;
4906 va_list p;
4907
4908 gcc_assert (TREE_CODE_CLASS (code) != tcc_vl_exp);
4909
4910 va_start (p, code);
4911
4912 t = make_node (code);
4913 length = TREE_CODE_LENGTH (code);
4914
4915 for (i = 0; i < length; i++)
4916 TREE_OPERAND (t, i) = va_arg (p, tree);
4917
4918 va_end (p);
4919 return t;
4920 }
4921
4922 /* Similar to build_nt, but for creating a CALL_EXPR object with a
4923 tree vec. */
4924
4925 tree
build_nt_call_vec(tree fn,vec<tree,va_gc> * args)4926 build_nt_call_vec (tree fn, vec<tree, va_gc> *args)
4927 {
4928 tree ret, t;
4929 unsigned int ix;
4930
4931 ret = build_vl_exp (CALL_EXPR, vec_safe_length (args) + 3);
4932 CALL_EXPR_FN (ret) = fn;
4933 CALL_EXPR_STATIC_CHAIN (ret) = NULL_TREE;
4934 FOR_EACH_VEC_SAFE_ELT (args, ix, t)
4935 CALL_EXPR_ARG (ret, ix) = t;
4936 return ret;
4937 }
4938
4939 /* Create a DECL_... node of code CODE, name NAME and data type TYPE.
4940 We do NOT enter this node in any sort of symbol table.
4941
4942 LOC is the location of the decl.
4943
4944 layout_decl is used to set up the decl's storage layout.
4945 Other slots are initialized to 0 or null pointers. */
4946
4947 tree
build_decl(location_t loc,enum tree_code code,tree name,tree type MEM_STAT_DECL)4948 build_decl (location_t loc, enum tree_code code, tree name,
4949 tree type MEM_STAT_DECL)
4950 {
4951 tree t;
4952
4953 t = make_node (code PASS_MEM_STAT);
4954 DECL_SOURCE_LOCATION (t) = loc;
4955
4956 /* if (type == error_mark_node)
4957 type = integer_type_node; */
4958 /* That is not done, deliberately, so that having error_mark_node
4959 as the type can suppress useless errors in the use of this variable. */
4960
4961 DECL_NAME (t) = name;
4962 TREE_TYPE (t) = type;
4963
4964 if (code == VAR_DECL || code == PARM_DECL || code == RESULT_DECL)
4965 layout_decl (t, 0);
4966
4967 return t;
4968 }
4969
4970 /* Builds and returns function declaration with NAME and TYPE. */
4971
4972 tree
build_fn_decl(const char * name,tree type)4973 build_fn_decl (const char *name, tree type)
4974 {
4975 tree id = get_identifier (name);
4976 tree decl = build_decl (input_location, FUNCTION_DECL, id, type);
4977
4978 DECL_EXTERNAL (decl) = 1;
4979 TREE_PUBLIC (decl) = 1;
4980 DECL_ARTIFICIAL (decl) = 1;
4981 TREE_NOTHROW (decl) = 1;
4982
4983 return decl;
4984 }
4985
4986 vec<tree, va_gc> *all_translation_units;
4987
4988 /* Builds a new translation-unit decl with name NAME, queues it in the
4989 global list of translation-unit decls and returns it. */
4990
4991 tree
build_translation_unit_decl(tree name)4992 build_translation_unit_decl (tree name)
4993 {
4994 tree tu = build_decl (UNKNOWN_LOCATION, TRANSLATION_UNIT_DECL,
4995 name, NULL_TREE);
4996 TRANSLATION_UNIT_LANGUAGE (tu) = lang_hooks.name;
4997 vec_safe_push (all_translation_units, tu);
4998 return tu;
4999 }
5000
5001
5002 /* BLOCK nodes are used to represent the structure of binding contours
5003 and declarations, once those contours have been exited and their contents
5004 compiled. This information is used for outputting debugging info. */
5005
5006 tree
build_block(tree vars,tree subblocks,tree supercontext,tree chain)5007 build_block (tree vars, tree subblocks, tree supercontext, tree chain)
5008 {
5009 tree block = make_node (BLOCK);
5010
5011 BLOCK_VARS (block) = vars;
5012 BLOCK_SUBBLOCKS (block) = subblocks;
5013 BLOCK_SUPERCONTEXT (block) = supercontext;
5014 BLOCK_CHAIN (block) = chain;
5015 return block;
5016 }
5017
5018
5019 /* Like SET_EXPR_LOCATION, but make sure the tree can have a location.
5020
5021 LOC is the location to use in tree T. */
5022
5023 void
protected_set_expr_location(tree t,location_t loc)5024 protected_set_expr_location (tree t, location_t loc)
5025 {
5026 if (CAN_HAVE_LOCATION_P (t))
5027 SET_EXPR_LOCATION (t, loc);
5028 }
5029
5030 /* Reset the expression *EXPR_P, a size or position.
5031
5032 ??? We could reset all non-constant sizes or positions. But it's cheap
5033 enough to not do so and refrain from adding workarounds to dwarf2out.c.
5034
5035 We need to reset self-referential sizes or positions because they cannot
5036 be gimplified and thus can contain a CALL_EXPR after the gimplification
5037 is finished, which will run afoul of LTO streaming. And they need to be
5038 reset to something essentially dummy but not constant, so as to preserve
5039 the properties of the object they are attached to. */
5040
5041 static inline void
free_lang_data_in_one_sizepos(tree * expr_p)5042 free_lang_data_in_one_sizepos (tree *expr_p)
5043 {
5044 tree expr = *expr_p;
5045 if (CONTAINS_PLACEHOLDER_P (expr))
5046 *expr_p = build0 (PLACEHOLDER_EXPR, TREE_TYPE (expr));
5047 }
5048
5049
5050 /* Reset all the fields in a binfo node BINFO. We only keep
5051 BINFO_VTABLE, which is used by gimple_fold_obj_type_ref. */
5052
5053 static void
free_lang_data_in_binfo(tree binfo)5054 free_lang_data_in_binfo (tree binfo)
5055 {
5056 unsigned i;
5057 tree t;
5058
5059 gcc_assert (TREE_CODE (binfo) == TREE_BINFO);
5060
5061 BINFO_VIRTUALS (binfo) = NULL_TREE;
5062 BINFO_BASE_ACCESSES (binfo) = NULL;
5063 BINFO_INHERITANCE_CHAIN (binfo) = NULL_TREE;
5064 BINFO_SUBVTT_INDEX (binfo) = NULL_TREE;
5065
5066 FOR_EACH_VEC_ELT (*BINFO_BASE_BINFOS (binfo), i, t)
5067 free_lang_data_in_binfo (t);
5068 }
5069
5070
5071 /* Reset all language specific information still present in TYPE. */
5072
5073 static void
free_lang_data_in_type(tree type)5074 free_lang_data_in_type (tree type)
5075 {
5076 gcc_assert (TYPE_P (type));
5077
5078 /* Give the FE a chance to remove its own data first. */
5079 lang_hooks.free_lang_data (type);
5080
5081 TREE_LANG_FLAG_0 (type) = 0;
5082 TREE_LANG_FLAG_1 (type) = 0;
5083 TREE_LANG_FLAG_2 (type) = 0;
5084 TREE_LANG_FLAG_3 (type) = 0;
5085 TREE_LANG_FLAG_4 (type) = 0;
5086 TREE_LANG_FLAG_5 (type) = 0;
5087 TREE_LANG_FLAG_6 (type) = 0;
5088
5089 if (TREE_CODE (type) == FUNCTION_TYPE)
5090 {
5091 /* Remove the const and volatile qualifiers from arguments. The
5092 C++ front end removes them, but the C front end does not,
5093 leading to false ODR violation errors when merging two
5094 instances of the same function signature compiled by
5095 different front ends. */
5096 for (tree p = TYPE_ARG_TYPES (type); p; p = TREE_CHAIN (p))
5097 {
5098 tree arg_type = TREE_VALUE (p);
5099
5100 if (TYPE_READONLY (arg_type) || TYPE_VOLATILE (arg_type))
5101 {
5102 int quals = TYPE_QUALS (arg_type)
5103 & ~TYPE_QUAL_CONST
5104 & ~TYPE_QUAL_VOLATILE;
5105 TREE_VALUE (p) = build_qualified_type (arg_type, quals);
5106 free_lang_data_in_type (TREE_VALUE (p));
5107 }
5108 /* C++ FE uses TREE_PURPOSE to store initial values. */
5109 TREE_PURPOSE (p) = NULL;
5110 }
5111 }
5112 else if (TREE_CODE (type) == METHOD_TYPE)
5113 for (tree p = TYPE_ARG_TYPES (type); p; p = TREE_CHAIN (p))
5114 /* C++ FE uses TREE_PURPOSE to store initial values. */
5115 TREE_PURPOSE (p) = NULL;
5116 else if (RECORD_OR_UNION_TYPE_P (type))
5117 {
5118 /* Remove members that are not FIELD_DECLs from the field list
5119 of an aggregate. These occur in C++. */
5120 for (tree *prev = &TYPE_FIELDS (type), member; (member = *prev);)
5121 if (TREE_CODE (member) == FIELD_DECL)
5122 prev = &DECL_CHAIN (member);
5123 else
5124 *prev = DECL_CHAIN (member);
5125
5126 /* FIXME: C FE uses TYPE_VFIELD to record C_TYPE_INCOMPLETE_VARS
5127 and danagle the pointer from time to time. */
5128 if (TYPE_VFIELD (type) && TREE_CODE (TYPE_VFIELD (type)) != FIELD_DECL)
5129 TYPE_VFIELD (type) = NULL_TREE;
5130
5131 if (TYPE_BINFO (type))
5132 {
5133 free_lang_data_in_binfo (TYPE_BINFO (type));
5134 /* We need to preserve link to bases and virtual table for all
5135 polymorphic types to make devirtualization machinery working. */
5136 if (!BINFO_VTABLE (TYPE_BINFO (type))
5137 || !flag_devirtualize)
5138 TYPE_BINFO (type) = NULL;
5139 }
5140 }
5141 else if (INTEGRAL_TYPE_P (type)
5142 || SCALAR_FLOAT_TYPE_P (type)
5143 || FIXED_POINT_TYPE_P (type))
5144 {
5145 free_lang_data_in_one_sizepos (&TYPE_MIN_VALUE (type));
5146 free_lang_data_in_one_sizepos (&TYPE_MAX_VALUE (type));
5147 }
5148
5149 TYPE_LANG_SLOT_1 (type) = NULL_TREE;
5150
5151 free_lang_data_in_one_sizepos (&TYPE_SIZE (type));
5152 free_lang_data_in_one_sizepos (&TYPE_SIZE_UNIT (type));
5153
5154 if (TYPE_CONTEXT (type)
5155 && TREE_CODE (TYPE_CONTEXT (type)) == BLOCK)
5156 {
5157 tree ctx = TYPE_CONTEXT (type);
5158 do
5159 {
5160 ctx = BLOCK_SUPERCONTEXT (ctx);
5161 }
5162 while (ctx && TREE_CODE (ctx) == BLOCK);
5163 TYPE_CONTEXT (type) = ctx;
5164 }
5165
5166 /* Drop TYPE_DECLs in TYPE_NAME in favor of the identifier in the
5167 TYPE_DECL if the type doesn't have linkage. */
5168 if (! type_with_linkage_p (type))
5169 TYPE_NAME (type) = TYPE_IDENTIFIER (type);
5170 }
5171
5172
5173 /* Return true if DECL may need an assembler name to be set. */
5174
5175 static inline bool
need_assembler_name_p(tree decl)5176 need_assembler_name_p (tree decl)
5177 {
5178 /* We use DECL_ASSEMBLER_NAME to hold mangled type names for One Definition
5179 Rule merging. This makes type_odr_p to return true on those types during
5180 LTO and by comparing the mangled name, we can say what types are intended
5181 to be equivalent across compilation unit.
5182
5183 We do not store names of type_in_anonymous_namespace_p.
5184
5185 Record, union and enumeration type have linkage that allows use
5186 to check type_in_anonymous_namespace_p. We do not mangle compound types
5187 that always can be compared structurally.
5188
5189 Similarly for builtin types, we compare properties of their main variant.
5190 A special case are integer types where mangling do make differences
5191 between char/signed char/unsigned char etc. Storing name for these makes
5192 e.g. -fno-signed-char/-fsigned-char mismatches to be handled well.
5193 See cp/mangle.c:write_builtin_type for details. */
5194
5195 if (flag_lto_odr_type_mering
5196 && TREE_CODE (decl) == TYPE_DECL
5197 && DECL_NAME (decl)
5198 && decl == TYPE_NAME (TREE_TYPE (decl))
5199 && TYPE_MAIN_VARIANT (TREE_TYPE (decl)) == TREE_TYPE (decl)
5200 && !TYPE_ARTIFICIAL (TREE_TYPE (decl))
5201 && (type_with_linkage_p (TREE_TYPE (decl))
5202 || TREE_CODE (TREE_TYPE (decl)) == INTEGER_TYPE)
5203 && !variably_modified_type_p (TREE_TYPE (decl), NULL_TREE))
5204 return !DECL_ASSEMBLER_NAME_SET_P (decl);
5205 /* Only FUNCTION_DECLs and VAR_DECLs are considered. */
5206 if (!VAR_OR_FUNCTION_DECL_P (decl))
5207 return false;
5208
5209 /* If DECL already has its assembler name set, it does not need a
5210 new one. */
5211 if (!HAS_DECL_ASSEMBLER_NAME_P (decl)
5212 || DECL_ASSEMBLER_NAME_SET_P (decl))
5213 return false;
5214
5215 /* Abstract decls do not need an assembler name. */
5216 if (DECL_ABSTRACT_P (decl))
5217 return false;
5218
5219 /* For VAR_DECLs, only static, public and external symbols need an
5220 assembler name. */
5221 if (VAR_P (decl)
5222 && !TREE_STATIC (decl)
5223 && !TREE_PUBLIC (decl)
5224 && !DECL_EXTERNAL (decl))
5225 return false;
5226
5227 if (TREE_CODE (decl) == FUNCTION_DECL)
5228 {
5229 /* Do not set assembler name on builtins. Allow RTL expansion to
5230 decide whether to expand inline or via a regular call. */
5231 if (DECL_BUILT_IN (decl)
5232 && DECL_BUILT_IN_CLASS (decl) != BUILT_IN_FRONTEND)
5233 return false;
5234
5235 /* Functions represented in the callgraph need an assembler name. */
5236 if (cgraph_node::get (decl) != NULL)
5237 return true;
5238
5239 /* Unused and not public functions don't need an assembler name. */
5240 if (!TREE_USED (decl) && !TREE_PUBLIC (decl))
5241 return false;
5242 }
5243
5244 return true;
5245 }
5246
5247
5248 /* Reset all language specific information still present in symbol
5249 DECL. */
5250
5251 static void
free_lang_data_in_decl(tree decl)5252 free_lang_data_in_decl (tree decl)
5253 {
5254 gcc_assert (DECL_P (decl));
5255
5256 /* Give the FE a chance to remove its own data first. */
5257 lang_hooks.free_lang_data (decl);
5258
5259 TREE_LANG_FLAG_0 (decl) = 0;
5260 TREE_LANG_FLAG_1 (decl) = 0;
5261 TREE_LANG_FLAG_2 (decl) = 0;
5262 TREE_LANG_FLAG_3 (decl) = 0;
5263 TREE_LANG_FLAG_4 (decl) = 0;
5264 TREE_LANG_FLAG_5 (decl) = 0;
5265 TREE_LANG_FLAG_6 (decl) = 0;
5266
5267 free_lang_data_in_one_sizepos (&DECL_SIZE (decl));
5268 free_lang_data_in_one_sizepos (&DECL_SIZE_UNIT (decl));
5269 if (TREE_CODE (decl) == FIELD_DECL)
5270 {
5271 free_lang_data_in_one_sizepos (&DECL_FIELD_OFFSET (decl));
5272 if (TREE_CODE (DECL_CONTEXT (decl)) == QUAL_UNION_TYPE)
5273 DECL_QUALIFIER (decl) = NULL_TREE;
5274 }
5275
5276 if (TREE_CODE (decl) == FUNCTION_DECL)
5277 {
5278 struct cgraph_node *node;
5279 if (!(node = cgraph_node::get (decl))
5280 || (!node->definition && !node->clones))
5281 {
5282 if (node)
5283 node->release_body ();
5284 else
5285 {
5286 release_function_body (decl);
5287 DECL_ARGUMENTS (decl) = NULL;
5288 DECL_RESULT (decl) = NULL;
5289 DECL_INITIAL (decl) = error_mark_node;
5290 }
5291 }
5292 if (gimple_has_body_p (decl) || (node && node->thunk.thunk_p))
5293 {
5294 tree t;
5295
5296 /* If DECL has a gimple body, then the context for its
5297 arguments must be DECL. Otherwise, it doesn't really
5298 matter, as we will not be emitting any code for DECL. In
5299 general, there may be other instances of DECL created by
5300 the front end and since PARM_DECLs are generally shared,
5301 their DECL_CONTEXT changes as the replicas of DECL are
5302 created. The only time where DECL_CONTEXT is important
5303 is for the FUNCTION_DECLs that have a gimple body (since
5304 the PARM_DECL will be used in the function's body). */
5305 for (t = DECL_ARGUMENTS (decl); t; t = TREE_CHAIN (t))
5306 DECL_CONTEXT (t) = decl;
5307 if (!DECL_FUNCTION_SPECIFIC_TARGET (decl))
5308 DECL_FUNCTION_SPECIFIC_TARGET (decl)
5309 = target_option_default_node;
5310 if (!DECL_FUNCTION_SPECIFIC_OPTIMIZATION (decl))
5311 DECL_FUNCTION_SPECIFIC_OPTIMIZATION (decl)
5312 = optimization_default_node;
5313 }
5314
5315 /* DECL_SAVED_TREE holds the GENERIC representation for DECL.
5316 At this point, it is not needed anymore. */
5317 DECL_SAVED_TREE (decl) = NULL_TREE;
5318
5319 /* Clear the abstract origin if it refers to a method.
5320 Otherwise dwarf2out.c will ICE as we splice functions out of
5321 TYPE_FIELDS and thus the origin will not be output
5322 correctly. */
5323 if (DECL_ABSTRACT_ORIGIN (decl)
5324 && DECL_CONTEXT (DECL_ABSTRACT_ORIGIN (decl))
5325 && RECORD_OR_UNION_TYPE_P
5326 (DECL_CONTEXT (DECL_ABSTRACT_ORIGIN (decl))))
5327 DECL_ABSTRACT_ORIGIN (decl) = NULL_TREE;
5328
5329 /* Sometimes the C++ frontend doesn't manage to transform a temporary
5330 DECL_VINDEX referring to itself into a vtable slot number as it
5331 should. Happens with functions that are copied and then forgotten
5332 about. Just clear it, it won't matter anymore. */
5333 if (DECL_VINDEX (decl) && !tree_fits_shwi_p (DECL_VINDEX (decl)))
5334 DECL_VINDEX (decl) = NULL_TREE;
5335 }
5336 else if (VAR_P (decl))
5337 {
5338 if ((DECL_EXTERNAL (decl)
5339 && (!TREE_STATIC (decl) || !TREE_READONLY (decl)))
5340 || (decl_function_context (decl) && !TREE_STATIC (decl)))
5341 DECL_INITIAL (decl) = NULL_TREE;
5342 }
5343 else if (TREE_CODE (decl) == TYPE_DECL)
5344 {
5345 DECL_VISIBILITY (decl) = VISIBILITY_DEFAULT;
5346 DECL_VISIBILITY_SPECIFIED (decl) = 0;
5347 DECL_INITIAL (decl) = NULL_TREE;
5348 }
5349 else if (TREE_CODE (decl) == FIELD_DECL)
5350 DECL_INITIAL (decl) = NULL_TREE;
5351 else if (TREE_CODE (decl) == TRANSLATION_UNIT_DECL
5352 && DECL_INITIAL (decl)
5353 && TREE_CODE (DECL_INITIAL (decl)) == BLOCK)
5354 {
5355 /* Strip builtins from the translation-unit BLOCK. We still have targets
5356 without builtin_decl_explicit support and also builtins are shared
5357 nodes and thus we can't use TREE_CHAIN in multiple lists. */
5358 tree *nextp = &BLOCK_VARS (DECL_INITIAL (decl));
5359 while (*nextp)
5360 {
5361 tree var = *nextp;
5362 if (TREE_CODE (var) == FUNCTION_DECL
5363 && DECL_BUILT_IN (var))
5364 *nextp = TREE_CHAIN (var);
5365 else
5366 nextp = &TREE_CHAIN (var);
5367 }
5368 }
5369 }
5370
5371
5372 /* Data used when collecting DECLs and TYPEs for language data removal. */
5373
5374 struct free_lang_data_d
5375 {
free_lang_data_dfree_lang_data_d5376 free_lang_data_d () : decls (100), types (100) {}
5377
5378 /* Worklist to avoid excessive recursion. */
5379 auto_vec<tree> worklist;
5380
5381 /* Set of traversed objects. Used to avoid duplicate visits. */
5382 hash_set<tree> pset;
5383
5384 /* Array of symbols to process with free_lang_data_in_decl. */
5385 auto_vec<tree> decls;
5386
5387 /* Array of types to process with free_lang_data_in_type. */
5388 auto_vec<tree> types;
5389 };
5390
5391
5392 /* Add type or decl T to one of the list of tree nodes that need their
5393 language data removed. The lists are held inside FLD. */
5394
5395 static void
add_tree_to_fld_list(tree t,struct free_lang_data_d * fld)5396 add_tree_to_fld_list (tree t, struct free_lang_data_d *fld)
5397 {
5398 if (DECL_P (t))
5399 fld->decls.safe_push (t);
5400 else if (TYPE_P (t))
5401 fld->types.safe_push (t);
5402 else
5403 gcc_unreachable ();
5404 }
5405
5406 /* Push tree node T into FLD->WORKLIST. */
5407
5408 static inline void
fld_worklist_push(tree t,struct free_lang_data_d * fld)5409 fld_worklist_push (tree t, struct free_lang_data_d *fld)
5410 {
5411 if (t && !is_lang_specific (t) && !fld->pset.contains (t))
5412 fld->worklist.safe_push ((t));
5413 }
5414
5415
5416 /* Operand callback helper for free_lang_data_in_node. *TP is the
5417 subtree operand being considered. */
5418
5419 static tree
find_decls_types_r(tree * tp,int * ws,void * data)5420 find_decls_types_r (tree *tp, int *ws, void *data)
5421 {
5422 tree t = *tp;
5423 struct free_lang_data_d *fld = (struct free_lang_data_d *) data;
5424
5425 if (TREE_CODE (t) == TREE_LIST)
5426 return NULL_TREE;
5427
5428 /* Language specific nodes will be removed, so there is no need
5429 to gather anything under them. */
5430 if (is_lang_specific (t))
5431 {
5432 *ws = 0;
5433 return NULL_TREE;
5434 }
5435
5436 if (DECL_P (t))
5437 {
5438 /* Note that walk_tree does not traverse every possible field in
5439 decls, so we have to do our own traversals here. */
5440 add_tree_to_fld_list (t, fld);
5441
5442 fld_worklist_push (DECL_NAME (t), fld);
5443 fld_worklist_push (DECL_CONTEXT (t), fld);
5444 fld_worklist_push (DECL_SIZE (t), fld);
5445 fld_worklist_push (DECL_SIZE_UNIT (t), fld);
5446
5447 /* We are going to remove everything under DECL_INITIAL for
5448 TYPE_DECLs. No point walking them. */
5449 if (TREE_CODE (t) != TYPE_DECL)
5450 fld_worklist_push (DECL_INITIAL (t), fld);
5451
5452 fld_worklist_push (DECL_ATTRIBUTES (t), fld);
5453 fld_worklist_push (DECL_ABSTRACT_ORIGIN (t), fld);
5454
5455 if (TREE_CODE (t) == FUNCTION_DECL)
5456 {
5457 fld_worklist_push (DECL_ARGUMENTS (t), fld);
5458 fld_worklist_push (DECL_RESULT (t), fld);
5459 }
5460 else if (TREE_CODE (t) == TYPE_DECL)
5461 {
5462 fld_worklist_push (DECL_ORIGINAL_TYPE (t), fld);
5463 }
5464 else if (TREE_CODE (t) == FIELD_DECL)
5465 {
5466 fld_worklist_push (DECL_FIELD_OFFSET (t), fld);
5467 fld_worklist_push (DECL_BIT_FIELD_TYPE (t), fld);
5468 fld_worklist_push (DECL_FIELD_BIT_OFFSET (t), fld);
5469 fld_worklist_push (DECL_FCONTEXT (t), fld);
5470 }
5471
5472 if ((VAR_P (t) || TREE_CODE (t) == PARM_DECL)
5473 && DECL_HAS_VALUE_EXPR_P (t))
5474 fld_worklist_push (DECL_VALUE_EXPR (t), fld);
5475
5476 if (TREE_CODE (t) != FIELD_DECL
5477 && TREE_CODE (t) != TYPE_DECL)
5478 fld_worklist_push (TREE_CHAIN (t), fld);
5479 *ws = 0;
5480 }
5481 else if (TYPE_P (t))
5482 {
5483 /* Note that walk_tree does not traverse every possible field in
5484 types, so we have to do our own traversals here. */
5485 add_tree_to_fld_list (t, fld);
5486
5487 if (!RECORD_OR_UNION_TYPE_P (t))
5488 fld_worklist_push (TYPE_CACHED_VALUES (t), fld);
5489 fld_worklist_push (TYPE_SIZE (t), fld);
5490 fld_worklist_push (TYPE_SIZE_UNIT (t), fld);
5491 fld_worklist_push (TYPE_ATTRIBUTES (t), fld);
5492 fld_worklist_push (TYPE_POINTER_TO (t), fld);
5493 fld_worklist_push (TYPE_REFERENCE_TO (t), fld);
5494 fld_worklist_push (TYPE_NAME (t), fld);
5495 /* Do not walk TYPE_NEXT_PTR_TO or TYPE_NEXT_REF_TO. We do not stream
5496 them and thus do not and want not to reach unused pointer types
5497 this way. */
5498 if (!POINTER_TYPE_P (t))
5499 fld_worklist_push (TYPE_MIN_VALUE_RAW (t), fld);
5500 /* TYPE_MAX_VALUE_RAW is TYPE_BINFO for record types. */
5501 if (!RECORD_OR_UNION_TYPE_P (t))
5502 fld_worklist_push (TYPE_MAX_VALUE_RAW (t), fld);
5503 fld_worklist_push (TYPE_MAIN_VARIANT (t), fld);
5504 /* Do not walk TYPE_NEXT_VARIANT. We do not stream it and thus
5505 do not and want not to reach unused variants this way. */
5506 if (TYPE_CONTEXT (t))
5507 {
5508 tree ctx = TYPE_CONTEXT (t);
5509 /* We adjust BLOCK TYPE_CONTEXTs to the innermost non-BLOCK one.
5510 So push that instead. */
5511 while (ctx && TREE_CODE (ctx) == BLOCK)
5512 ctx = BLOCK_SUPERCONTEXT (ctx);
5513 fld_worklist_push (ctx, fld);
5514 }
5515 /* Do not walk TYPE_CANONICAL. We do not stream it and thus do not
5516 and want not to reach unused types this way. */
5517
5518 if (RECORD_OR_UNION_TYPE_P (t) && TYPE_BINFO (t))
5519 {
5520 unsigned i;
5521 tree tem;
5522 FOR_EACH_VEC_ELT (*BINFO_BASE_BINFOS (TYPE_BINFO (t)), i, tem)
5523 fld_worklist_push (TREE_TYPE (tem), fld);
5524 fld_worklist_push (BINFO_TYPE (TYPE_BINFO (t)), fld);
5525 fld_worklist_push (BINFO_VTABLE (TYPE_BINFO (t)), fld);
5526 }
5527 if (RECORD_OR_UNION_TYPE_P (t))
5528 {
5529 tree tem;
5530 /* Push all TYPE_FIELDS - there can be interleaving interesting
5531 and non-interesting things. */
5532 tem = TYPE_FIELDS (t);
5533 while (tem)
5534 {
5535 if (TREE_CODE (tem) == FIELD_DECL
5536 || (TREE_CODE (tem) == TYPE_DECL
5537 && !DECL_IGNORED_P (tem)
5538 && debug_info_level > DINFO_LEVEL_TERSE
5539 && !is_redundant_typedef (tem)))
5540 fld_worklist_push (tem, fld);
5541 tem = TREE_CHAIN (tem);
5542 }
5543 }
5544 if (FUNC_OR_METHOD_TYPE_P (t))
5545 fld_worklist_push (TYPE_METHOD_BASETYPE (t), fld);
5546
5547 fld_worklist_push (TYPE_STUB_DECL (t), fld);
5548 *ws = 0;
5549 }
5550 else if (TREE_CODE (t) == BLOCK)
5551 {
5552 tree tem;
5553 for (tem = BLOCK_VARS (t); tem; tem = TREE_CHAIN (tem))
5554 fld_worklist_push (tem, fld);
5555 for (tem = BLOCK_SUBBLOCKS (t); tem; tem = BLOCK_CHAIN (tem))
5556 fld_worklist_push (tem, fld);
5557 fld_worklist_push (BLOCK_ABSTRACT_ORIGIN (t), fld);
5558 }
5559
5560 if (TREE_CODE (t) != IDENTIFIER_NODE
5561 && CODE_CONTAINS_STRUCT (TREE_CODE (t), TS_TYPED))
5562 fld_worklist_push (TREE_TYPE (t), fld);
5563
5564 return NULL_TREE;
5565 }
5566
5567
5568 /* Find decls and types in T. */
5569
5570 static void
find_decls_types(tree t,struct free_lang_data_d * fld)5571 find_decls_types (tree t, struct free_lang_data_d *fld)
5572 {
5573 while (1)
5574 {
5575 if (!fld->pset.contains (t))
5576 walk_tree (&t, find_decls_types_r, fld, &fld->pset);
5577 if (fld->worklist.is_empty ())
5578 break;
5579 t = fld->worklist.pop ();
5580 }
5581 }
5582
5583 /* Translate all the types in LIST with the corresponding runtime
5584 types. */
5585
5586 static tree
get_eh_types_for_runtime(tree list)5587 get_eh_types_for_runtime (tree list)
5588 {
5589 tree head, prev;
5590
5591 if (list == NULL_TREE)
5592 return NULL_TREE;
5593
5594 head = build_tree_list (0, lookup_type_for_runtime (TREE_VALUE (list)));
5595 prev = head;
5596 list = TREE_CHAIN (list);
5597 while (list)
5598 {
5599 tree n = build_tree_list (0, lookup_type_for_runtime (TREE_VALUE (list)));
5600 TREE_CHAIN (prev) = n;
5601 prev = TREE_CHAIN (prev);
5602 list = TREE_CHAIN (list);
5603 }
5604
5605 return head;
5606 }
5607
5608
5609 /* Find decls and types referenced in EH region R and store them in
5610 FLD->DECLS and FLD->TYPES. */
5611
5612 static void
find_decls_types_in_eh_region(eh_region r,struct free_lang_data_d * fld)5613 find_decls_types_in_eh_region (eh_region r, struct free_lang_data_d *fld)
5614 {
5615 switch (r->type)
5616 {
5617 case ERT_CLEANUP:
5618 break;
5619
5620 case ERT_TRY:
5621 {
5622 eh_catch c;
5623
5624 /* The types referenced in each catch must first be changed to the
5625 EH types used at runtime. This removes references to FE types
5626 in the region. */
5627 for (c = r->u.eh_try.first_catch; c ; c = c->next_catch)
5628 {
5629 c->type_list = get_eh_types_for_runtime (c->type_list);
5630 walk_tree (&c->type_list, find_decls_types_r, fld, &fld->pset);
5631 }
5632 }
5633 break;
5634
5635 case ERT_ALLOWED_EXCEPTIONS:
5636 r->u.allowed.type_list
5637 = get_eh_types_for_runtime (r->u.allowed.type_list);
5638 walk_tree (&r->u.allowed.type_list, find_decls_types_r, fld, &fld->pset);
5639 break;
5640
5641 case ERT_MUST_NOT_THROW:
5642 walk_tree (&r->u.must_not_throw.failure_decl,
5643 find_decls_types_r, fld, &fld->pset);
5644 break;
5645 }
5646 }
5647
5648
5649 /* Find decls and types referenced in cgraph node N and store them in
5650 FLD->DECLS and FLD->TYPES. Unlike pass_referenced_vars, this will
5651 look for *every* kind of DECL and TYPE node reachable from N,
5652 including those embedded inside types and decls (i.e,, TYPE_DECLs,
5653 NAMESPACE_DECLs, etc). */
5654
5655 static void
find_decls_types_in_node(struct cgraph_node * n,struct free_lang_data_d * fld)5656 find_decls_types_in_node (struct cgraph_node *n, struct free_lang_data_d *fld)
5657 {
5658 basic_block bb;
5659 struct function *fn;
5660 unsigned ix;
5661 tree t;
5662
5663 find_decls_types (n->decl, fld);
5664
5665 if (!gimple_has_body_p (n->decl))
5666 return;
5667
5668 gcc_assert (current_function_decl == NULL_TREE && cfun == NULL);
5669
5670 fn = DECL_STRUCT_FUNCTION (n->decl);
5671
5672 /* Traverse locals. */
5673 FOR_EACH_LOCAL_DECL (fn, ix, t)
5674 find_decls_types (t, fld);
5675
5676 /* Traverse EH regions in FN. */
5677 {
5678 eh_region r;
5679 FOR_ALL_EH_REGION_FN (r, fn)
5680 find_decls_types_in_eh_region (r, fld);
5681 }
5682
5683 /* Traverse every statement in FN. */
5684 FOR_EACH_BB_FN (bb, fn)
5685 {
5686 gphi_iterator psi;
5687 gimple_stmt_iterator si;
5688 unsigned i;
5689
5690 for (psi = gsi_start_phis (bb); !gsi_end_p (psi); gsi_next (&psi))
5691 {
5692 gphi *phi = psi.phi ();
5693
5694 for (i = 0; i < gimple_phi_num_args (phi); i++)
5695 {
5696 tree *arg_p = gimple_phi_arg_def_ptr (phi, i);
5697 find_decls_types (*arg_p, fld);
5698 }
5699 }
5700
5701 for (si = gsi_start_bb (bb); !gsi_end_p (si); gsi_next (&si))
5702 {
5703 gimple *stmt = gsi_stmt (si);
5704
5705 if (is_gimple_call (stmt))
5706 find_decls_types (gimple_call_fntype (stmt), fld);
5707
5708 for (i = 0; i < gimple_num_ops (stmt); i++)
5709 {
5710 tree arg = gimple_op (stmt, i);
5711 find_decls_types (arg, fld);
5712 }
5713 }
5714 }
5715 }
5716
5717
5718 /* Find decls and types referenced in varpool node N and store them in
5719 FLD->DECLS and FLD->TYPES. Unlike pass_referenced_vars, this will
5720 look for *every* kind of DECL and TYPE node reachable from N,
5721 including those embedded inside types and decls (i.e,, TYPE_DECLs,
5722 NAMESPACE_DECLs, etc). */
5723
5724 static void
find_decls_types_in_var(varpool_node * v,struct free_lang_data_d * fld)5725 find_decls_types_in_var (varpool_node *v, struct free_lang_data_d *fld)
5726 {
5727 find_decls_types (v->decl, fld);
5728 }
5729
5730 /* If T needs an assembler name, have one created for it. */
5731
5732 void
assign_assembler_name_if_needed(tree t)5733 assign_assembler_name_if_needed (tree t)
5734 {
5735 if (need_assembler_name_p (t))
5736 {
5737 /* When setting DECL_ASSEMBLER_NAME, the C++ mangler may emit
5738 diagnostics that use input_location to show locus
5739 information. The problem here is that, at this point,
5740 input_location is generally anchored to the end of the file
5741 (since the parser is long gone), so we don't have a good
5742 position to pin it to.
5743
5744 To alleviate this problem, this uses the location of T's
5745 declaration. Examples of this are
5746 testsuite/g++.dg/template/cond2.C and
5747 testsuite/g++.dg/template/pr35240.C. */
5748 location_t saved_location = input_location;
5749 input_location = DECL_SOURCE_LOCATION (t);
5750
5751 decl_assembler_name (t);
5752
5753 input_location = saved_location;
5754 }
5755 }
5756
5757
5758 /* Free language specific information for every operand and expression
5759 in every node of the call graph. This process operates in three stages:
5760
5761 1- Every callgraph node and varpool node is traversed looking for
5762 decls and types embedded in them. This is a more exhaustive
5763 search than that done by find_referenced_vars, because it will
5764 also collect individual fields, decls embedded in types, etc.
5765
5766 2- All the decls found are sent to free_lang_data_in_decl.
5767
5768 3- All the types found are sent to free_lang_data_in_type.
5769
5770 The ordering between decls and types is important because
5771 free_lang_data_in_decl sets assembler names, which includes
5772 mangling. So types cannot be freed up until assembler names have
5773 been set up. */
5774
5775 static void
free_lang_data_in_cgraph(void)5776 free_lang_data_in_cgraph (void)
5777 {
5778 struct cgraph_node *n;
5779 varpool_node *v;
5780 struct free_lang_data_d fld;
5781 tree t;
5782 unsigned i;
5783 alias_pair *p;
5784
5785 /* Find decls and types in the body of every function in the callgraph. */
5786 FOR_EACH_FUNCTION (n)
5787 find_decls_types_in_node (n, &fld);
5788
5789 FOR_EACH_VEC_SAFE_ELT (alias_pairs, i, p)
5790 find_decls_types (p->decl, &fld);
5791
5792 /* Find decls and types in every varpool symbol. */
5793 FOR_EACH_VARIABLE (v)
5794 find_decls_types_in_var (v, &fld);
5795
5796 /* Set the assembler name on every decl found. We need to do this
5797 now because free_lang_data_in_decl will invalidate data needed
5798 for mangling. This breaks mangling on interdependent decls. */
5799 FOR_EACH_VEC_ELT (fld.decls, i, t)
5800 assign_assembler_name_if_needed (t);
5801
5802 /* Traverse every decl found freeing its language data. */
5803 FOR_EACH_VEC_ELT (fld.decls, i, t)
5804 free_lang_data_in_decl (t);
5805
5806 /* Traverse every type found freeing its language data. */
5807 FOR_EACH_VEC_ELT (fld.types, i, t)
5808 free_lang_data_in_type (t);
5809 if (flag_checking)
5810 {
5811 FOR_EACH_VEC_ELT (fld.types, i, t)
5812 verify_type (t);
5813 }
5814 }
5815
5816
5817 /* Free resources that are used by FE but are not needed once they are done. */
5818
5819 static unsigned
free_lang_data(void)5820 free_lang_data (void)
5821 {
5822 unsigned i;
5823
5824 /* If we are the LTO frontend we have freed lang-specific data already. */
5825 if (in_lto_p
5826 || (!flag_generate_lto && !flag_generate_offload))
5827 {
5828 /* Rebuild type inheritance graph even when not doing LTO to get
5829 consistent profile data. */
5830 rebuild_type_inheritance_graph ();
5831 return 0;
5832 }
5833
5834 /* Provide a dummy TRANSLATION_UNIT_DECL if the FE failed to provide one. */
5835 if (vec_safe_is_empty (all_translation_units))
5836 build_translation_unit_decl (NULL_TREE);
5837
5838 /* Allocate and assign alias sets to the standard integer types
5839 while the slots are still in the way the frontends generated them. */
5840 for (i = 0; i < itk_none; ++i)
5841 if (integer_types[i])
5842 TYPE_ALIAS_SET (integer_types[i]) = get_alias_set (integer_types[i]);
5843
5844 /* Traverse the IL resetting language specific information for
5845 operands, expressions, etc. */
5846 free_lang_data_in_cgraph ();
5847
5848 /* Create gimple variants for common types. */
5849 for (unsigned i = 0;
5850 i < sizeof (builtin_structptr_types) / sizeof (builtin_structptr_type);
5851 ++i)
5852 builtin_structptr_types[i].node = builtin_structptr_types[i].base;
5853
5854 /* Reset some langhooks. Do not reset types_compatible_p, it may
5855 still be used indirectly via the get_alias_set langhook. */
5856 lang_hooks.dwarf_name = lhd_dwarf_name;
5857 lang_hooks.decl_printable_name = gimple_decl_printable_name;
5858 lang_hooks.gimplify_expr = lhd_gimplify_expr;
5859
5860 /* We do not want the default decl_assembler_name implementation,
5861 rather if we have fixed everything we want a wrapper around it
5862 asserting that all non-local symbols already got their assembler
5863 name and only produce assembler names for local symbols. Or rather
5864 make sure we never call decl_assembler_name on local symbols and
5865 devise a separate, middle-end private scheme for it. */
5866
5867 /* Reset diagnostic machinery. */
5868 tree_diagnostics_defaults (global_dc);
5869
5870 rebuild_type_inheritance_graph ();
5871
5872 return 0;
5873 }
5874
5875
5876 namespace {
5877
5878 const pass_data pass_data_ipa_free_lang_data =
5879 {
5880 SIMPLE_IPA_PASS, /* type */
5881 "*free_lang_data", /* name */
5882 OPTGROUP_NONE, /* optinfo_flags */
5883 TV_IPA_FREE_LANG_DATA, /* tv_id */
5884 0, /* properties_required */
5885 0, /* properties_provided */
5886 0, /* properties_destroyed */
5887 0, /* todo_flags_start */
5888 0, /* todo_flags_finish */
5889 };
5890
5891 class pass_ipa_free_lang_data : public simple_ipa_opt_pass
5892 {
5893 public:
pass_ipa_free_lang_data(gcc::context * ctxt)5894 pass_ipa_free_lang_data (gcc::context *ctxt)
5895 : simple_ipa_opt_pass (pass_data_ipa_free_lang_data, ctxt)
5896 {}
5897
5898 /* opt_pass methods: */
execute(function *)5899 virtual unsigned int execute (function *) { return free_lang_data (); }
5900
5901 }; // class pass_ipa_free_lang_data
5902
5903 } // anon namespace
5904
5905 simple_ipa_opt_pass *
make_pass_ipa_free_lang_data(gcc::context * ctxt)5906 make_pass_ipa_free_lang_data (gcc::context *ctxt)
5907 {
5908 return new pass_ipa_free_lang_data (ctxt);
5909 }
5910
5911 /* Set the type qualifiers for TYPE to TYPE_QUALS, which is a bitmask
5912 of the various TYPE_QUAL values. */
5913
5914 static void
set_type_quals(tree type,int type_quals)5915 set_type_quals (tree type, int type_quals)
5916 {
5917 TYPE_READONLY (type) = (type_quals & TYPE_QUAL_CONST) != 0;
5918 TYPE_VOLATILE (type) = (type_quals & TYPE_QUAL_VOLATILE) != 0;
5919 TYPE_RESTRICT (type) = (type_quals & TYPE_QUAL_RESTRICT) != 0;
5920 TYPE_ATOMIC (type) = (type_quals & TYPE_QUAL_ATOMIC) != 0;
5921 TYPE_ADDR_SPACE (type) = DECODE_QUAL_ADDR_SPACE (type_quals);
5922 }
5923
5924 /* Returns true iff CAND and BASE have equivalent language-specific
5925 qualifiers. */
5926
5927 bool
check_lang_type(const_tree cand,const_tree base)5928 check_lang_type (const_tree cand, const_tree base)
5929 {
5930 if (lang_hooks.types.type_hash_eq == NULL)
5931 return true;
5932 /* type_hash_eq currently only applies to these types. */
5933 if (TREE_CODE (cand) != FUNCTION_TYPE
5934 && TREE_CODE (cand) != METHOD_TYPE)
5935 return true;
5936 return lang_hooks.types.type_hash_eq (cand, base);
5937 }
5938
5939 /* Returns true iff unqualified CAND and BASE are equivalent. */
5940
5941 bool
check_base_type(const_tree cand,const_tree base)5942 check_base_type (const_tree cand, const_tree base)
5943 {
5944 return (TYPE_NAME (cand) == TYPE_NAME (base)
5945 /* Apparently this is needed for Objective-C. */
5946 && TYPE_CONTEXT (cand) == TYPE_CONTEXT (base)
5947 /* Check alignment. */
5948 && TYPE_ALIGN (cand) == TYPE_ALIGN (base)
5949 && attribute_list_equal (TYPE_ATTRIBUTES (cand),
5950 TYPE_ATTRIBUTES (base)));
5951 }
5952
5953 /* Returns true iff CAND is equivalent to BASE with TYPE_QUALS. */
5954
5955 bool
check_qualified_type(const_tree cand,const_tree base,int type_quals)5956 check_qualified_type (const_tree cand, const_tree base, int type_quals)
5957 {
5958 return (TYPE_QUALS (cand) == type_quals
5959 && check_base_type (cand, base)
5960 && check_lang_type (cand, base));
5961 }
5962
5963 /* Returns true iff CAND is equivalent to BASE with ALIGN. */
5964
5965 static bool
check_aligned_type(const_tree cand,const_tree base,unsigned int align)5966 check_aligned_type (const_tree cand, const_tree base, unsigned int align)
5967 {
5968 return (TYPE_QUALS (cand) == TYPE_QUALS (base)
5969 && TYPE_NAME (cand) == TYPE_NAME (base)
5970 /* Apparently this is needed for Objective-C. */
5971 && TYPE_CONTEXT (cand) == TYPE_CONTEXT (base)
5972 /* Check alignment. */
5973 && TYPE_ALIGN (cand) == align
5974 && attribute_list_equal (TYPE_ATTRIBUTES (cand),
5975 TYPE_ATTRIBUTES (base))
5976 && check_lang_type (cand, base));
5977 }
5978
5979 /* This function checks to see if TYPE matches the size one of the built-in
5980 atomic types, and returns that core atomic type. */
5981
5982 static tree
find_atomic_core_type(tree type)5983 find_atomic_core_type (tree type)
5984 {
5985 tree base_atomic_type;
5986
5987 /* Only handle complete types. */
5988 if (!tree_fits_uhwi_p (TYPE_SIZE (type)))
5989 return NULL_TREE;
5990
5991 switch (tree_to_uhwi (TYPE_SIZE (type)))
5992 {
5993 case 8:
5994 base_atomic_type = atomicQI_type_node;
5995 break;
5996
5997 case 16:
5998 base_atomic_type = atomicHI_type_node;
5999 break;
6000
6001 case 32:
6002 base_atomic_type = atomicSI_type_node;
6003 break;
6004
6005 case 64:
6006 base_atomic_type = atomicDI_type_node;
6007 break;
6008
6009 case 128:
6010 base_atomic_type = atomicTI_type_node;
6011 break;
6012
6013 default:
6014 base_atomic_type = NULL_TREE;
6015 }
6016
6017 return base_atomic_type;
6018 }
6019
6020 /* Return a version of the TYPE, qualified as indicated by the
6021 TYPE_QUALS, if one exists. If no qualified version exists yet,
6022 return NULL_TREE. */
6023
6024 tree
get_qualified_type(tree type,int type_quals)6025 get_qualified_type (tree type, int type_quals)
6026 {
6027 tree t;
6028
6029 if (TYPE_QUALS (type) == type_quals)
6030 return type;
6031
6032 /* Search the chain of variants to see if there is already one there just
6033 like the one we need to have. If so, use that existing one. We must
6034 preserve the TYPE_NAME, since there is code that depends on this. */
6035 for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
6036 if (check_qualified_type (t, type, type_quals))
6037 return t;
6038
6039 return NULL_TREE;
6040 }
6041
6042 /* Like get_qualified_type, but creates the type if it does not
6043 exist. This function never returns NULL_TREE. */
6044
6045 tree
build_qualified_type(tree type,int type_quals MEM_STAT_DECL)6046 build_qualified_type (tree type, int type_quals MEM_STAT_DECL)
6047 {
6048 tree t;
6049
6050 /* See if we already have the appropriate qualified variant. */
6051 t = get_qualified_type (type, type_quals);
6052
6053 /* If not, build it. */
6054 if (!t)
6055 {
6056 t = build_variant_type_copy (type PASS_MEM_STAT);
6057 set_type_quals (t, type_quals);
6058
6059 if (((type_quals & TYPE_QUAL_ATOMIC) == TYPE_QUAL_ATOMIC))
6060 {
6061 /* See if this object can map to a basic atomic type. */
6062 tree atomic_type = find_atomic_core_type (type);
6063 if (atomic_type)
6064 {
6065 /* Ensure the alignment of this type is compatible with
6066 the required alignment of the atomic type. */
6067 if (TYPE_ALIGN (atomic_type) > TYPE_ALIGN (t))
6068 SET_TYPE_ALIGN (t, TYPE_ALIGN (atomic_type));
6069 }
6070 }
6071
6072 if (TYPE_STRUCTURAL_EQUALITY_P (type))
6073 /* Propagate structural equality. */
6074 SET_TYPE_STRUCTURAL_EQUALITY (t);
6075 else if (TYPE_CANONICAL (type) != type)
6076 /* Build the underlying canonical type, since it is different
6077 from TYPE. */
6078 {
6079 tree c = build_qualified_type (TYPE_CANONICAL (type), type_quals);
6080 TYPE_CANONICAL (t) = TYPE_CANONICAL (c);
6081 }
6082 else
6083 /* T is its own canonical type. */
6084 TYPE_CANONICAL (t) = t;
6085
6086 }
6087
6088 return t;
6089 }
6090
6091 /* Create a variant of type T with alignment ALIGN. */
6092
6093 tree
build_aligned_type(tree type,unsigned int align)6094 build_aligned_type (tree type, unsigned int align)
6095 {
6096 tree t;
6097
6098 if (TYPE_PACKED (type)
6099 || TYPE_ALIGN (type) == align)
6100 return type;
6101
6102 for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
6103 if (check_aligned_type (t, type, align))
6104 return t;
6105
6106 t = build_variant_type_copy (type);
6107 SET_TYPE_ALIGN (t, align);
6108 TYPE_USER_ALIGN (t) = 1;
6109
6110 return t;
6111 }
6112
6113 /* Create a new distinct copy of TYPE. The new type is made its own
6114 MAIN_VARIANT. If TYPE requires structural equality checks, the
6115 resulting type requires structural equality checks; otherwise, its
6116 TYPE_CANONICAL points to itself. */
6117
6118 tree
build_distinct_type_copy(tree type MEM_STAT_DECL)6119 build_distinct_type_copy (tree type MEM_STAT_DECL)
6120 {
6121 tree t = copy_node (type PASS_MEM_STAT);
6122
6123 TYPE_POINTER_TO (t) = 0;
6124 TYPE_REFERENCE_TO (t) = 0;
6125
6126 /* Set the canonical type either to a new equivalence class, or
6127 propagate the need for structural equality checks. */
6128 if (TYPE_STRUCTURAL_EQUALITY_P (type))
6129 SET_TYPE_STRUCTURAL_EQUALITY (t);
6130 else
6131 TYPE_CANONICAL (t) = t;
6132
6133 /* Make it its own variant. */
6134 TYPE_MAIN_VARIANT (t) = t;
6135 TYPE_NEXT_VARIANT (t) = 0;
6136
6137 /* Note that it is now possible for TYPE_MIN_VALUE to be a value
6138 whose TREE_TYPE is not t. This can also happen in the Ada
6139 frontend when using subtypes. */
6140
6141 return t;
6142 }
6143
6144 /* Create a new variant of TYPE, equivalent but distinct. This is so
6145 the caller can modify it. TYPE_CANONICAL for the return type will
6146 be equivalent to TYPE_CANONICAL of TYPE, indicating that the types
6147 are considered equal by the language itself (or that both types
6148 require structural equality checks). */
6149
6150 tree
build_variant_type_copy(tree type MEM_STAT_DECL)6151 build_variant_type_copy (tree type MEM_STAT_DECL)
6152 {
6153 tree t, m = TYPE_MAIN_VARIANT (type);
6154
6155 t = build_distinct_type_copy (type PASS_MEM_STAT);
6156
6157 /* Since we're building a variant, assume that it is a non-semantic
6158 variant. This also propagates TYPE_STRUCTURAL_EQUALITY_P. */
6159 TYPE_CANONICAL (t) = TYPE_CANONICAL (type);
6160 /* Type variants have no alias set defined. */
6161 TYPE_ALIAS_SET (t) = -1;
6162
6163 /* Add the new type to the chain of variants of TYPE. */
6164 TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (m);
6165 TYPE_NEXT_VARIANT (m) = t;
6166 TYPE_MAIN_VARIANT (t) = m;
6167
6168 return t;
6169 }
6170
6171 /* Return true if the from tree in both tree maps are equal. */
6172
6173 int
tree_map_base_eq(const void * va,const void * vb)6174 tree_map_base_eq (const void *va, const void *vb)
6175 {
6176 const struct tree_map_base *const a = (const struct tree_map_base *) va,
6177 *const b = (const struct tree_map_base *) vb;
6178 return (a->from == b->from);
6179 }
6180
6181 /* Hash a from tree in a tree_base_map. */
6182
6183 unsigned int
tree_map_base_hash(const void * item)6184 tree_map_base_hash (const void *item)
6185 {
6186 return htab_hash_pointer (((const struct tree_map_base *)item)->from);
6187 }
6188
6189 /* Return true if this tree map structure is marked for garbage collection
6190 purposes. We simply return true if the from tree is marked, so that this
6191 structure goes away when the from tree goes away. */
6192
6193 int
tree_map_base_marked_p(const void * p)6194 tree_map_base_marked_p (const void *p)
6195 {
6196 return ggc_marked_p (((const struct tree_map_base *) p)->from);
6197 }
6198
6199 /* Hash a from tree in a tree_map. */
6200
6201 unsigned int
tree_map_hash(const void * item)6202 tree_map_hash (const void *item)
6203 {
6204 return (((const struct tree_map *) item)->hash);
6205 }
6206
6207 /* Hash a from tree in a tree_decl_map. */
6208
6209 unsigned int
tree_decl_map_hash(const void * item)6210 tree_decl_map_hash (const void *item)
6211 {
6212 return DECL_UID (((const struct tree_decl_map *) item)->base.from);
6213 }
6214
6215 /* Return the initialization priority for DECL. */
6216
6217 priority_type
decl_init_priority_lookup(tree decl)6218 decl_init_priority_lookup (tree decl)
6219 {
6220 symtab_node *snode = symtab_node::get (decl);
6221
6222 if (!snode)
6223 return DEFAULT_INIT_PRIORITY;
6224 return
6225 snode->get_init_priority ();
6226 }
6227
6228 /* Return the finalization priority for DECL. */
6229
6230 priority_type
decl_fini_priority_lookup(tree decl)6231 decl_fini_priority_lookup (tree decl)
6232 {
6233 cgraph_node *node = cgraph_node::get (decl);
6234
6235 if (!node)
6236 return DEFAULT_INIT_PRIORITY;
6237 return
6238 node->get_fini_priority ();
6239 }
6240
6241 /* Set the initialization priority for DECL to PRIORITY. */
6242
6243 void
decl_init_priority_insert(tree decl,priority_type priority)6244 decl_init_priority_insert (tree decl, priority_type priority)
6245 {
6246 struct symtab_node *snode;
6247
6248 if (priority == DEFAULT_INIT_PRIORITY)
6249 {
6250 snode = symtab_node::get (decl);
6251 if (!snode)
6252 return;
6253 }
6254 else if (VAR_P (decl))
6255 snode = varpool_node::get_create (decl);
6256 else
6257 snode = cgraph_node::get_create (decl);
6258 snode->set_init_priority (priority);
6259 }
6260
6261 /* Set the finalization priority for DECL to PRIORITY. */
6262
6263 void
decl_fini_priority_insert(tree decl,priority_type priority)6264 decl_fini_priority_insert (tree decl, priority_type priority)
6265 {
6266 struct cgraph_node *node;
6267
6268 if (priority == DEFAULT_INIT_PRIORITY)
6269 {
6270 node = cgraph_node::get (decl);
6271 if (!node)
6272 return;
6273 }
6274 else
6275 node = cgraph_node::get_create (decl);
6276 node->set_fini_priority (priority);
6277 }
6278
6279 /* Print out the statistics for the DECL_DEBUG_EXPR hash table. */
6280
6281 static void
print_debug_expr_statistics(void)6282 print_debug_expr_statistics (void)
6283 {
6284 fprintf (stderr, "DECL_DEBUG_EXPR hash: size %ld, %ld elements, %f collisions\n",
6285 (long) debug_expr_for_decl->size (),
6286 (long) debug_expr_for_decl->elements (),
6287 debug_expr_for_decl->collisions ());
6288 }
6289
6290 /* Print out the statistics for the DECL_VALUE_EXPR hash table. */
6291
6292 static void
print_value_expr_statistics(void)6293 print_value_expr_statistics (void)
6294 {
6295 fprintf (stderr, "DECL_VALUE_EXPR hash: size %ld, %ld elements, %f collisions\n",
6296 (long) value_expr_for_decl->size (),
6297 (long) value_expr_for_decl->elements (),
6298 value_expr_for_decl->collisions ());
6299 }
6300
6301 /* Lookup a debug expression for FROM, and return it if we find one. */
6302
6303 tree
decl_debug_expr_lookup(tree from)6304 decl_debug_expr_lookup (tree from)
6305 {
6306 struct tree_decl_map *h, in;
6307 in.base.from = from;
6308
6309 h = debug_expr_for_decl->find_with_hash (&in, DECL_UID (from));
6310 if (h)
6311 return h->to;
6312 return NULL_TREE;
6313 }
6314
6315 /* Insert a mapping FROM->TO in the debug expression hashtable. */
6316
6317 void
decl_debug_expr_insert(tree from,tree to)6318 decl_debug_expr_insert (tree from, tree to)
6319 {
6320 struct tree_decl_map *h;
6321
6322 h = ggc_alloc<tree_decl_map> ();
6323 h->base.from = from;
6324 h->to = to;
6325 *debug_expr_for_decl->find_slot_with_hash (h, DECL_UID (from), INSERT) = h;
6326 }
6327
6328 /* Lookup a value expression for FROM, and return it if we find one. */
6329
6330 tree
decl_value_expr_lookup(tree from)6331 decl_value_expr_lookup (tree from)
6332 {
6333 struct tree_decl_map *h, in;
6334 in.base.from = from;
6335
6336 h = value_expr_for_decl->find_with_hash (&in, DECL_UID (from));
6337 if (h)
6338 return h->to;
6339 return NULL_TREE;
6340 }
6341
6342 /* Insert a mapping FROM->TO in the value expression hashtable. */
6343
6344 void
decl_value_expr_insert(tree from,tree to)6345 decl_value_expr_insert (tree from, tree to)
6346 {
6347 struct tree_decl_map *h;
6348
6349 h = ggc_alloc<tree_decl_map> ();
6350 h->base.from = from;
6351 h->to = to;
6352 *value_expr_for_decl->find_slot_with_hash (h, DECL_UID (from), INSERT) = h;
6353 }
6354
6355 /* Lookup a vector of debug arguments for FROM, and return it if we
6356 find one. */
6357
6358 vec<tree, va_gc> **
decl_debug_args_lookup(tree from)6359 decl_debug_args_lookup (tree from)
6360 {
6361 struct tree_vec_map *h, in;
6362
6363 if (!DECL_HAS_DEBUG_ARGS_P (from))
6364 return NULL;
6365 gcc_checking_assert (debug_args_for_decl != NULL);
6366 in.base.from = from;
6367 h = debug_args_for_decl->find_with_hash (&in, DECL_UID (from));
6368 if (h)
6369 return &h->to;
6370 return NULL;
6371 }
6372
6373 /* Insert a mapping FROM->empty vector of debug arguments in the value
6374 expression hashtable. */
6375
6376 vec<tree, va_gc> **
decl_debug_args_insert(tree from)6377 decl_debug_args_insert (tree from)
6378 {
6379 struct tree_vec_map *h;
6380 tree_vec_map **loc;
6381
6382 if (DECL_HAS_DEBUG_ARGS_P (from))
6383 return decl_debug_args_lookup (from);
6384 if (debug_args_for_decl == NULL)
6385 debug_args_for_decl = hash_table<tree_vec_map_cache_hasher>::create_ggc (64);
6386 h = ggc_alloc<tree_vec_map> ();
6387 h->base.from = from;
6388 h->to = NULL;
6389 loc = debug_args_for_decl->find_slot_with_hash (h, DECL_UID (from), INSERT);
6390 *loc = h;
6391 DECL_HAS_DEBUG_ARGS_P (from) = 1;
6392 return &h->to;
6393 }
6394
6395 /* Hashing of types so that we don't make duplicates.
6396 The entry point is `type_hash_canon'. */
6397
6398 /* Generate the default hash code for TYPE. This is designed for
6399 speed, rather than maximum entropy. */
6400
6401 hashval_t
type_hash_canon_hash(tree type)6402 type_hash_canon_hash (tree type)
6403 {
6404 inchash::hash hstate;
6405
6406 hstate.add_int (TREE_CODE (type));
6407
6408 if (TREE_TYPE (type))
6409 hstate.add_object (TYPE_HASH (TREE_TYPE (type)));
6410
6411 for (tree t = TYPE_ATTRIBUTES (type); t; t = TREE_CHAIN (t))
6412 /* Just the identifier is adequate to distinguish. */
6413 hstate.add_object (IDENTIFIER_HASH_VALUE (get_attribute_name (t)));
6414
6415 switch (TREE_CODE (type))
6416 {
6417 case METHOD_TYPE:
6418 hstate.add_object (TYPE_HASH (TYPE_METHOD_BASETYPE (type)));
6419 /* FALLTHROUGH. */
6420 case FUNCTION_TYPE:
6421 for (tree t = TYPE_ARG_TYPES (type); t; t = TREE_CHAIN (t))
6422 if (TREE_VALUE (t) != error_mark_node)
6423 hstate.add_object (TYPE_HASH (TREE_VALUE (t)));
6424 break;
6425
6426 case OFFSET_TYPE:
6427 hstate.add_object (TYPE_HASH (TYPE_OFFSET_BASETYPE (type)));
6428 break;
6429
6430 case ARRAY_TYPE:
6431 {
6432 if (TYPE_DOMAIN (type))
6433 hstate.add_object (TYPE_HASH (TYPE_DOMAIN (type)));
6434 if (!AGGREGATE_TYPE_P (TREE_TYPE (type)))
6435 {
6436 unsigned typeless = TYPE_TYPELESS_STORAGE (type);
6437 hstate.add_object (typeless);
6438 }
6439 }
6440 break;
6441
6442 case INTEGER_TYPE:
6443 {
6444 tree t = TYPE_MAX_VALUE (type);
6445 if (!t)
6446 t = TYPE_MIN_VALUE (type);
6447 for (int i = 0; i < TREE_INT_CST_NUNITS (t); i++)
6448 hstate.add_object (TREE_INT_CST_ELT (t, i));
6449 break;
6450 }
6451
6452 case REAL_TYPE:
6453 case FIXED_POINT_TYPE:
6454 {
6455 unsigned prec = TYPE_PRECISION (type);
6456 hstate.add_object (prec);
6457 break;
6458 }
6459
6460 case VECTOR_TYPE:
6461 hstate.add_poly_int (TYPE_VECTOR_SUBPARTS (type));
6462 break;
6463
6464 default:
6465 break;
6466 }
6467
6468 return hstate.end ();
6469 }
6470
6471 /* These are the Hashtable callback functions. */
6472
6473 /* Returns true iff the types are equivalent. */
6474
6475 bool
equal(type_hash * a,type_hash * b)6476 type_cache_hasher::equal (type_hash *a, type_hash *b)
6477 {
6478 /* First test the things that are the same for all types. */
6479 if (a->hash != b->hash
6480 || TREE_CODE (a->type) != TREE_CODE (b->type)
6481 || TREE_TYPE (a->type) != TREE_TYPE (b->type)
6482 || !attribute_list_equal (TYPE_ATTRIBUTES (a->type),
6483 TYPE_ATTRIBUTES (b->type))
6484 || (TREE_CODE (a->type) != COMPLEX_TYPE
6485 && TYPE_NAME (a->type) != TYPE_NAME (b->type)))
6486 return 0;
6487
6488 /* Be careful about comparing arrays before and after the element type
6489 has been completed; don't compare TYPE_ALIGN unless both types are
6490 complete. */
6491 if (COMPLETE_TYPE_P (a->type) && COMPLETE_TYPE_P (b->type)
6492 && (TYPE_ALIGN (a->type) != TYPE_ALIGN (b->type)
6493 || TYPE_MODE (a->type) != TYPE_MODE (b->type)))
6494 return 0;
6495
6496 switch (TREE_CODE (a->type))
6497 {
6498 case VOID_TYPE:
6499 case COMPLEX_TYPE:
6500 case POINTER_TYPE:
6501 case REFERENCE_TYPE:
6502 case NULLPTR_TYPE:
6503 return 1;
6504
6505 case VECTOR_TYPE:
6506 return known_eq (TYPE_VECTOR_SUBPARTS (a->type),
6507 TYPE_VECTOR_SUBPARTS (b->type));
6508
6509 case ENUMERAL_TYPE:
6510 if (TYPE_VALUES (a->type) != TYPE_VALUES (b->type)
6511 && !(TYPE_VALUES (a->type)
6512 && TREE_CODE (TYPE_VALUES (a->type)) == TREE_LIST
6513 && TYPE_VALUES (b->type)
6514 && TREE_CODE (TYPE_VALUES (b->type)) == TREE_LIST
6515 && type_list_equal (TYPE_VALUES (a->type),
6516 TYPE_VALUES (b->type))))
6517 return 0;
6518
6519 /* fall through */
6520
6521 case INTEGER_TYPE:
6522 case REAL_TYPE:
6523 case BOOLEAN_TYPE:
6524 if (TYPE_PRECISION (a->type) != TYPE_PRECISION (b->type))
6525 return false;
6526 return ((TYPE_MAX_VALUE (a->type) == TYPE_MAX_VALUE (b->type)
6527 || tree_int_cst_equal (TYPE_MAX_VALUE (a->type),
6528 TYPE_MAX_VALUE (b->type)))
6529 && (TYPE_MIN_VALUE (a->type) == TYPE_MIN_VALUE (b->type)
6530 || tree_int_cst_equal (TYPE_MIN_VALUE (a->type),
6531 TYPE_MIN_VALUE (b->type))));
6532
6533 case FIXED_POINT_TYPE:
6534 return TYPE_SATURATING (a->type) == TYPE_SATURATING (b->type);
6535
6536 case OFFSET_TYPE:
6537 return TYPE_OFFSET_BASETYPE (a->type) == TYPE_OFFSET_BASETYPE (b->type);
6538
6539 case METHOD_TYPE:
6540 if (TYPE_METHOD_BASETYPE (a->type) == TYPE_METHOD_BASETYPE (b->type)
6541 && (TYPE_ARG_TYPES (a->type) == TYPE_ARG_TYPES (b->type)
6542 || (TYPE_ARG_TYPES (a->type)
6543 && TREE_CODE (TYPE_ARG_TYPES (a->type)) == TREE_LIST
6544 && TYPE_ARG_TYPES (b->type)
6545 && TREE_CODE (TYPE_ARG_TYPES (b->type)) == TREE_LIST
6546 && type_list_equal (TYPE_ARG_TYPES (a->type),
6547 TYPE_ARG_TYPES (b->type)))))
6548 break;
6549 return 0;
6550 case ARRAY_TYPE:
6551 /* Don't compare TYPE_TYPELESS_STORAGE flag on aggregates,
6552 where the flag should be inherited from the element type
6553 and can change after ARRAY_TYPEs are created; on non-aggregates
6554 compare it and hash it, scalars will never have that flag set
6555 and we need to differentiate between arrays created by different
6556 front-ends or middle-end created arrays. */
6557 return (TYPE_DOMAIN (a->type) == TYPE_DOMAIN (b->type)
6558 && (AGGREGATE_TYPE_P (TREE_TYPE (a->type))
6559 || (TYPE_TYPELESS_STORAGE (a->type)
6560 == TYPE_TYPELESS_STORAGE (b->type))));
6561
6562 case RECORD_TYPE:
6563 case UNION_TYPE:
6564 case QUAL_UNION_TYPE:
6565 return (TYPE_FIELDS (a->type) == TYPE_FIELDS (b->type)
6566 || (TYPE_FIELDS (a->type)
6567 && TREE_CODE (TYPE_FIELDS (a->type)) == TREE_LIST
6568 && TYPE_FIELDS (b->type)
6569 && TREE_CODE (TYPE_FIELDS (b->type)) == TREE_LIST
6570 && type_list_equal (TYPE_FIELDS (a->type),
6571 TYPE_FIELDS (b->type))));
6572
6573 case FUNCTION_TYPE:
6574 if (TYPE_ARG_TYPES (a->type) == TYPE_ARG_TYPES (b->type)
6575 || (TYPE_ARG_TYPES (a->type)
6576 && TREE_CODE (TYPE_ARG_TYPES (a->type)) == TREE_LIST
6577 && TYPE_ARG_TYPES (b->type)
6578 && TREE_CODE (TYPE_ARG_TYPES (b->type)) == TREE_LIST
6579 && type_list_equal (TYPE_ARG_TYPES (a->type),
6580 TYPE_ARG_TYPES (b->type))))
6581 break;
6582 return 0;
6583
6584 default:
6585 return 0;
6586 }
6587
6588 if (lang_hooks.types.type_hash_eq != NULL)
6589 return lang_hooks.types.type_hash_eq (a->type, b->type);
6590
6591 return 1;
6592 }
6593
6594 /* Given TYPE, and HASHCODE its hash code, return the canonical
6595 object for an identical type if one already exists.
6596 Otherwise, return TYPE, and record it as the canonical object.
6597
6598 To use this function, first create a type of the sort you want.
6599 Then compute its hash code from the fields of the type that
6600 make it different from other similar types.
6601 Then call this function and use the value. */
6602
6603 tree
type_hash_canon(unsigned int hashcode,tree type)6604 type_hash_canon (unsigned int hashcode, tree type)
6605 {
6606 type_hash in;
6607 type_hash **loc;
6608
6609 /* The hash table only contains main variants, so ensure that's what we're
6610 being passed. */
6611 gcc_assert (TYPE_MAIN_VARIANT (type) == type);
6612
6613 /* The TYPE_ALIGN field of a type is set by layout_type(), so we
6614 must call that routine before comparing TYPE_ALIGNs. */
6615 layout_type (type);
6616
6617 in.hash = hashcode;
6618 in.type = type;
6619
6620 loc = type_hash_table->find_slot_with_hash (&in, hashcode, INSERT);
6621 if (*loc)
6622 {
6623 tree t1 = ((type_hash *) *loc)->type;
6624 gcc_assert (TYPE_MAIN_VARIANT (t1) == t1
6625 && t1 != type);
6626 if (TYPE_UID (type) + 1 == next_type_uid)
6627 --next_type_uid;
6628 /* Free also min/max values and the cache for integer
6629 types. This can't be done in free_node, as LTO frees
6630 those on its own. */
6631 if (TREE_CODE (type) == INTEGER_TYPE)
6632 {
6633 if (TYPE_MIN_VALUE (type)
6634 && TREE_TYPE (TYPE_MIN_VALUE (type)) == type)
6635 {
6636 /* Zero is always in TYPE_CACHED_VALUES. */
6637 if (! TYPE_UNSIGNED (type))
6638 int_cst_hash_table->remove_elt (TYPE_MIN_VALUE (type));
6639 ggc_free (TYPE_MIN_VALUE (type));
6640 }
6641 if (TYPE_MAX_VALUE (type)
6642 && TREE_TYPE (TYPE_MAX_VALUE (type)) == type)
6643 {
6644 int_cst_hash_table->remove_elt (TYPE_MAX_VALUE (type));
6645 ggc_free (TYPE_MAX_VALUE (type));
6646 }
6647 if (TYPE_CACHED_VALUES_P (type))
6648 ggc_free (TYPE_CACHED_VALUES (type));
6649 }
6650 free_node (type);
6651 return t1;
6652 }
6653 else
6654 {
6655 struct type_hash *h;
6656
6657 h = ggc_alloc<type_hash> ();
6658 h->hash = hashcode;
6659 h->type = type;
6660 *loc = h;
6661
6662 return type;
6663 }
6664 }
6665
6666 static void
print_type_hash_statistics(void)6667 print_type_hash_statistics (void)
6668 {
6669 fprintf (stderr, "Type hash: size %ld, %ld elements, %f collisions\n",
6670 (long) type_hash_table->size (),
6671 (long) type_hash_table->elements (),
6672 type_hash_table->collisions ());
6673 }
6674
6675 /* Given two lists of types
6676 (chains of TREE_LIST nodes with types in the TREE_VALUE slots)
6677 return 1 if the lists contain the same types in the same order.
6678 Also, the TREE_PURPOSEs must match. */
6679
6680 int
type_list_equal(const_tree l1,const_tree l2)6681 type_list_equal (const_tree l1, const_tree l2)
6682 {
6683 const_tree t1, t2;
6684
6685 for (t1 = l1, t2 = l2; t1 && t2; t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2))
6686 if (TREE_VALUE (t1) != TREE_VALUE (t2)
6687 || (TREE_PURPOSE (t1) != TREE_PURPOSE (t2)
6688 && ! (1 == simple_cst_equal (TREE_PURPOSE (t1), TREE_PURPOSE (t2))
6689 && (TREE_TYPE (TREE_PURPOSE (t1))
6690 == TREE_TYPE (TREE_PURPOSE (t2))))))
6691 return 0;
6692
6693 return t1 == t2;
6694 }
6695
6696 /* Returns the number of arguments to the FUNCTION_TYPE or METHOD_TYPE
6697 given by TYPE. If the argument list accepts variable arguments,
6698 then this function counts only the ordinary arguments. */
6699
6700 int
type_num_arguments(const_tree type)6701 type_num_arguments (const_tree type)
6702 {
6703 int i = 0;
6704 tree t;
6705
6706 for (t = TYPE_ARG_TYPES (type); t; t = TREE_CHAIN (t))
6707 /* If the function does not take a variable number of arguments,
6708 the last element in the list will have type `void'. */
6709 if (VOID_TYPE_P (TREE_VALUE (t)))
6710 break;
6711 else
6712 ++i;
6713
6714 return i;
6715 }
6716
6717 /* Nonzero if integer constants T1 and T2
6718 represent the same constant value. */
6719
6720 int
tree_int_cst_equal(const_tree t1,const_tree t2)6721 tree_int_cst_equal (const_tree t1, const_tree t2)
6722 {
6723 if (t1 == t2)
6724 return 1;
6725
6726 if (t1 == 0 || t2 == 0)
6727 return 0;
6728
6729 if (TREE_CODE (t1) == INTEGER_CST
6730 && TREE_CODE (t2) == INTEGER_CST
6731 && wi::to_widest (t1) == wi::to_widest (t2))
6732 return 1;
6733
6734 return 0;
6735 }
6736
6737 /* Return true if T is an INTEGER_CST whose numerical value (extended
6738 according to TYPE_UNSIGNED) fits in a signed HOST_WIDE_INT. */
6739
6740 bool
tree_fits_shwi_p(const_tree t)6741 tree_fits_shwi_p (const_tree t)
6742 {
6743 return (t != NULL_TREE
6744 && TREE_CODE (t) == INTEGER_CST
6745 && wi::fits_shwi_p (wi::to_widest (t)));
6746 }
6747
6748 /* Return true if T is an INTEGER_CST or POLY_INT_CST whose numerical
6749 value (extended according to TYPE_UNSIGNED) fits in a poly_int64. */
6750
6751 bool
tree_fits_poly_int64_p(const_tree t)6752 tree_fits_poly_int64_p (const_tree t)
6753 {
6754 if (t == NULL_TREE)
6755 return false;
6756 if (POLY_INT_CST_P (t))
6757 {
6758 for (unsigned int i = 0; i < NUM_POLY_INT_COEFFS; i++)
6759 if (!wi::fits_shwi_p (wi::to_wide (POLY_INT_CST_COEFF (t, i))))
6760 return false;
6761 return true;
6762 }
6763 return (TREE_CODE (t) == INTEGER_CST
6764 && wi::fits_shwi_p (wi::to_widest (t)));
6765 }
6766
6767 /* Return true if T is an INTEGER_CST whose numerical value (extended
6768 according to TYPE_UNSIGNED) fits in an unsigned HOST_WIDE_INT. */
6769
6770 bool
tree_fits_uhwi_p(const_tree t)6771 tree_fits_uhwi_p (const_tree t)
6772 {
6773 return (t != NULL_TREE
6774 && TREE_CODE (t) == INTEGER_CST
6775 && wi::fits_uhwi_p (wi::to_widest (t)));
6776 }
6777
6778 /* Return true if T is an INTEGER_CST or POLY_INT_CST whose numerical
6779 value (extended according to TYPE_UNSIGNED) fits in a poly_uint64. */
6780
6781 bool
tree_fits_poly_uint64_p(const_tree t)6782 tree_fits_poly_uint64_p (const_tree t)
6783 {
6784 if (t == NULL_TREE)
6785 return false;
6786 if (POLY_INT_CST_P (t))
6787 {
6788 for (unsigned int i = 0; i < NUM_POLY_INT_COEFFS; i++)
6789 if (!wi::fits_uhwi_p (wi::to_widest (POLY_INT_CST_COEFF (t, i))))
6790 return false;
6791 return true;
6792 }
6793 return (TREE_CODE (t) == INTEGER_CST
6794 && wi::fits_uhwi_p (wi::to_widest (t)));
6795 }
6796
6797 /* T is an INTEGER_CST whose numerical value (extended according to
6798 TYPE_UNSIGNED) fits in a signed HOST_WIDE_INT. Return that
6799 HOST_WIDE_INT. */
6800
6801 HOST_WIDE_INT
tree_to_shwi(const_tree t)6802 tree_to_shwi (const_tree t)
6803 {
6804 gcc_assert (tree_fits_shwi_p (t));
6805 return TREE_INT_CST_LOW (t);
6806 }
6807
6808 /* T is an INTEGER_CST whose numerical value (extended according to
6809 TYPE_UNSIGNED) fits in an unsigned HOST_WIDE_INT. Return that
6810 HOST_WIDE_INT. */
6811
6812 unsigned HOST_WIDE_INT
tree_to_uhwi(const_tree t)6813 tree_to_uhwi (const_tree t)
6814 {
6815 gcc_assert (tree_fits_uhwi_p (t));
6816 return TREE_INT_CST_LOW (t);
6817 }
6818
6819 /* Return the most significant (sign) bit of T. */
6820
6821 int
tree_int_cst_sign_bit(const_tree t)6822 tree_int_cst_sign_bit (const_tree t)
6823 {
6824 unsigned bitno = TYPE_PRECISION (TREE_TYPE (t)) - 1;
6825
6826 return wi::extract_uhwi (wi::to_wide (t), bitno, 1);
6827 }
6828
6829 /* Return an indication of the sign of the integer constant T.
6830 The return value is -1 if T < 0, 0 if T == 0, and 1 if T > 0.
6831 Note that -1 will never be returned if T's type is unsigned. */
6832
6833 int
tree_int_cst_sgn(const_tree t)6834 tree_int_cst_sgn (const_tree t)
6835 {
6836 if (wi::to_wide (t) == 0)
6837 return 0;
6838 else if (TYPE_UNSIGNED (TREE_TYPE (t)))
6839 return 1;
6840 else if (wi::neg_p (wi::to_wide (t)))
6841 return -1;
6842 else
6843 return 1;
6844 }
6845
6846 /* Return the minimum number of bits needed to represent VALUE in a
6847 signed or unsigned type, UNSIGNEDP says which. */
6848
6849 unsigned int
tree_int_cst_min_precision(tree value,signop sgn)6850 tree_int_cst_min_precision (tree value, signop sgn)
6851 {
6852 /* If the value is negative, compute its negative minus 1. The latter
6853 adjustment is because the absolute value of the largest negative value
6854 is one larger than the largest positive value. This is equivalent to
6855 a bit-wise negation, so use that operation instead. */
6856
6857 if (tree_int_cst_sgn (value) < 0)
6858 value = fold_build1 (BIT_NOT_EXPR, TREE_TYPE (value), value);
6859
6860 /* Return the number of bits needed, taking into account the fact
6861 that we need one more bit for a signed than unsigned type.
6862 If value is 0 or -1, the minimum precision is 1 no matter
6863 whether unsignedp is true or false. */
6864
6865 if (integer_zerop (value))
6866 return 1;
6867 else
6868 return tree_floor_log2 (value) + 1 + (sgn == SIGNED ? 1 : 0) ;
6869 }
6870
6871 /* Return truthvalue of whether T1 is the same tree structure as T2.
6872 Return 1 if they are the same.
6873 Return 0 if they are understandably different.
6874 Return -1 if either contains tree structure not understood by
6875 this function. */
6876
6877 int
simple_cst_equal(const_tree t1,const_tree t2)6878 simple_cst_equal (const_tree t1, const_tree t2)
6879 {
6880 enum tree_code code1, code2;
6881 int cmp;
6882 int i;
6883
6884 if (t1 == t2)
6885 return 1;
6886 if (t1 == 0 || t2 == 0)
6887 return 0;
6888
6889 code1 = TREE_CODE (t1);
6890 code2 = TREE_CODE (t2);
6891
6892 if (CONVERT_EXPR_CODE_P (code1) || code1 == NON_LVALUE_EXPR)
6893 {
6894 if (CONVERT_EXPR_CODE_P (code2)
6895 || code2 == NON_LVALUE_EXPR)
6896 return simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
6897 else
6898 return simple_cst_equal (TREE_OPERAND (t1, 0), t2);
6899 }
6900
6901 else if (CONVERT_EXPR_CODE_P (code2)
6902 || code2 == NON_LVALUE_EXPR)
6903 return simple_cst_equal (t1, TREE_OPERAND (t2, 0));
6904
6905 if (code1 != code2)
6906 return 0;
6907
6908 switch (code1)
6909 {
6910 case INTEGER_CST:
6911 return wi::to_widest (t1) == wi::to_widest (t2);
6912
6913 case REAL_CST:
6914 return real_identical (&TREE_REAL_CST (t1), &TREE_REAL_CST (t2));
6915
6916 case FIXED_CST:
6917 return FIXED_VALUES_IDENTICAL (TREE_FIXED_CST (t1), TREE_FIXED_CST (t2));
6918
6919 case STRING_CST:
6920 return (TREE_STRING_LENGTH (t1) == TREE_STRING_LENGTH (t2)
6921 && ! memcmp (TREE_STRING_POINTER (t1), TREE_STRING_POINTER (t2),
6922 TREE_STRING_LENGTH (t1)));
6923
6924 case CONSTRUCTOR:
6925 {
6926 unsigned HOST_WIDE_INT idx;
6927 vec<constructor_elt, va_gc> *v1 = CONSTRUCTOR_ELTS (t1);
6928 vec<constructor_elt, va_gc> *v2 = CONSTRUCTOR_ELTS (t2);
6929
6930 if (vec_safe_length (v1) != vec_safe_length (v2))
6931 return false;
6932
6933 for (idx = 0; idx < vec_safe_length (v1); ++idx)
6934 /* ??? Should we handle also fields here? */
6935 if (!simple_cst_equal ((*v1)[idx].value, (*v2)[idx].value))
6936 return false;
6937 return true;
6938 }
6939
6940 case SAVE_EXPR:
6941 return simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
6942
6943 case CALL_EXPR:
6944 cmp = simple_cst_equal (CALL_EXPR_FN (t1), CALL_EXPR_FN (t2));
6945 if (cmp <= 0)
6946 return cmp;
6947 if (call_expr_nargs (t1) != call_expr_nargs (t2))
6948 return 0;
6949 {
6950 const_tree arg1, arg2;
6951 const_call_expr_arg_iterator iter1, iter2;
6952 for (arg1 = first_const_call_expr_arg (t1, &iter1),
6953 arg2 = first_const_call_expr_arg (t2, &iter2);
6954 arg1 && arg2;
6955 arg1 = next_const_call_expr_arg (&iter1),
6956 arg2 = next_const_call_expr_arg (&iter2))
6957 {
6958 cmp = simple_cst_equal (arg1, arg2);
6959 if (cmp <= 0)
6960 return cmp;
6961 }
6962 return arg1 == arg2;
6963 }
6964
6965 case TARGET_EXPR:
6966 /* Special case: if either target is an unallocated VAR_DECL,
6967 it means that it's going to be unified with whatever the
6968 TARGET_EXPR is really supposed to initialize, so treat it
6969 as being equivalent to anything. */
6970 if ((TREE_CODE (TREE_OPERAND (t1, 0)) == VAR_DECL
6971 && DECL_NAME (TREE_OPERAND (t1, 0)) == NULL_TREE
6972 && !DECL_RTL_SET_P (TREE_OPERAND (t1, 0)))
6973 || (TREE_CODE (TREE_OPERAND (t2, 0)) == VAR_DECL
6974 && DECL_NAME (TREE_OPERAND (t2, 0)) == NULL_TREE
6975 && !DECL_RTL_SET_P (TREE_OPERAND (t2, 0))))
6976 cmp = 1;
6977 else
6978 cmp = simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
6979
6980 if (cmp <= 0)
6981 return cmp;
6982
6983 return simple_cst_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1));
6984
6985 case WITH_CLEANUP_EXPR:
6986 cmp = simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
6987 if (cmp <= 0)
6988 return cmp;
6989
6990 return simple_cst_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t1, 1));
6991
6992 case COMPONENT_REF:
6993 if (TREE_OPERAND (t1, 1) == TREE_OPERAND (t2, 1))
6994 return simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
6995
6996 return 0;
6997
6998 case VAR_DECL:
6999 case PARM_DECL:
7000 case CONST_DECL:
7001 case FUNCTION_DECL:
7002 return 0;
7003
7004 default:
7005 if (POLY_INT_CST_P (t1))
7006 /* A false return means maybe_ne rather than known_ne. */
7007 return known_eq (poly_widest_int::from (poly_int_cst_value (t1),
7008 TYPE_SIGN (TREE_TYPE (t1))),
7009 poly_widest_int::from (poly_int_cst_value (t2),
7010 TYPE_SIGN (TREE_TYPE (t2))));
7011 break;
7012 }
7013
7014 /* This general rule works for most tree codes. All exceptions should be
7015 handled above. If this is a language-specific tree code, we can't
7016 trust what might be in the operand, so say we don't know
7017 the situation. */
7018 if ((int) code1 >= (int) LAST_AND_UNUSED_TREE_CODE)
7019 return -1;
7020
7021 switch (TREE_CODE_CLASS (code1))
7022 {
7023 case tcc_unary:
7024 case tcc_binary:
7025 case tcc_comparison:
7026 case tcc_expression:
7027 case tcc_reference:
7028 case tcc_statement:
7029 cmp = 1;
7030 for (i = 0; i < TREE_CODE_LENGTH (code1); i++)
7031 {
7032 cmp = simple_cst_equal (TREE_OPERAND (t1, i), TREE_OPERAND (t2, i));
7033 if (cmp <= 0)
7034 return cmp;
7035 }
7036
7037 return cmp;
7038
7039 default:
7040 return -1;
7041 }
7042 }
7043
7044 /* Compare the value of T, an INTEGER_CST, with U, an unsigned integer value.
7045 Return -1, 0, or 1 if the value of T is less than, equal to, or greater
7046 than U, respectively. */
7047
7048 int
compare_tree_int(const_tree t,unsigned HOST_WIDE_INT u)7049 compare_tree_int (const_tree t, unsigned HOST_WIDE_INT u)
7050 {
7051 if (tree_int_cst_sgn (t) < 0)
7052 return -1;
7053 else if (!tree_fits_uhwi_p (t))
7054 return 1;
7055 else if (TREE_INT_CST_LOW (t) == u)
7056 return 0;
7057 else if (TREE_INT_CST_LOW (t) < u)
7058 return -1;
7059 else
7060 return 1;
7061 }
7062
7063 /* Return true if SIZE represents a constant size that is in bounds of
7064 what the middle-end and the backend accepts (covering not more than
7065 half of the address-space). */
7066
7067 bool
valid_constant_size_p(const_tree size)7068 valid_constant_size_p (const_tree size)
7069 {
7070 if (POLY_INT_CST_P (size))
7071 {
7072 if (TREE_OVERFLOW (size))
7073 return false;
7074 for (unsigned int i = 0; i < NUM_POLY_INT_COEFFS; ++i)
7075 if (!valid_constant_size_p (POLY_INT_CST_COEFF (size, i)))
7076 return false;
7077 return true;
7078 }
7079 if (! tree_fits_uhwi_p (size)
7080 || TREE_OVERFLOW (size)
7081 || tree_int_cst_sign_bit (size) != 0)
7082 return false;
7083 return true;
7084 }
7085
7086 /* Return the precision of the type, or for a complex or vector type the
7087 precision of the type of its elements. */
7088
7089 unsigned int
element_precision(const_tree type)7090 element_precision (const_tree type)
7091 {
7092 if (!TYPE_P (type))
7093 type = TREE_TYPE (type);
7094 enum tree_code code = TREE_CODE (type);
7095 if (code == COMPLEX_TYPE || code == VECTOR_TYPE)
7096 type = TREE_TYPE (type);
7097
7098 return TYPE_PRECISION (type);
7099 }
7100
7101 /* Return true if CODE represents an associative tree code. Otherwise
7102 return false. */
7103 bool
associative_tree_code(enum tree_code code)7104 associative_tree_code (enum tree_code code)
7105 {
7106 switch (code)
7107 {
7108 case BIT_IOR_EXPR:
7109 case BIT_AND_EXPR:
7110 case BIT_XOR_EXPR:
7111 case PLUS_EXPR:
7112 case MULT_EXPR:
7113 case MIN_EXPR:
7114 case MAX_EXPR:
7115 return true;
7116
7117 default:
7118 break;
7119 }
7120 return false;
7121 }
7122
7123 /* Return true if CODE represents a commutative tree code. Otherwise
7124 return false. */
7125 bool
commutative_tree_code(enum tree_code code)7126 commutative_tree_code (enum tree_code code)
7127 {
7128 switch (code)
7129 {
7130 case PLUS_EXPR:
7131 case MULT_EXPR:
7132 case MULT_HIGHPART_EXPR:
7133 case MIN_EXPR:
7134 case MAX_EXPR:
7135 case BIT_IOR_EXPR:
7136 case BIT_XOR_EXPR:
7137 case BIT_AND_EXPR:
7138 case NE_EXPR:
7139 case EQ_EXPR:
7140 case UNORDERED_EXPR:
7141 case ORDERED_EXPR:
7142 case UNEQ_EXPR:
7143 case LTGT_EXPR:
7144 case TRUTH_AND_EXPR:
7145 case TRUTH_XOR_EXPR:
7146 case TRUTH_OR_EXPR:
7147 case WIDEN_MULT_EXPR:
7148 case VEC_WIDEN_MULT_HI_EXPR:
7149 case VEC_WIDEN_MULT_LO_EXPR:
7150 case VEC_WIDEN_MULT_EVEN_EXPR:
7151 case VEC_WIDEN_MULT_ODD_EXPR:
7152 return true;
7153
7154 default:
7155 break;
7156 }
7157 return false;
7158 }
7159
7160 /* Return true if CODE represents a ternary tree code for which the
7161 first two operands are commutative. Otherwise return false. */
7162 bool
commutative_ternary_tree_code(enum tree_code code)7163 commutative_ternary_tree_code (enum tree_code code)
7164 {
7165 switch (code)
7166 {
7167 case WIDEN_MULT_PLUS_EXPR:
7168 case WIDEN_MULT_MINUS_EXPR:
7169 case DOT_PROD_EXPR:
7170 case FMA_EXPR:
7171 return true;
7172
7173 default:
7174 break;
7175 }
7176 return false;
7177 }
7178
7179 /* Returns true if CODE can overflow. */
7180
7181 bool
operation_can_overflow(enum tree_code code)7182 operation_can_overflow (enum tree_code code)
7183 {
7184 switch (code)
7185 {
7186 case PLUS_EXPR:
7187 case MINUS_EXPR:
7188 case MULT_EXPR:
7189 case LSHIFT_EXPR:
7190 /* Can overflow in various ways. */
7191 return true;
7192 case TRUNC_DIV_EXPR:
7193 case EXACT_DIV_EXPR:
7194 case FLOOR_DIV_EXPR:
7195 case CEIL_DIV_EXPR:
7196 /* For INT_MIN / -1. */
7197 return true;
7198 case NEGATE_EXPR:
7199 case ABS_EXPR:
7200 /* For -INT_MIN. */
7201 return true;
7202 default:
7203 /* These operators cannot overflow. */
7204 return false;
7205 }
7206 }
7207
7208 /* Returns true if CODE operating on operands of type TYPE doesn't overflow, or
7209 ftrapv doesn't generate trapping insns for CODE. */
7210
7211 bool
operation_no_trapping_overflow(tree type,enum tree_code code)7212 operation_no_trapping_overflow (tree type, enum tree_code code)
7213 {
7214 gcc_checking_assert (ANY_INTEGRAL_TYPE_P (type));
7215
7216 /* We don't generate instructions that trap on overflow for complex or vector
7217 types. */
7218 if (!INTEGRAL_TYPE_P (type))
7219 return true;
7220
7221 if (!TYPE_OVERFLOW_TRAPS (type))
7222 return true;
7223
7224 switch (code)
7225 {
7226 case PLUS_EXPR:
7227 case MINUS_EXPR:
7228 case MULT_EXPR:
7229 case NEGATE_EXPR:
7230 case ABS_EXPR:
7231 /* These operators can overflow, and -ftrapv generates trapping code for
7232 these. */
7233 return false;
7234 case TRUNC_DIV_EXPR:
7235 case EXACT_DIV_EXPR:
7236 case FLOOR_DIV_EXPR:
7237 case CEIL_DIV_EXPR:
7238 case LSHIFT_EXPR:
7239 /* These operators can overflow, but -ftrapv does not generate trapping
7240 code for these. */
7241 return true;
7242 default:
7243 /* These operators cannot overflow. */
7244 return true;
7245 }
7246 }
7247
7248 namespace inchash
7249 {
7250
7251 /* Generate a hash value for an expression. This can be used iteratively
7252 by passing a previous result as the HSTATE argument.
7253
7254 This function is intended to produce the same hash for expressions which
7255 would compare equal using operand_equal_p. */
7256 void
add_expr(const_tree t,inchash::hash & hstate,unsigned int flags)7257 add_expr (const_tree t, inchash::hash &hstate, unsigned int flags)
7258 {
7259 int i;
7260 enum tree_code code;
7261 enum tree_code_class tclass;
7262
7263 if (t == NULL_TREE || t == error_mark_node)
7264 {
7265 hstate.merge_hash (0);
7266 return;
7267 }
7268
7269 if (!(flags & OEP_ADDRESS_OF))
7270 STRIP_NOPS (t);
7271
7272 code = TREE_CODE (t);
7273
7274 switch (code)
7275 {
7276 /* Alas, constants aren't shared, so we can't rely on pointer
7277 identity. */
7278 case VOID_CST:
7279 hstate.merge_hash (0);
7280 return;
7281 case INTEGER_CST:
7282 gcc_checking_assert (!(flags & OEP_ADDRESS_OF));
7283 for (i = 0; i < TREE_INT_CST_EXT_NUNITS (t); i++)
7284 hstate.add_hwi (TREE_INT_CST_ELT (t, i));
7285 return;
7286 case REAL_CST:
7287 {
7288 unsigned int val2;
7289 if (!HONOR_SIGNED_ZEROS (t) && real_zerop (t))
7290 val2 = rvc_zero;
7291 else
7292 val2 = real_hash (TREE_REAL_CST_PTR (t));
7293 hstate.merge_hash (val2);
7294 return;
7295 }
7296 case FIXED_CST:
7297 {
7298 unsigned int val2 = fixed_hash (TREE_FIXED_CST_PTR (t));
7299 hstate.merge_hash (val2);
7300 return;
7301 }
7302 case STRING_CST:
7303 hstate.add ((const void *) TREE_STRING_POINTER (t),
7304 TREE_STRING_LENGTH (t));
7305 return;
7306 case COMPLEX_CST:
7307 inchash::add_expr (TREE_REALPART (t), hstate, flags);
7308 inchash::add_expr (TREE_IMAGPART (t), hstate, flags);
7309 return;
7310 case VECTOR_CST:
7311 {
7312 hstate.add_int (VECTOR_CST_NPATTERNS (t));
7313 hstate.add_int (VECTOR_CST_NELTS_PER_PATTERN (t));
7314 unsigned int count = vector_cst_encoded_nelts (t);
7315 for (unsigned int i = 0; i < count; ++i)
7316 inchash::add_expr (VECTOR_CST_ENCODED_ELT (t, i), hstate, flags);
7317 return;
7318 }
7319 case SSA_NAME:
7320 /* We can just compare by pointer. */
7321 hstate.add_hwi (SSA_NAME_VERSION (t));
7322 return;
7323 case PLACEHOLDER_EXPR:
7324 /* The node itself doesn't matter. */
7325 return;
7326 case BLOCK:
7327 case OMP_CLAUSE:
7328 /* Ignore. */
7329 return;
7330 case TREE_LIST:
7331 /* A list of expressions, for a CALL_EXPR or as the elements of a
7332 VECTOR_CST. */
7333 for (; t; t = TREE_CHAIN (t))
7334 inchash::add_expr (TREE_VALUE (t), hstate, flags);
7335 return;
7336 case CONSTRUCTOR:
7337 {
7338 unsigned HOST_WIDE_INT idx;
7339 tree field, value;
7340 flags &= ~OEP_ADDRESS_OF;
7341 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t), idx, field, value)
7342 {
7343 inchash::add_expr (field, hstate, flags);
7344 inchash::add_expr (value, hstate, flags);
7345 }
7346 return;
7347 }
7348 case STATEMENT_LIST:
7349 {
7350 tree_stmt_iterator i;
7351 for (i = tsi_start (CONST_CAST_TREE (t));
7352 !tsi_end_p (i); tsi_next (&i))
7353 inchash::add_expr (tsi_stmt (i), hstate, flags);
7354 return;
7355 }
7356 case TREE_VEC:
7357 for (i = 0; i < TREE_VEC_LENGTH (t); ++i)
7358 inchash::add_expr (TREE_VEC_ELT (t, i), hstate, flags);
7359 return;
7360 case IDENTIFIER_NODE:
7361 hstate.add_object (IDENTIFIER_HASH_VALUE (t));
7362 return;
7363 case FUNCTION_DECL:
7364 /* When referring to a built-in FUNCTION_DECL, use the __builtin__ form.
7365 Otherwise nodes that compare equal according to operand_equal_p might
7366 get different hash codes. However, don't do this for machine specific
7367 or front end builtins, since the function code is overloaded in those
7368 cases. */
7369 if (DECL_BUILT_IN_CLASS (t) == BUILT_IN_NORMAL
7370 && builtin_decl_explicit_p (DECL_FUNCTION_CODE (t)))
7371 {
7372 t = builtin_decl_explicit (DECL_FUNCTION_CODE (t));
7373 code = TREE_CODE (t);
7374 }
7375 /* FALL THROUGH */
7376 default:
7377 if (POLY_INT_CST_P (t))
7378 {
7379 for (unsigned int i = 0; i < NUM_POLY_INT_COEFFS; ++i)
7380 hstate.add_wide_int (wi::to_wide (POLY_INT_CST_COEFF (t, i)));
7381 return;
7382 }
7383 tclass = TREE_CODE_CLASS (code);
7384
7385 if (tclass == tcc_declaration)
7386 {
7387 /* DECL's have a unique ID */
7388 hstate.add_hwi (DECL_UID (t));
7389 }
7390 else if (tclass == tcc_comparison && !commutative_tree_code (code))
7391 {
7392 /* For comparisons that can be swapped, use the lower
7393 tree code. */
7394 enum tree_code ccode = swap_tree_comparison (code);
7395 if (code < ccode)
7396 ccode = code;
7397 hstate.add_object (ccode);
7398 inchash::add_expr (TREE_OPERAND (t, ccode != code), hstate, flags);
7399 inchash::add_expr (TREE_OPERAND (t, ccode == code), hstate, flags);
7400 }
7401 else if (CONVERT_EXPR_CODE_P (code))
7402 {
7403 /* NOP_EXPR and CONVERT_EXPR are considered equal by
7404 operand_equal_p. */
7405 enum tree_code ccode = NOP_EXPR;
7406 hstate.add_object (ccode);
7407
7408 /* Don't hash the type, that can lead to having nodes which
7409 compare equal according to operand_equal_p, but which
7410 have different hash codes. Make sure to include signedness
7411 in the hash computation. */
7412 hstate.add_int (TYPE_UNSIGNED (TREE_TYPE (t)));
7413 inchash::add_expr (TREE_OPERAND (t, 0), hstate, flags);
7414 }
7415 /* For OEP_ADDRESS_OF, hash MEM_EXPR[&decl, 0] the same as decl. */
7416 else if (code == MEM_REF
7417 && (flags & OEP_ADDRESS_OF) != 0
7418 && TREE_CODE (TREE_OPERAND (t, 0)) == ADDR_EXPR
7419 && DECL_P (TREE_OPERAND (TREE_OPERAND (t, 0), 0))
7420 && integer_zerop (TREE_OPERAND (t, 1)))
7421 inchash::add_expr (TREE_OPERAND (TREE_OPERAND (t, 0), 0),
7422 hstate, flags);
7423 /* Don't ICE on FE specific trees, or their arguments etc.
7424 during operand_equal_p hash verification. */
7425 else if (!IS_EXPR_CODE_CLASS (tclass))
7426 gcc_assert (flags & OEP_HASH_CHECK);
7427 else
7428 {
7429 unsigned int sflags = flags;
7430
7431 hstate.add_object (code);
7432
7433 switch (code)
7434 {
7435 case ADDR_EXPR:
7436 gcc_checking_assert (!(flags & OEP_ADDRESS_OF));
7437 flags |= OEP_ADDRESS_OF;
7438 sflags = flags;
7439 break;
7440
7441 case INDIRECT_REF:
7442 case MEM_REF:
7443 case TARGET_MEM_REF:
7444 flags &= ~OEP_ADDRESS_OF;
7445 sflags = flags;
7446 break;
7447
7448 case ARRAY_REF:
7449 case ARRAY_RANGE_REF:
7450 case COMPONENT_REF:
7451 case BIT_FIELD_REF:
7452 sflags &= ~OEP_ADDRESS_OF;
7453 break;
7454
7455 case COND_EXPR:
7456 flags &= ~OEP_ADDRESS_OF;
7457 break;
7458
7459 case FMA_EXPR:
7460 case WIDEN_MULT_PLUS_EXPR:
7461 case WIDEN_MULT_MINUS_EXPR:
7462 {
7463 /* The multiplication operands are commutative. */
7464 inchash::hash one, two;
7465 inchash::add_expr (TREE_OPERAND (t, 0), one, flags);
7466 inchash::add_expr (TREE_OPERAND (t, 1), two, flags);
7467 hstate.add_commutative (one, two);
7468 inchash::add_expr (TREE_OPERAND (t, 2), two, flags);
7469 return;
7470 }
7471
7472 case CALL_EXPR:
7473 if (CALL_EXPR_FN (t) == NULL_TREE)
7474 hstate.add_int (CALL_EXPR_IFN (t));
7475 break;
7476
7477 case TARGET_EXPR:
7478 /* For TARGET_EXPR, just hash on the TARGET_EXPR_SLOT.
7479 Usually different TARGET_EXPRs just should use
7480 different temporaries in their slots. */
7481 inchash::add_expr (TARGET_EXPR_SLOT (t), hstate, flags);
7482 return;
7483
7484 default:
7485 break;
7486 }
7487
7488 /* Don't hash the type, that can lead to having nodes which
7489 compare equal according to operand_equal_p, but which
7490 have different hash codes. */
7491 if (code == NON_LVALUE_EXPR)
7492 {
7493 /* Make sure to include signness in the hash computation. */
7494 hstate.add_int (TYPE_UNSIGNED (TREE_TYPE (t)));
7495 inchash::add_expr (TREE_OPERAND (t, 0), hstate, flags);
7496 }
7497
7498 else if (commutative_tree_code (code))
7499 {
7500 /* It's a commutative expression. We want to hash it the same
7501 however it appears. We do this by first hashing both operands
7502 and then rehashing based on the order of their independent
7503 hashes. */
7504 inchash::hash one, two;
7505 inchash::add_expr (TREE_OPERAND (t, 0), one, flags);
7506 inchash::add_expr (TREE_OPERAND (t, 1), two, flags);
7507 hstate.add_commutative (one, two);
7508 }
7509 else
7510 for (i = TREE_OPERAND_LENGTH (t) - 1; i >= 0; --i)
7511 inchash::add_expr (TREE_OPERAND (t, i), hstate,
7512 i == 0 ? flags : sflags);
7513 }
7514 return;
7515 }
7516 }
7517
7518 }
7519
7520 /* Constructors for pointer, array and function types.
7521 (RECORD_TYPE, UNION_TYPE and ENUMERAL_TYPE nodes are
7522 constructed by language-dependent code, not here.) */
7523
7524 /* Construct, lay out and return the type of pointers to TO_TYPE with
7525 mode MODE. If CAN_ALIAS_ALL is TRUE, indicate this type can
7526 reference all of memory. If such a type has already been
7527 constructed, reuse it. */
7528
7529 tree
build_pointer_type_for_mode(tree to_type,machine_mode mode,bool can_alias_all)7530 build_pointer_type_for_mode (tree to_type, machine_mode mode,
7531 bool can_alias_all)
7532 {
7533 tree t;
7534 bool could_alias = can_alias_all;
7535
7536 if (to_type == error_mark_node)
7537 return error_mark_node;
7538
7539 /* If the pointed-to type has the may_alias attribute set, force
7540 a TYPE_REF_CAN_ALIAS_ALL pointer to be generated. */
7541 if (lookup_attribute ("may_alias", TYPE_ATTRIBUTES (to_type)))
7542 can_alias_all = true;
7543
7544 /* In some cases, languages will have things that aren't a POINTER_TYPE
7545 (such as a RECORD_TYPE for fat pointers in Ada) as TYPE_POINTER_TO.
7546 In that case, return that type without regard to the rest of our
7547 operands.
7548
7549 ??? This is a kludge, but consistent with the way this function has
7550 always operated and there doesn't seem to be a good way to avoid this
7551 at the moment. */
7552 if (TYPE_POINTER_TO (to_type) != 0
7553 && TREE_CODE (TYPE_POINTER_TO (to_type)) != POINTER_TYPE)
7554 return TYPE_POINTER_TO (to_type);
7555
7556 /* First, if we already have a type for pointers to TO_TYPE and it's
7557 the proper mode, use it. */
7558 for (t = TYPE_POINTER_TO (to_type); t; t = TYPE_NEXT_PTR_TO (t))
7559 if (TYPE_MODE (t) == mode && TYPE_REF_CAN_ALIAS_ALL (t) == can_alias_all)
7560 return t;
7561
7562 t = make_node (POINTER_TYPE);
7563
7564 TREE_TYPE (t) = to_type;
7565 SET_TYPE_MODE (t, mode);
7566 TYPE_REF_CAN_ALIAS_ALL (t) = can_alias_all;
7567 TYPE_NEXT_PTR_TO (t) = TYPE_POINTER_TO (to_type);
7568 TYPE_POINTER_TO (to_type) = t;
7569
7570 /* During LTO we do not set TYPE_CANONICAL of pointers and references. */
7571 if (TYPE_STRUCTURAL_EQUALITY_P (to_type) || in_lto_p)
7572 SET_TYPE_STRUCTURAL_EQUALITY (t);
7573 else if (TYPE_CANONICAL (to_type) != to_type || could_alias)
7574 TYPE_CANONICAL (t)
7575 = build_pointer_type_for_mode (TYPE_CANONICAL (to_type),
7576 mode, false);
7577
7578 /* Lay out the type. This function has many callers that are concerned
7579 with expression-construction, and this simplifies them all. */
7580 layout_type (t);
7581
7582 return t;
7583 }
7584
7585 /* By default build pointers in ptr_mode. */
7586
7587 tree
build_pointer_type(tree to_type)7588 build_pointer_type (tree to_type)
7589 {
7590 addr_space_t as = to_type == error_mark_node? ADDR_SPACE_GENERIC
7591 : TYPE_ADDR_SPACE (to_type);
7592 machine_mode pointer_mode = targetm.addr_space.pointer_mode (as);
7593 return build_pointer_type_for_mode (to_type, pointer_mode, false);
7594 }
7595
7596 /* Same as build_pointer_type_for_mode, but for REFERENCE_TYPE. */
7597
7598 tree
build_reference_type_for_mode(tree to_type,machine_mode mode,bool can_alias_all)7599 build_reference_type_for_mode (tree to_type, machine_mode mode,
7600 bool can_alias_all)
7601 {
7602 tree t;
7603 bool could_alias = can_alias_all;
7604
7605 if (to_type == error_mark_node)
7606 return error_mark_node;
7607
7608 /* If the pointed-to type has the may_alias attribute set, force
7609 a TYPE_REF_CAN_ALIAS_ALL pointer to be generated. */
7610 if (lookup_attribute ("may_alias", TYPE_ATTRIBUTES (to_type)))
7611 can_alias_all = true;
7612
7613 /* In some cases, languages will have things that aren't a REFERENCE_TYPE
7614 (such as a RECORD_TYPE for fat pointers in Ada) as TYPE_REFERENCE_TO.
7615 In that case, return that type without regard to the rest of our
7616 operands.
7617
7618 ??? This is a kludge, but consistent with the way this function has
7619 always operated and there doesn't seem to be a good way to avoid this
7620 at the moment. */
7621 if (TYPE_REFERENCE_TO (to_type) != 0
7622 && TREE_CODE (TYPE_REFERENCE_TO (to_type)) != REFERENCE_TYPE)
7623 return TYPE_REFERENCE_TO (to_type);
7624
7625 /* First, if we already have a type for pointers to TO_TYPE and it's
7626 the proper mode, use it. */
7627 for (t = TYPE_REFERENCE_TO (to_type); t; t = TYPE_NEXT_REF_TO (t))
7628 if (TYPE_MODE (t) == mode && TYPE_REF_CAN_ALIAS_ALL (t) == can_alias_all)
7629 return t;
7630
7631 t = make_node (REFERENCE_TYPE);
7632
7633 TREE_TYPE (t) = to_type;
7634 SET_TYPE_MODE (t, mode);
7635 TYPE_REF_CAN_ALIAS_ALL (t) = can_alias_all;
7636 TYPE_NEXT_REF_TO (t) = TYPE_REFERENCE_TO (to_type);
7637 TYPE_REFERENCE_TO (to_type) = t;
7638
7639 /* During LTO we do not set TYPE_CANONICAL of pointers and references. */
7640 if (TYPE_STRUCTURAL_EQUALITY_P (to_type) || in_lto_p)
7641 SET_TYPE_STRUCTURAL_EQUALITY (t);
7642 else if (TYPE_CANONICAL (to_type) != to_type || could_alias)
7643 TYPE_CANONICAL (t)
7644 = build_reference_type_for_mode (TYPE_CANONICAL (to_type),
7645 mode, false);
7646
7647 layout_type (t);
7648
7649 return t;
7650 }
7651
7652
7653 /* Build the node for the type of references-to-TO_TYPE by default
7654 in ptr_mode. */
7655
7656 tree
build_reference_type(tree to_type)7657 build_reference_type (tree to_type)
7658 {
7659 addr_space_t as = to_type == error_mark_node? ADDR_SPACE_GENERIC
7660 : TYPE_ADDR_SPACE (to_type);
7661 machine_mode pointer_mode = targetm.addr_space.pointer_mode (as);
7662 return build_reference_type_for_mode (to_type, pointer_mode, false);
7663 }
7664
7665 #define MAX_INT_CACHED_PREC \
7666 (HOST_BITS_PER_WIDE_INT > 64 ? HOST_BITS_PER_WIDE_INT : 64)
7667 static GTY(()) tree nonstandard_integer_type_cache[2 * MAX_INT_CACHED_PREC + 2];
7668
7669 /* Builds a signed or unsigned integer type of precision PRECISION.
7670 Used for C bitfields whose precision does not match that of
7671 built-in target types. */
7672 tree
build_nonstandard_integer_type(unsigned HOST_WIDE_INT precision,int unsignedp)7673 build_nonstandard_integer_type (unsigned HOST_WIDE_INT precision,
7674 int unsignedp)
7675 {
7676 tree itype, ret;
7677
7678 if (unsignedp)
7679 unsignedp = MAX_INT_CACHED_PREC + 1;
7680
7681 if (precision <= MAX_INT_CACHED_PREC)
7682 {
7683 itype = nonstandard_integer_type_cache[precision + unsignedp];
7684 if (itype)
7685 return itype;
7686 }
7687
7688 itype = make_node (INTEGER_TYPE);
7689 TYPE_PRECISION (itype) = precision;
7690
7691 if (unsignedp)
7692 fixup_unsigned_type (itype);
7693 else
7694 fixup_signed_type (itype);
7695
7696 ret = itype;
7697
7698 inchash::hash hstate;
7699 inchash::add_expr (TYPE_MAX_VALUE (itype), hstate);
7700 ret = type_hash_canon (hstate.end (), itype);
7701 if (precision <= MAX_INT_CACHED_PREC)
7702 nonstandard_integer_type_cache[precision + unsignedp] = ret;
7703
7704 return ret;
7705 }
7706
7707 #define MAX_BOOL_CACHED_PREC \
7708 (HOST_BITS_PER_WIDE_INT > 64 ? HOST_BITS_PER_WIDE_INT : 64)
7709 static GTY(()) tree nonstandard_boolean_type_cache[MAX_BOOL_CACHED_PREC + 1];
7710
7711 /* Builds a boolean type of precision PRECISION.
7712 Used for boolean vectors to choose proper vector element size. */
7713 tree
build_nonstandard_boolean_type(unsigned HOST_WIDE_INT precision)7714 build_nonstandard_boolean_type (unsigned HOST_WIDE_INT precision)
7715 {
7716 tree type;
7717
7718 if (precision <= MAX_BOOL_CACHED_PREC)
7719 {
7720 type = nonstandard_boolean_type_cache[precision];
7721 if (type)
7722 return type;
7723 }
7724
7725 type = make_node (BOOLEAN_TYPE);
7726 TYPE_PRECISION (type) = precision;
7727 fixup_signed_type (type);
7728
7729 if (precision <= MAX_INT_CACHED_PREC)
7730 nonstandard_boolean_type_cache[precision] = type;
7731
7732 return type;
7733 }
7734
7735 /* Create a range of some discrete type TYPE (an INTEGER_TYPE, ENUMERAL_TYPE
7736 or BOOLEAN_TYPE) with low bound LOWVAL and high bound HIGHVAL. If SHARED
7737 is true, reuse such a type that has already been constructed. */
7738
7739 static tree
build_range_type_1(tree type,tree lowval,tree highval,bool shared)7740 build_range_type_1 (tree type, tree lowval, tree highval, bool shared)
7741 {
7742 tree itype = make_node (INTEGER_TYPE);
7743
7744 TREE_TYPE (itype) = type;
7745
7746 TYPE_MIN_VALUE (itype) = fold_convert (type, lowval);
7747 TYPE_MAX_VALUE (itype) = highval ? fold_convert (type, highval) : NULL;
7748
7749 TYPE_PRECISION (itype) = TYPE_PRECISION (type);
7750 SET_TYPE_MODE (itype, TYPE_MODE (type));
7751 TYPE_SIZE (itype) = TYPE_SIZE (type);
7752 TYPE_SIZE_UNIT (itype) = TYPE_SIZE_UNIT (type);
7753 SET_TYPE_ALIGN (itype, TYPE_ALIGN (type));
7754 TYPE_USER_ALIGN (itype) = TYPE_USER_ALIGN (type);
7755 SET_TYPE_WARN_IF_NOT_ALIGN (itype, TYPE_WARN_IF_NOT_ALIGN (type));
7756
7757 if (!shared)
7758 return itype;
7759
7760 if ((TYPE_MIN_VALUE (itype)
7761 && TREE_CODE (TYPE_MIN_VALUE (itype)) != INTEGER_CST)
7762 || (TYPE_MAX_VALUE (itype)
7763 && TREE_CODE (TYPE_MAX_VALUE (itype)) != INTEGER_CST))
7764 {
7765 /* Since we cannot reliably merge this type, we need to compare it using
7766 structural equality checks. */
7767 SET_TYPE_STRUCTURAL_EQUALITY (itype);
7768 return itype;
7769 }
7770
7771 hashval_t hash = type_hash_canon_hash (itype);
7772 itype = type_hash_canon (hash, itype);
7773
7774 return itype;
7775 }
7776
7777 /* Wrapper around build_range_type_1 with SHARED set to true. */
7778
7779 tree
build_range_type(tree type,tree lowval,tree highval)7780 build_range_type (tree type, tree lowval, tree highval)
7781 {
7782 return build_range_type_1 (type, lowval, highval, true);
7783 }
7784
7785 /* Wrapper around build_range_type_1 with SHARED set to false. */
7786
7787 tree
build_nonshared_range_type(tree type,tree lowval,tree highval)7788 build_nonshared_range_type (tree type, tree lowval, tree highval)
7789 {
7790 return build_range_type_1 (type, lowval, highval, false);
7791 }
7792
7793 /* Create a type of integers to be the TYPE_DOMAIN of an ARRAY_TYPE.
7794 MAXVAL should be the maximum value in the domain
7795 (one less than the length of the array).
7796
7797 The maximum value that MAXVAL can have is INT_MAX for a HOST_WIDE_INT.
7798 We don't enforce this limit, that is up to caller (e.g. language front end).
7799 The limit exists because the result is a signed type and we don't handle
7800 sizes that use more than one HOST_WIDE_INT. */
7801
7802 tree
build_index_type(tree maxval)7803 build_index_type (tree maxval)
7804 {
7805 return build_range_type (sizetype, size_zero_node, maxval);
7806 }
7807
7808 /* Return true if the debug information for TYPE, a subtype, should be emitted
7809 as a subrange type. If so, set LOWVAL to the low bound and HIGHVAL to the
7810 high bound, respectively. Sometimes doing so unnecessarily obfuscates the
7811 debug info and doesn't reflect the source code. */
7812
7813 bool
subrange_type_for_debug_p(const_tree type,tree * lowval,tree * highval)7814 subrange_type_for_debug_p (const_tree type, tree *lowval, tree *highval)
7815 {
7816 tree base_type = TREE_TYPE (type), low, high;
7817
7818 /* Subrange types have a base type which is an integral type. */
7819 if (!INTEGRAL_TYPE_P (base_type))
7820 return false;
7821
7822 /* Get the real bounds of the subtype. */
7823 if (lang_hooks.types.get_subrange_bounds)
7824 lang_hooks.types.get_subrange_bounds (type, &low, &high);
7825 else
7826 {
7827 low = TYPE_MIN_VALUE (type);
7828 high = TYPE_MAX_VALUE (type);
7829 }
7830
7831 /* If the type and its base type have the same representation and the same
7832 name, then the type is not a subrange but a copy of the base type. */
7833 if ((TREE_CODE (base_type) == INTEGER_TYPE
7834 || TREE_CODE (base_type) == BOOLEAN_TYPE)
7835 && int_size_in_bytes (type) == int_size_in_bytes (base_type)
7836 && tree_int_cst_equal (low, TYPE_MIN_VALUE (base_type))
7837 && tree_int_cst_equal (high, TYPE_MAX_VALUE (base_type))
7838 && TYPE_IDENTIFIER (type) == TYPE_IDENTIFIER (base_type))
7839 return false;
7840
7841 if (lowval)
7842 *lowval = low;
7843 if (highval)
7844 *highval = high;
7845 return true;
7846 }
7847
7848 /* Construct, lay out and return the type of arrays of elements with ELT_TYPE
7849 and number of elements specified by the range of values of INDEX_TYPE.
7850 If TYPELESS_STORAGE is true, TYPE_TYPELESS_STORAGE flag is set on the type.
7851 If SHARED is true, reuse such a type that has already been constructed. */
7852
7853 static tree
build_array_type_1(tree elt_type,tree index_type,bool typeless_storage,bool shared)7854 build_array_type_1 (tree elt_type, tree index_type, bool typeless_storage,
7855 bool shared)
7856 {
7857 tree t;
7858
7859 if (TREE_CODE (elt_type) == FUNCTION_TYPE)
7860 {
7861 error ("arrays of functions are not meaningful");
7862 elt_type = integer_type_node;
7863 }
7864
7865 t = make_node (ARRAY_TYPE);
7866 TREE_TYPE (t) = elt_type;
7867 TYPE_DOMAIN (t) = index_type;
7868 TYPE_ADDR_SPACE (t) = TYPE_ADDR_SPACE (elt_type);
7869 TYPE_TYPELESS_STORAGE (t) = typeless_storage;
7870 layout_type (t);
7871
7872 /* If the element type is incomplete at this point we get marked for
7873 structural equality. Do not record these types in the canonical
7874 type hashtable. */
7875 if (TYPE_STRUCTURAL_EQUALITY_P (t))
7876 return t;
7877
7878 if (shared)
7879 {
7880 hashval_t hash = type_hash_canon_hash (t);
7881 t = type_hash_canon (hash, t);
7882 }
7883
7884 if (TYPE_CANONICAL (t) == t)
7885 {
7886 if (TYPE_STRUCTURAL_EQUALITY_P (elt_type)
7887 || (index_type && TYPE_STRUCTURAL_EQUALITY_P (index_type))
7888 || in_lto_p)
7889 SET_TYPE_STRUCTURAL_EQUALITY (t);
7890 else if (TYPE_CANONICAL (elt_type) != elt_type
7891 || (index_type && TYPE_CANONICAL (index_type) != index_type))
7892 TYPE_CANONICAL (t)
7893 = build_array_type_1 (TYPE_CANONICAL (elt_type),
7894 index_type
7895 ? TYPE_CANONICAL (index_type) : NULL_TREE,
7896 typeless_storage, shared);
7897 }
7898
7899 return t;
7900 }
7901
7902 /* Wrapper around build_array_type_1 with SHARED set to true. */
7903
7904 tree
build_array_type(tree elt_type,tree index_type,bool typeless_storage)7905 build_array_type (tree elt_type, tree index_type, bool typeless_storage)
7906 {
7907 return build_array_type_1 (elt_type, index_type, typeless_storage, true);
7908 }
7909
7910 /* Wrapper around build_array_type_1 with SHARED set to false. */
7911
7912 tree
build_nonshared_array_type(tree elt_type,tree index_type)7913 build_nonshared_array_type (tree elt_type, tree index_type)
7914 {
7915 return build_array_type_1 (elt_type, index_type, false, false);
7916 }
7917
7918 /* Return a representation of ELT_TYPE[NELTS], using indices of type
7919 sizetype. */
7920
7921 tree
build_array_type_nelts(tree elt_type,poly_uint64 nelts)7922 build_array_type_nelts (tree elt_type, poly_uint64 nelts)
7923 {
7924 return build_array_type (elt_type, build_index_type (size_int (nelts - 1)));
7925 }
7926
7927 /* Recursively examines the array elements of TYPE, until a non-array
7928 element type is found. */
7929
7930 tree
strip_array_types(tree type)7931 strip_array_types (tree type)
7932 {
7933 while (TREE_CODE (type) == ARRAY_TYPE)
7934 type = TREE_TYPE (type);
7935
7936 return type;
7937 }
7938
7939 /* Computes the canonical argument types from the argument type list
7940 ARGTYPES.
7941
7942 Upon return, *ANY_STRUCTURAL_P will be true iff either it was true
7943 on entry to this function, or if any of the ARGTYPES are
7944 structural.
7945
7946 Upon return, *ANY_NONCANONICAL_P will be true iff either it was
7947 true on entry to this function, or if any of the ARGTYPES are
7948 non-canonical.
7949
7950 Returns a canonical argument list, which may be ARGTYPES when the
7951 canonical argument list is unneeded (i.e., *ANY_STRUCTURAL_P is
7952 true) or would not differ from ARGTYPES. */
7953
7954 static tree
maybe_canonicalize_argtypes(tree argtypes,bool * any_structural_p,bool * any_noncanonical_p)7955 maybe_canonicalize_argtypes (tree argtypes,
7956 bool *any_structural_p,
7957 bool *any_noncanonical_p)
7958 {
7959 tree arg;
7960 bool any_noncanonical_argtypes_p = false;
7961
7962 for (arg = argtypes; arg && !(*any_structural_p); arg = TREE_CHAIN (arg))
7963 {
7964 if (!TREE_VALUE (arg) || TREE_VALUE (arg) == error_mark_node)
7965 /* Fail gracefully by stating that the type is structural. */
7966 *any_structural_p = true;
7967 else if (TYPE_STRUCTURAL_EQUALITY_P (TREE_VALUE (arg)))
7968 *any_structural_p = true;
7969 else if (TYPE_CANONICAL (TREE_VALUE (arg)) != TREE_VALUE (arg)
7970 || TREE_PURPOSE (arg))
7971 /* If the argument has a default argument, we consider it
7972 non-canonical even though the type itself is canonical.
7973 That way, different variants of function and method types
7974 with default arguments will all point to the variant with
7975 no defaults as their canonical type. */
7976 any_noncanonical_argtypes_p = true;
7977 }
7978
7979 if (*any_structural_p)
7980 return argtypes;
7981
7982 if (any_noncanonical_argtypes_p)
7983 {
7984 /* Build the canonical list of argument types. */
7985 tree canon_argtypes = NULL_TREE;
7986 bool is_void = false;
7987
7988 for (arg = argtypes; arg; arg = TREE_CHAIN (arg))
7989 {
7990 if (arg == void_list_node)
7991 is_void = true;
7992 else
7993 canon_argtypes = tree_cons (NULL_TREE,
7994 TYPE_CANONICAL (TREE_VALUE (arg)),
7995 canon_argtypes);
7996 }
7997
7998 canon_argtypes = nreverse (canon_argtypes);
7999 if (is_void)
8000 canon_argtypes = chainon (canon_argtypes, void_list_node);
8001
8002 /* There is a non-canonical type. */
8003 *any_noncanonical_p = true;
8004 return canon_argtypes;
8005 }
8006
8007 /* The canonical argument types are the same as ARGTYPES. */
8008 return argtypes;
8009 }
8010
8011 /* Construct, lay out and return
8012 the type of functions returning type VALUE_TYPE
8013 given arguments of types ARG_TYPES.
8014 ARG_TYPES is a chain of TREE_LIST nodes whose TREE_VALUEs
8015 are data type nodes for the arguments of the function.
8016 If such a type has already been constructed, reuse it. */
8017
8018 tree
build_function_type(tree value_type,tree arg_types)8019 build_function_type (tree value_type, tree arg_types)
8020 {
8021 tree t;
8022 inchash::hash hstate;
8023 bool any_structural_p, any_noncanonical_p;
8024 tree canon_argtypes;
8025
8026 gcc_assert (arg_types != error_mark_node);
8027
8028 if (TREE_CODE (value_type) == FUNCTION_TYPE)
8029 {
8030 error ("function return type cannot be function");
8031 value_type = integer_type_node;
8032 }
8033
8034 /* Make a node of the sort we want. */
8035 t = make_node (FUNCTION_TYPE);
8036 TREE_TYPE (t) = value_type;
8037 TYPE_ARG_TYPES (t) = arg_types;
8038
8039 /* If we already have such a type, use the old one. */
8040 hashval_t hash = type_hash_canon_hash (t);
8041 t = type_hash_canon (hash, t);
8042
8043 /* Set up the canonical type. */
8044 any_structural_p = TYPE_STRUCTURAL_EQUALITY_P (value_type);
8045 any_noncanonical_p = TYPE_CANONICAL (value_type) != value_type;
8046 canon_argtypes = maybe_canonicalize_argtypes (arg_types,
8047 &any_structural_p,
8048 &any_noncanonical_p);
8049 if (any_structural_p)
8050 SET_TYPE_STRUCTURAL_EQUALITY (t);
8051 else if (any_noncanonical_p)
8052 TYPE_CANONICAL (t) = build_function_type (TYPE_CANONICAL (value_type),
8053 canon_argtypes);
8054
8055 if (!COMPLETE_TYPE_P (t))
8056 layout_type (t);
8057 return t;
8058 }
8059
8060 /* Build a function type. The RETURN_TYPE is the type returned by the
8061 function. If VAARGS is set, no void_type_node is appended to the
8062 list. ARGP must be always be terminated be a NULL_TREE. */
8063
8064 static tree
build_function_type_list_1(bool vaargs,tree return_type,va_list argp)8065 build_function_type_list_1 (bool vaargs, tree return_type, va_list argp)
8066 {
8067 tree t, args, last;
8068
8069 t = va_arg (argp, tree);
8070 for (args = NULL_TREE; t != NULL_TREE; t = va_arg (argp, tree))
8071 args = tree_cons (NULL_TREE, t, args);
8072
8073 if (vaargs)
8074 {
8075 last = args;
8076 if (args != NULL_TREE)
8077 args = nreverse (args);
8078 gcc_assert (last != void_list_node);
8079 }
8080 else if (args == NULL_TREE)
8081 args = void_list_node;
8082 else
8083 {
8084 last = args;
8085 args = nreverse (args);
8086 TREE_CHAIN (last) = void_list_node;
8087 }
8088 args = build_function_type (return_type, args);
8089
8090 return args;
8091 }
8092
8093 /* Build a function type. The RETURN_TYPE is the type returned by the
8094 function. If additional arguments are provided, they are
8095 additional argument types. The list of argument types must always
8096 be terminated by NULL_TREE. */
8097
8098 tree
build_function_type_list(tree return_type,...)8099 build_function_type_list (tree return_type, ...)
8100 {
8101 tree args;
8102 va_list p;
8103
8104 va_start (p, return_type);
8105 args = build_function_type_list_1 (false, return_type, p);
8106 va_end (p);
8107 return args;
8108 }
8109
8110 /* Build a variable argument function type. The RETURN_TYPE is the
8111 type returned by the function. If additional arguments are provided,
8112 they are additional argument types. The list of argument types must
8113 always be terminated by NULL_TREE. */
8114
8115 tree
build_varargs_function_type_list(tree return_type,...)8116 build_varargs_function_type_list (tree return_type, ...)
8117 {
8118 tree args;
8119 va_list p;
8120
8121 va_start (p, return_type);
8122 args = build_function_type_list_1 (true, return_type, p);
8123 va_end (p);
8124
8125 return args;
8126 }
8127
8128 /* Build a function type. RETURN_TYPE is the type returned by the
8129 function; VAARGS indicates whether the function takes varargs. The
8130 function takes N named arguments, the types of which are provided in
8131 ARG_TYPES. */
8132
8133 static tree
build_function_type_array_1(bool vaargs,tree return_type,int n,tree * arg_types)8134 build_function_type_array_1 (bool vaargs, tree return_type, int n,
8135 tree *arg_types)
8136 {
8137 int i;
8138 tree t = vaargs ? NULL_TREE : void_list_node;
8139
8140 for (i = n - 1; i >= 0; i--)
8141 t = tree_cons (NULL_TREE, arg_types[i], t);
8142
8143 return build_function_type (return_type, t);
8144 }
8145
8146 /* Build a function type. RETURN_TYPE is the type returned by the
8147 function. The function takes N named arguments, the types of which
8148 are provided in ARG_TYPES. */
8149
8150 tree
build_function_type_array(tree return_type,int n,tree * arg_types)8151 build_function_type_array (tree return_type, int n, tree *arg_types)
8152 {
8153 return build_function_type_array_1 (false, return_type, n, arg_types);
8154 }
8155
8156 /* Build a variable argument function type. RETURN_TYPE is the type
8157 returned by the function. The function takes N named arguments, the
8158 types of which are provided in ARG_TYPES. */
8159
8160 tree
build_varargs_function_type_array(tree return_type,int n,tree * arg_types)8161 build_varargs_function_type_array (tree return_type, int n, tree *arg_types)
8162 {
8163 return build_function_type_array_1 (true, return_type, n, arg_types);
8164 }
8165
8166 /* Build a METHOD_TYPE for a member of BASETYPE. The RETTYPE (a TYPE)
8167 and ARGTYPES (a TREE_LIST) are the return type and arguments types
8168 for the method. An implicit additional parameter (of type
8169 pointer-to-BASETYPE) is added to the ARGTYPES. */
8170
8171 tree
build_method_type_directly(tree basetype,tree rettype,tree argtypes)8172 build_method_type_directly (tree basetype,
8173 tree rettype,
8174 tree argtypes)
8175 {
8176 tree t;
8177 tree ptype;
8178 bool any_structural_p, any_noncanonical_p;
8179 tree canon_argtypes;
8180
8181 /* Make a node of the sort we want. */
8182 t = make_node (METHOD_TYPE);
8183
8184 TYPE_METHOD_BASETYPE (t) = TYPE_MAIN_VARIANT (basetype);
8185 TREE_TYPE (t) = rettype;
8186 ptype = build_pointer_type (basetype);
8187
8188 /* The actual arglist for this function includes a "hidden" argument
8189 which is "this". Put it into the list of argument types. */
8190 argtypes = tree_cons (NULL_TREE, ptype, argtypes);
8191 TYPE_ARG_TYPES (t) = argtypes;
8192
8193 /* If we already have such a type, use the old one. */
8194 hashval_t hash = type_hash_canon_hash (t);
8195 t = type_hash_canon (hash, t);
8196
8197 /* Set up the canonical type. */
8198 any_structural_p
8199 = (TYPE_STRUCTURAL_EQUALITY_P (basetype)
8200 || TYPE_STRUCTURAL_EQUALITY_P (rettype));
8201 any_noncanonical_p
8202 = (TYPE_CANONICAL (basetype) != basetype
8203 || TYPE_CANONICAL (rettype) != rettype);
8204 canon_argtypes = maybe_canonicalize_argtypes (TREE_CHAIN (argtypes),
8205 &any_structural_p,
8206 &any_noncanonical_p);
8207 if (any_structural_p)
8208 SET_TYPE_STRUCTURAL_EQUALITY (t);
8209 else if (any_noncanonical_p)
8210 TYPE_CANONICAL (t)
8211 = build_method_type_directly (TYPE_CANONICAL (basetype),
8212 TYPE_CANONICAL (rettype),
8213 canon_argtypes);
8214 if (!COMPLETE_TYPE_P (t))
8215 layout_type (t);
8216
8217 return t;
8218 }
8219
8220 /* Construct, lay out and return the type of methods belonging to class
8221 BASETYPE and whose arguments and values are described by TYPE.
8222 If that type exists already, reuse it.
8223 TYPE must be a FUNCTION_TYPE node. */
8224
8225 tree
build_method_type(tree basetype,tree type)8226 build_method_type (tree basetype, tree type)
8227 {
8228 gcc_assert (TREE_CODE (type) == FUNCTION_TYPE);
8229
8230 return build_method_type_directly (basetype,
8231 TREE_TYPE (type),
8232 TYPE_ARG_TYPES (type));
8233 }
8234
8235 /* Construct, lay out and return the type of offsets to a value
8236 of type TYPE, within an object of type BASETYPE.
8237 If a suitable offset type exists already, reuse it. */
8238
8239 tree
build_offset_type(tree basetype,tree type)8240 build_offset_type (tree basetype, tree type)
8241 {
8242 tree t;
8243
8244 /* Make a node of the sort we want. */
8245 t = make_node (OFFSET_TYPE);
8246
8247 TYPE_OFFSET_BASETYPE (t) = TYPE_MAIN_VARIANT (basetype);
8248 TREE_TYPE (t) = type;
8249
8250 /* If we already have such a type, use the old one. */
8251 hashval_t hash = type_hash_canon_hash (t);
8252 t = type_hash_canon (hash, t);
8253
8254 if (!COMPLETE_TYPE_P (t))
8255 layout_type (t);
8256
8257 if (TYPE_CANONICAL (t) == t)
8258 {
8259 if (TYPE_STRUCTURAL_EQUALITY_P (basetype)
8260 || TYPE_STRUCTURAL_EQUALITY_P (type))
8261 SET_TYPE_STRUCTURAL_EQUALITY (t);
8262 else if (TYPE_CANONICAL (TYPE_MAIN_VARIANT (basetype)) != basetype
8263 || TYPE_CANONICAL (type) != type)
8264 TYPE_CANONICAL (t)
8265 = build_offset_type (TYPE_CANONICAL (TYPE_MAIN_VARIANT (basetype)),
8266 TYPE_CANONICAL (type));
8267 }
8268
8269 return t;
8270 }
8271
8272 /* Create a complex type whose components are COMPONENT_TYPE.
8273
8274 If NAMED is true, the type is given a TYPE_NAME. We do not always
8275 do so because this creates a DECL node and thus make the DECL_UIDs
8276 dependent on the type canonicalization hashtable, which is GC-ed,
8277 so the DECL_UIDs would not be stable wrt garbage collection. */
8278
8279 tree
build_complex_type(tree component_type,bool named)8280 build_complex_type (tree component_type, bool named)
8281 {
8282 gcc_assert (INTEGRAL_TYPE_P (component_type)
8283 || SCALAR_FLOAT_TYPE_P (component_type)
8284 || FIXED_POINT_TYPE_P (component_type));
8285
8286 /* Make a node of the sort we want. */
8287 tree probe = make_node (COMPLEX_TYPE);
8288
8289 TREE_TYPE (probe) = TYPE_MAIN_VARIANT (component_type);
8290
8291 /* If we already have such a type, use the old one. */
8292 hashval_t hash = type_hash_canon_hash (probe);
8293 tree t = type_hash_canon (hash, probe);
8294
8295 if (t == probe)
8296 {
8297 /* We created a new type. The hash insertion will have laid
8298 out the type. We need to check the canonicalization and
8299 maybe set the name. */
8300 gcc_checking_assert (COMPLETE_TYPE_P (t)
8301 && !TYPE_NAME (t)
8302 && TYPE_CANONICAL (t) == t);
8303
8304 if (TYPE_STRUCTURAL_EQUALITY_P (TREE_TYPE (t)))
8305 SET_TYPE_STRUCTURAL_EQUALITY (t);
8306 else if (TYPE_CANONICAL (TREE_TYPE (t)) != TREE_TYPE (t))
8307 TYPE_CANONICAL (t)
8308 = build_complex_type (TYPE_CANONICAL (TREE_TYPE (t)), named);
8309
8310 /* We need to create a name, since complex is a fundamental type. */
8311 if (named)
8312 {
8313 const char *name = NULL;
8314
8315 if (TREE_TYPE (t) == char_type_node)
8316 name = "complex char";
8317 else if (TREE_TYPE (t) == signed_char_type_node)
8318 name = "complex signed char";
8319 else if (TREE_TYPE (t) == unsigned_char_type_node)
8320 name = "complex unsigned char";
8321 else if (TREE_TYPE (t) == short_integer_type_node)
8322 name = "complex short int";
8323 else if (TREE_TYPE (t) == short_unsigned_type_node)
8324 name = "complex short unsigned int";
8325 else if (TREE_TYPE (t) == integer_type_node)
8326 name = "complex int";
8327 else if (TREE_TYPE (t) == unsigned_type_node)
8328 name = "complex unsigned int";
8329 else if (TREE_TYPE (t) == long_integer_type_node)
8330 name = "complex long int";
8331 else if (TREE_TYPE (t) == long_unsigned_type_node)
8332 name = "complex long unsigned int";
8333 else if (TREE_TYPE (t) == long_long_integer_type_node)
8334 name = "complex long long int";
8335 else if (TREE_TYPE (t) == long_long_unsigned_type_node)
8336 name = "complex long long unsigned int";
8337
8338 if (name != NULL)
8339 TYPE_NAME (t) = build_decl (UNKNOWN_LOCATION, TYPE_DECL,
8340 get_identifier (name), t);
8341 }
8342 }
8343
8344 return build_qualified_type (t, TYPE_QUALS (component_type));
8345 }
8346
8347 /* If TYPE is a real or complex floating-point type and the target
8348 does not directly support arithmetic on TYPE then return the wider
8349 type to be used for arithmetic on TYPE. Otherwise, return
8350 NULL_TREE. */
8351
8352 tree
excess_precision_type(tree type)8353 excess_precision_type (tree type)
8354 {
8355 /* The target can give two different responses to the question of
8356 which excess precision mode it would like depending on whether we
8357 are in -fexcess-precision=standard or -fexcess-precision=fast. */
8358
8359 enum excess_precision_type requested_type
8360 = (flag_excess_precision == EXCESS_PRECISION_FAST
8361 ? EXCESS_PRECISION_TYPE_FAST
8362 : EXCESS_PRECISION_TYPE_STANDARD);
8363
8364 enum flt_eval_method target_flt_eval_method
8365 = targetm.c.excess_precision (requested_type);
8366
8367 /* The target should not ask for unpredictable float evaluation (though
8368 it might advertise that implicitly the evaluation is unpredictable,
8369 but we don't care about that here, it will have been reported
8370 elsewhere). If it does ask for unpredictable evaluation, we have
8371 nothing to do here. */
8372 gcc_assert (target_flt_eval_method != FLT_EVAL_METHOD_UNPREDICTABLE);
8373
8374 /* Nothing to do. The target has asked for all types we know about
8375 to be computed with their native precision and range. */
8376 if (target_flt_eval_method == FLT_EVAL_METHOD_PROMOTE_TO_FLOAT16)
8377 return NULL_TREE;
8378
8379 /* The target will promote this type in a target-dependent way, so excess
8380 precision ought to leave it alone. */
8381 if (targetm.promoted_type (type) != NULL_TREE)
8382 return NULL_TREE;
8383
8384 machine_mode float16_type_mode = (float16_type_node
8385 ? TYPE_MODE (float16_type_node)
8386 : VOIDmode);
8387 machine_mode float_type_mode = TYPE_MODE (float_type_node);
8388 machine_mode double_type_mode = TYPE_MODE (double_type_node);
8389
8390 switch (TREE_CODE (type))
8391 {
8392 case REAL_TYPE:
8393 {
8394 machine_mode type_mode = TYPE_MODE (type);
8395 switch (target_flt_eval_method)
8396 {
8397 case FLT_EVAL_METHOD_PROMOTE_TO_FLOAT:
8398 if (type_mode == float16_type_mode)
8399 return float_type_node;
8400 break;
8401 case FLT_EVAL_METHOD_PROMOTE_TO_DOUBLE:
8402 if (type_mode == float16_type_mode
8403 || type_mode == float_type_mode)
8404 return double_type_node;
8405 break;
8406 case FLT_EVAL_METHOD_PROMOTE_TO_LONG_DOUBLE:
8407 if (type_mode == float16_type_mode
8408 || type_mode == float_type_mode
8409 || type_mode == double_type_mode)
8410 return long_double_type_node;
8411 break;
8412 default:
8413 gcc_unreachable ();
8414 }
8415 break;
8416 }
8417 case COMPLEX_TYPE:
8418 {
8419 if (TREE_CODE (TREE_TYPE (type)) != REAL_TYPE)
8420 return NULL_TREE;
8421 machine_mode type_mode = TYPE_MODE (TREE_TYPE (type));
8422 switch (target_flt_eval_method)
8423 {
8424 case FLT_EVAL_METHOD_PROMOTE_TO_FLOAT:
8425 if (type_mode == float16_type_mode)
8426 return complex_float_type_node;
8427 break;
8428 case FLT_EVAL_METHOD_PROMOTE_TO_DOUBLE:
8429 if (type_mode == float16_type_mode
8430 || type_mode == float_type_mode)
8431 return complex_double_type_node;
8432 break;
8433 case FLT_EVAL_METHOD_PROMOTE_TO_LONG_DOUBLE:
8434 if (type_mode == float16_type_mode
8435 || type_mode == float_type_mode
8436 || type_mode == double_type_mode)
8437 return complex_long_double_type_node;
8438 break;
8439 default:
8440 gcc_unreachable ();
8441 }
8442 break;
8443 }
8444 default:
8445 break;
8446 }
8447
8448 return NULL_TREE;
8449 }
8450
8451 /* Return OP, stripped of any conversions to wider types as much as is safe.
8452 Converting the value back to OP's type makes a value equivalent to OP.
8453
8454 If FOR_TYPE is nonzero, we return a value which, if converted to
8455 type FOR_TYPE, would be equivalent to converting OP to type FOR_TYPE.
8456
8457 OP must have integer, real or enumeral type. Pointers are not allowed!
8458
8459 There are some cases where the obvious value we could return
8460 would regenerate to OP if converted to OP's type,
8461 but would not extend like OP to wider types.
8462 If FOR_TYPE indicates such extension is contemplated, we eschew such values.
8463 For example, if OP is (unsigned short)(signed char)-1,
8464 we avoid returning (signed char)-1 if FOR_TYPE is int,
8465 even though extending that to an unsigned short would regenerate OP,
8466 since the result of extending (signed char)-1 to (int)
8467 is different from (int) OP. */
8468
8469 tree
get_unwidened(tree op,tree for_type)8470 get_unwidened (tree op, tree for_type)
8471 {
8472 /* Set UNS initially if converting OP to FOR_TYPE is a zero-extension. */
8473 tree type = TREE_TYPE (op);
8474 unsigned final_prec
8475 = TYPE_PRECISION (for_type != 0 ? for_type : type);
8476 int uns
8477 = (for_type != 0 && for_type != type
8478 && final_prec > TYPE_PRECISION (type)
8479 && TYPE_UNSIGNED (type));
8480 tree win = op;
8481
8482 while (CONVERT_EXPR_P (op))
8483 {
8484 int bitschange;
8485
8486 /* TYPE_PRECISION on vector types has different meaning
8487 (TYPE_VECTOR_SUBPARTS) and casts from vectors are view conversions,
8488 so avoid them here. */
8489 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (op, 0))) == VECTOR_TYPE)
8490 break;
8491
8492 bitschange = TYPE_PRECISION (TREE_TYPE (op))
8493 - TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op, 0)));
8494
8495 /* Truncations are many-one so cannot be removed.
8496 Unless we are later going to truncate down even farther. */
8497 if (bitschange < 0
8498 && final_prec > TYPE_PRECISION (TREE_TYPE (op)))
8499 break;
8500
8501 /* See what's inside this conversion. If we decide to strip it,
8502 we will set WIN. */
8503 op = TREE_OPERAND (op, 0);
8504
8505 /* If we have not stripped any zero-extensions (uns is 0),
8506 we can strip any kind of extension.
8507 If we have previously stripped a zero-extension,
8508 only zero-extensions can safely be stripped.
8509 Any extension can be stripped if the bits it would produce
8510 are all going to be discarded later by truncating to FOR_TYPE. */
8511
8512 if (bitschange > 0)
8513 {
8514 if (! uns || final_prec <= TYPE_PRECISION (TREE_TYPE (op)))
8515 win = op;
8516 /* TYPE_UNSIGNED says whether this is a zero-extension.
8517 Let's avoid computing it if it does not affect WIN
8518 and if UNS will not be needed again. */
8519 if ((uns
8520 || CONVERT_EXPR_P (op))
8521 && TYPE_UNSIGNED (TREE_TYPE (op)))
8522 {
8523 uns = 1;
8524 win = op;
8525 }
8526 }
8527 }
8528
8529 /* If we finally reach a constant see if it fits in sth smaller and
8530 in that case convert it. */
8531 if (TREE_CODE (win) == INTEGER_CST)
8532 {
8533 tree wtype = TREE_TYPE (win);
8534 unsigned prec = wi::min_precision (wi::to_wide (win), TYPE_SIGN (wtype));
8535 if (for_type)
8536 prec = MAX (prec, final_prec);
8537 if (prec < TYPE_PRECISION (wtype))
8538 {
8539 tree t = lang_hooks.types.type_for_size (prec, TYPE_UNSIGNED (wtype));
8540 if (t && TYPE_PRECISION (t) < TYPE_PRECISION (wtype))
8541 win = fold_convert (t, win);
8542 }
8543 }
8544
8545 return win;
8546 }
8547
8548 /* Return OP or a simpler expression for a narrower value
8549 which can be sign-extended or zero-extended to give back OP.
8550 Store in *UNSIGNEDP_PTR either 1 if the value should be zero-extended
8551 or 0 if the value should be sign-extended. */
8552
8553 tree
get_narrower(tree op,int * unsignedp_ptr)8554 get_narrower (tree op, int *unsignedp_ptr)
8555 {
8556 int uns = 0;
8557 int first = 1;
8558 tree win = op;
8559 bool integral_p = INTEGRAL_TYPE_P (TREE_TYPE (op));
8560
8561 while (TREE_CODE (op) == NOP_EXPR)
8562 {
8563 int bitschange
8564 = (TYPE_PRECISION (TREE_TYPE (op))
8565 - TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op, 0))));
8566
8567 /* Truncations are many-one so cannot be removed. */
8568 if (bitschange < 0)
8569 break;
8570
8571 /* See what's inside this conversion. If we decide to strip it,
8572 we will set WIN. */
8573
8574 if (bitschange > 0)
8575 {
8576 op = TREE_OPERAND (op, 0);
8577 /* An extension: the outermost one can be stripped,
8578 but remember whether it is zero or sign extension. */
8579 if (first)
8580 uns = TYPE_UNSIGNED (TREE_TYPE (op));
8581 /* Otherwise, if a sign extension has been stripped,
8582 only sign extensions can now be stripped;
8583 if a zero extension has been stripped, only zero-extensions. */
8584 else if (uns != TYPE_UNSIGNED (TREE_TYPE (op)))
8585 break;
8586 first = 0;
8587 }
8588 else /* bitschange == 0 */
8589 {
8590 /* A change in nominal type can always be stripped, but we must
8591 preserve the unsignedness. */
8592 if (first)
8593 uns = TYPE_UNSIGNED (TREE_TYPE (op));
8594 first = 0;
8595 op = TREE_OPERAND (op, 0);
8596 /* Keep trying to narrow, but don't assign op to win if it
8597 would turn an integral type into something else. */
8598 if (INTEGRAL_TYPE_P (TREE_TYPE (op)) != integral_p)
8599 continue;
8600 }
8601
8602 win = op;
8603 }
8604
8605 if (TREE_CODE (op) == COMPONENT_REF
8606 /* Since type_for_size always gives an integer type. */
8607 && TREE_CODE (TREE_TYPE (op)) != REAL_TYPE
8608 && TREE_CODE (TREE_TYPE (op)) != FIXED_POINT_TYPE
8609 /* Ensure field is laid out already. */
8610 && DECL_SIZE (TREE_OPERAND (op, 1)) != 0
8611 && tree_fits_uhwi_p (DECL_SIZE (TREE_OPERAND (op, 1))))
8612 {
8613 unsigned HOST_WIDE_INT innerprec
8614 = tree_to_uhwi (DECL_SIZE (TREE_OPERAND (op, 1)));
8615 int unsignedp = (DECL_UNSIGNED (TREE_OPERAND (op, 1))
8616 || TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op, 1))));
8617 tree type = lang_hooks.types.type_for_size (innerprec, unsignedp);
8618
8619 /* We can get this structure field in a narrower type that fits it,
8620 but the resulting extension to its nominal type (a fullword type)
8621 must satisfy the same conditions as for other extensions.
8622
8623 Do this only for fields that are aligned (not bit-fields),
8624 because when bit-field insns will be used there is no
8625 advantage in doing this. */
8626
8627 if (innerprec < TYPE_PRECISION (TREE_TYPE (op))
8628 && ! DECL_BIT_FIELD (TREE_OPERAND (op, 1))
8629 && (first || uns == DECL_UNSIGNED (TREE_OPERAND (op, 1)))
8630 && type != 0)
8631 {
8632 if (first)
8633 uns = DECL_UNSIGNED (TREE_OPERAND (op, 1));
8634 win = fold_convert (type, op);
8635 }
8636 }
8637
8638 *unsignedp_ptr = uns;
8639 return win;
8640 }
8641
8642 /* Return true if integer constant C has a value that is permissible
8643 for TYPE, an integral type. */
8644
8645 bool
int_fits_type_p(const_tree c,const_tree type)8646 int_fits_type_p (const_tree c, const_tree type)
8647 {
8648 tree type_low_bound, type_high_bound;
8649 bool ok_for_low_bound, ok_for_high_bound;
8650 signop sgn_c = TYPE_SIGN (TREE_TYPE (c));
8651
8652 /* Non-standard boolean types can have arbitrary precision but various
8653 transformations assume that they can only take values 0 and +/-1. */
8654 if (TREE_CODE (type) == BOOLEAN_TYPE)
8655 return wi::fits_to_boolean_p (wi::to_wide (c), type);
8656
8657 retry:
8658 type_low_bound = TYPE_MIN_VALUE (type);
8659 type_high_bound = TYPE_MAX_VALUE (type);
8660
8661 /* If at least one bound of the type is a constant integer, we can check
8662 ourselves and maybe make a decision. If no such decision is possible, but
8663 this type is a subtype, try checking against that. Otherwise, use
8664 fits_to_tree_p, which checks against the precision.
8665
8666 Compute the status for each possibly constant bound, and return if we see
8667 one does not match. Use ok_for_xxx_bound for this purpose, assigning -1
8668 for "unknown if constant fits", 0 for "constant known *not* to fit" and 1
8669 for "constant known to fit". */
8670
8671 /* Check if c >= type_low_bound. */
8672 if (type_low_bound && TREE_CODE (type_low_bound) == INTEGER_CST)
8673 {
8674 if (tree_int_cst_lt (c, type_low_bound))
8675 return false;
8676 ok_for_low_bound = true;
8677 }
8678 else
8679 ok_for_low_bound = false;
8680
8681 /* Check if c <= type_high_bound. */
8682 if (type_high_bound && TREE_CODE (type_high_bound) == INTEGER_CST)
8683 {
8684 if (tree_int_cst_lt (type_high_bound, c))
8685 return false;
8686 ok_for_high_bound = true;
8687 }
8688 else
8689 ok_for_high_bound = false;
8690
8691 /* If the constant fits both bounds, the result is known. */
8692 if (ok_for_low_bound && ok_for_high_bound)
8693 return true;
8694
8695 /* Perform some generic filtering which may allow making a decision
8696 even if the bounds are not constant. First, negative integers
8697 never fit in unsigned types, */
8698 if (TYPE_UNSIGNED (type) && sgn_c == SIGNED && wi::neg_p (wi::to_wide (c)))
8699 return false;
8700
8701 /* Second, narrower types always fit in wider ones. */
8702 if (TYPE_PRECISION (type) > TYPE_PRECISION (TREE_TYPE (c)))
8703 return true;
8704
8705 /* Third, unsigned integers with top bit set never fit signed types. */
8706 if (!TYPE_UNSIGNED (type) && sgn_c == UNSIGNED)
8707 {
8708 int prec = GET_MODE_PRECISION (SCALAR_INT_TYPE_MODE (TREE_TYPE (c))) - 1;
8709 if (prec < TYPE_PRECISION (TREE_TYPE (c)))
8710 {
8711 /* When a tree_cst is converted to a wide-int, the precision
8712 is taken from the type. However, if the precision of the
8713 mode underneath the type is smaller than that, it is
8714 possible that the value will not fit. The test below
8715 fails if any bit is set between the sign bit of the
8716 underlying mode and the top bit of the type. */
8717 if (wi::zext (wi::to_wide (c), prec - 1) != wi::to_wide (c))
8718 return false;
8719 }
8720 else if (wi::neg_p (wi::to_wide (c)))
8721 return false;
8722 }
8723
8724 /* If we haven't been able to decide at this point, there nothing more we
8725 can check ourselves here. Look at the base type if we have one and it
8726 has the same precision. */
8727 if (TREE_CODE (type) == INTEGER_TYPE
8728 && TREE_TYPE (type) != 0
8729 && TYPE_PRECISION (type) == TYPE_PRECISION (TREE_TYPE (type)))
8730 {
8731 type = TREE_TYPE (type);
8732 goto retry;
8733 }
8734
8735 /* Or to fits_to_tree_p, if nothing else. */
8736 return wi::fits_to_tree_p (wi::to_wide (c), type);
8737 }
8738
8739 /* Stores bounds of an integer TYPE in MIN and MAX. If TYPE has non-constant
8740 bounds or is a POINTER_TYPE, the maximum and/or minimum values that can be
8741 represented (assuming two's-complement arithmetic) within the bit
8742 precision of the type are returned instead. */
8743
8744 void
get_type_static_bounds(const_tree type,mpz_t min,mpz_t max)8745 get_type_static_bounds (const_tree type, mpz_t min, mpz_t max)
8746 {
8747 if (!POINTER_TYPE_P (type) && TYPE_MIN_VALUE (type)
8748 && TREE_CODE (TYPE_MIN_VALUE (type)) == INTEGER_CST)
8749 wi::to_mpz (wi::to_wide (TYPE_MIN_VALUE (type)), min, TYPE_SIGN (type));
8750 else
8751 {
8752 if (TYPE_UNSIGNED (type))
8753 mpz_set_ui (min, 0);
8754 else
8755 {
8756 wide_int mn = wi::min_value (TYPE_PRECISION (type), SIGNED);
8757 wi::to_mpz (mn, min, SIGNED);
8758 }
8759 }
8760
8761 if (!POINTER_TYPE_P (type) && TYPE_MAX_VALUE (type)
8762 && TREE_CODE (TYPE_MAX_VALUE (type)) == INTEGER_CST)
8763 wi::to_mpz (wi::to_wide (TYPE_MAX_VALUE (type)), max, TYPE_SIGN (type));
8764 else
8765 {
8766 wide_int mn = wi::max_value (TYPE_PRECISION (type), TYPE_SIGN (type));
8767 wi::to_mpz (mn, max, TYPE_SIGN (type));
8768 }
8769 }
8770
8771 /* Return true if VAR is an automatic variable defined in function FN. */
8772
8773 bool
auto_var_in_fn_p(const_tree var,const_tree fn)8774 auto_var_in_fn_p (const_tree var, const_tree fn)
8775 {
8776 return (DECL_P (var) && DECL_CONTEXT (var) == fn
8777 && ((((VAR_P (var) && ! DECL_EXTERNAL (var))
8778 || TREE_CODE (var) == PARM_DECL)
8779 && ! TREE_STATIC (var))
8780 || TREE_CODE (var) == LABEL_DECL
8781 || TREE_CODE (var) == RESULT_DECL));
8782 }
8783
8784 /* Subprogram of following function. Called by walk_tree.
8785
8786 Return *TP if it is an automatic variable or parameter of the
8787 function passed in as DATA. */
8788
8789 static tree
find_var_from_fn(tree * tp,int * walk_subtrees,void * data)8790 find_var_from_fn (tree *tp, int *walk_subtrees, void *data)
8791 {
8792 tree fn = (tree) data;
8793
8794 if (TYPE_P (*tp))
8795 *walk_subtrees = 0;
8796
8797 else if (DECL_P (*tp)
8798 && auto_var_in_fn_p (*tp, fn))
8799 return *tp;
8800
8801 return NULL_TREE;
8802 }
8803
8804 /* Returns true if T is, contains, or refers to a type with variable
8805 size. For METHOD_TYPEs and FUNCTION_TYPEs we exclude the
8806 arguments, but not the return type. If FN is nonzero, only return
8807 true if a modifier of the type or position of FN is a variable or
8808 parameter inside FN.
8809
8810 This concept is more general than that of C99 'variably modified types':
8811 in C99, a struct type is never variably modified because a VLA may not
8812 appear as a structure member. However, in GNU C code like:
8813
8814 struct S { int i[f()]; };
8815
8816 is valid, and other languages may define similar constructs. */
8817
8818 bool
variably_modified_type_p(tree type,tree fn)8819 variably_modified_type_p (tree type, tree fn)
8820 {
8821 tree t;
8822
8823 /* Test if T is either variable (if FN is zero) or an expression containing
8824 a variable in FN. If TYPE isn't gimplified, return true also if
8825 gimplify_one_sizepos would gimplify the expression into a local
8826 variable. */
8827 #define RETURN_TRUE_IF_VAR(T) \
8828 do { tree _t = (T); \
8829 if (_t != NULL_TREE \
8830 && _t != error_mark_node \
8831 && !CONSTANT_CLASS_P (_t) \
8832 && TREE_CODE (_t) != PLACEHOLDER_EXPR \
8833 && (!fn \
8834 || (!TYPE_SIZES_GIMPLIFIED (type) \
8835 && (TREE_CODE (_t) != VAR_DECL \
8836 && !CONTAINS_PLACEHOLDER_P (_t))) \
8837 || walk_tree (&_t, find_var_from_fn, fn, NULL))) \
8838 return true; } while (0)
8839
8840 if (type == error_mark_node)
8841 return false;
8842
8843 /* If TYPE itself has variable size, it is variably modified. */
8844 RETURN_TRUE_IF_VAR (TYPE_SIZE (type));
8845 RETURN_TRUE_IF_VAR (TYPE_SIZE_UNIT (type));
8846
8847 switch (TREE_CODE (type))
8848 {
8849 case POINTER_TYPE:
8850 case REFERENCE_TYPE:
8851 case VECTOR_TYPE:
8852 /* Ada can have pointer types refering to themselves indirectly. */
8853 if (TREE_VISITED (type))
8854 return false;
8855 TREE_VISITED (type) = true;
8856 if (variably_modified_type_p (TREE_TYPE (type), fn))
8857 {
8858 TREE_VISITED (type) = false;
8859 return true;
8860 }
8861 TREE_VISITED (type) = false;
8862 break;
8863
8864 case FUNCTION_TYPE:
8865 case METHOD_TYPE:
8866 /* If TYPE is a function type, it is variably modified if the
8867 return type is variably modified. */
8868 if (variably_modified_type_p (TREE_TYPE (type), fn))
8869 return true;
8870 break;
8871
8872 case INTEGER_TYPE:
8873 case REAL_TYPE:
8874 case FIXED_POINT_TYPE:
8875 case ENUMERAL_TYPE:
8876 case BOOLEAN_TYPE:
8877 /* Scalar types are variably modified if their end points
8878 aren't constant. */
8879 RETURN_TRUE_IF_VAR (TYPE_MIN_VALUE (type));
8880 RETURN_TRUE_IF_VAR (TYPE_MAX_VALUE (type));
8881 break;
8882
8883 case RECORD_TYPE:
8884 case UNION_TYPE:
8885 case QUAL_UNION_TYPE:
8886 /* We can't see if any of the fields are variably-modified by the
8887 definition we normally use, since that would produce infinite
8888 recursion via pointers. */
8889 /* This is variably modified if some field's type is. */
8890 for (t = TYPE_FIELDS (type); t; t = DECL_CHAIN (t))
8891 if (TREE_CODE (t) == FIELD_DECL)
8892 {
8893 RETURN_TRUE_IF_VAR (DECL_FIELD_OFFSET (t));
8894 RETURN_TRUE_IF_VAR (DECL_SIZE (t));
8895 RETURN_TRUE_IF_VAR (DECL_SIZE_UNIT (t));
8896
8897 if (TREE_CODE (type) == QUAL_UNION_TYPE)
8898 RETURN_TRUE_IF_VAR (DECL_QUALIFIER (t));
8899 }
8900 break;
8901
8902 case ARRAY_TYPE:
8903 /* Do not call ourselves to avoid infinite recursion. This is
8904 variably modified if the element type is. */
8905 RETURN_TRUE_IF_VAR (TYPE_SIZE (TREE_TYPE (type)));
8906 RETURN_TRUE_IF_VAR (TYPE_SIZE_UNIT (TREE_TYPE (type)));
8907 break;
8908
8909 default:
8910 break;
8911 }
8912
8913 /* The current language may have other cases to check, but in general,
8914 all other types are not variably modified. */
8915 return lang_hooks.tree_inlining.var_mod_type_p (type, fn);
8916
8917 #undef RETURN_TRUE_IF_VAR
8918 }
8919
8920 /* Given a DECL or TYPE, return the scope in which it was declared, or
8921 NULL_TREE if there is no containing scope. */
8922
8923 tree
get_containing_scope(const_tree t)8924 get_containing_scope (const_tree t)
8925 {
8926 return (TYPE_P (t) ? TYPE_CONTEXT (t) : DECL_CONTEXT (t));
8927 }
8928
8929 /* Returns the ultimate TRANSLATION_UNIT_DECL context of DECL or NULL. */
8930
8931 const_tree
get_ultimate_context(const_tree decl)8932 get_ultimate_context (const_tree decl)
8933 {
8934 while (decl && TREE_CODE (decl) != TRANSLATION_UNIT_DECL)
8935 {
8936 if (TREE_CODE (decl) == BLOCK)
8937 decl = BLOCK_SUPERCONTEXT (decl);
8938 else
8939 decl = get_containing_scope (decl);
8940 }
8941 return decl;
8942 }
8943
8944 /* Return the innermost context enclosing DECL that is
8945 a FUNCTION_DECL, or zero if none. */
8946
8947 tree
decl_function_context(const_tree decl)8948 decl_function_context (const_tree decl)
8949 {
8950 tree context;
8951
8952 if (TREE_CODE (decl) == ERROR_MARK)
8953 return 0;
8954
8955 /* C++ virtual functions use DECL_CONTEXT for the class of the vtable
8956 where we look up the function at runtime. Such functions always take
8957 a first argument of type 'pointer to real context'.
8958
8959 C++ should really be fixed to use DECL_CONTEXT for the real context,
8960 and use something else for the "virtual context". */
8961 else if (TREE_CODE (decl) == FUNCTION_DECL && DECL_VINDEX (decl))
8962 context
8963 = TYPE_MAIN_VARIANT
8964 (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl)))));
8965 else
8966 context = DECL_CONTEXT (decl);
8967
8968 while (context && TREE_CODE (context) != FUNCTION_DECL)
8969 {
8970 if (TREE_CODE (context) == BLOCK)
8971 context = BLOCK_SUPERCONTEXT (context);
8972 else
8973 context = get_containing_scope (context);
8974 }
8975
8976 return context;
8977 }
8978
8979 /* Return the innermost context enclosing DECL that is
8980 a RECORD_TYPE, UNION_TYPE or QUAL_UNION_TYPE, or zero if none.
8981 TYPE_DECLs and FUNCTION_DECLs are transparent to this function. */
8982
8983 tree
decl_type_context(const_tree decl)8984 decl_type_context (const_tree decl)
8985 {
8986 tree context = DECL_CONTEXT (decl);
8987
8988 while (context)
8989 switch (TREE_CODE (context))
8990 {
8991 case NAMESPACE_DECL:
8992 case TRANSLATION_UNIT_DECL:
8993 return NULL_TREE;
8994
8995 case RECORD_TYPE:
8996 case UNION_TYPE:
8997 case QUAL_UNION_TYPE:
8998 return context;
8999
9000 case TYPE_DECL:
9001 case FUNCTION_DECL:
9002 context = DECL_CONTEXT (context);
9003 break;
9004
9005 case BLOCK:
9006 context = BLOCK_SUPERCONTEXT (context);
9007 break;
9008
9009 default:
9010 gcc_unreachable ();
9011 }
9012
9013 return NULL_TREE;
9014 }
9015
9016 /* CALL is a CALL_EXPR. Return the declaration for the function
9017 called, or NULL_TREE if the called function cannot be
9018 determined. */
9019
9020 tree
get_callee_fndecl(const_tree call)9021 get_callee_fndecl (const_tree call)
9022 {
9023 tree addr;
9024
9025 if (call == error_mark_node)
9026 return error_mark_node;
9027
9028 /* It's invalid to call this function with anything but a
9029 CALL_EXPR. */
9030 gcc_assert (TREE_CODE (call) == CALL_EXPR);
9031
9032 /* The first operand to the CALL is the address of the function
9033 called. */
9034 addr = CALL_EXPR_FN (call);
9035
9036 /* If there is no function, return early. */
9037 if (addr == NULL_TREE)
9038 return NULL_TREE;
9039
9040 STRIP_NOPS (addr);
9041
9042 /* If this is a readonly function pointer, extract its initial value. */
9043 if (DECL_P (addr) && TREE_CODE (addr) != FUNCTION_DECL
9044 && TREE_READONLY (addr) && ! TREE_THIS_VOLATILE (addr)
9045 && DECL_INITIAL (addr))
9046 addr = DECL_INITIAL (addr);
9047
9048 /* If the address is just `&f' for some function `f', then we know
9049 that `f' is being called. */
9050 if (TREE_CODE (addr) == ADDR_EXPR
9051 && TREE_CODE (TREE_OPERAND (addr, 0)) == FUNCTION_DECL)
9052 return TREE_OPERAND (addr, 0);
9053
9054 /* We couldn't figure out what was being called. */
9055 return NULL_TREE;
9056 }
9057
9058 /* If CALL_EXPR CALL calls a normal built-in function or an internal function,
9059 return the associated function code, otherwise return CFN_LAST. */
9060
9061 combined_fn
get_call_combined_fn(const_tree call)9062 get_call_combined_fn (const_tree call)
9063 {
9064 /* It's invalid to call this function with anything but a CALL_EXPR. */
9065 gcc_assert (TREE_CODE (call) == CALL_EXPR);
9066
9067 if (!CALL_EXPR_FN (call))
9068 return as_combined_fn (CALL_EXPR_IFN (call));
9069
9070 tree fndecl = get_callee_fndecl (call);
9071 if (fndecl && DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL)
9072 return as_combined_fn (DECL_FUNCTION_CODE (fndecl));
9073
9074 return CFN_LAST;
9075 }
9076
9077 #define TREE_MEM_USAGE_SPACES 40
9078
9079 /* Print debugging information about tree nodes generated during the compile,
9080 and any language-specific information. */
9081
9082 void
dump_tree_statistics(void)9083 dump_tree_statistics (void)
9084 {
9085 if (GATHER_STATISTICS)
9086 {
9087 int i;
9088 uint64_t total_nodes, total_bytes;
9089 fprintf (stderr, "\nKind Nodes Bytes\n");
9090 mem_usage::print_dash_line (TREE_MEM_USAGE_SPACES);
9091 total_nodes = total_bytes = 0;
9092 for (i = 0; i < (int) all_kinds; i++)
9093 {
9094 fprintf (stderr, "%-20s %7" PRIu64 " %10" PRIu64 "\n",
9095 tree_node_kind_names[i], tree_node_counts[i],
9096 tree_node_sizes[i]);
9097 total_nodes += tree_node_counts[i];
9098 total_bytes += tree_node_sizes[i];
9099 }
9100 mem_usage::print_dash_line (TREE_MEM_USAGE_SPACES);
9101 fprintf (stderr, "%-20s %7" PRIu64 " %10" PRIu64 "\n", "Total",
9102 total_nodes, total_bytes);
9103 mem_usage::print_dash_line (TREE_MEM_USAGE_SPACES);
9104 fprintf (stderr, "Code Nodes\n");
9105 mem_usage::print_dash_line (TREE_MEM_USAGE_SPACES);
9106 for (i = 0; i < (int) MAX_TREE_CODES; i++)
9107 fprintf (stderr, "%-32s %7" PRIu64 "\n",
9108 get_tree_code_name ((enum tree_code) i), tree_code_counts[i]);
9109 mem_usage::print_dash_line (TREE_MEM_USAGE_SPACES);
9110 fprintf (stderr, "\n");
9111 ssanames_print_statistics ();
9112 fprintf (stderr, "\n");
9113 phinodes_print_statistics ();
9114 fprintf (stderr, "\n");
9115 }
9116 else
9117 fprintf (stderr, "(No per-node statistics)\n");
9118
9119 print_type_hash_statistics ();
9120 print_debug_expr_statistics ();
9121 print_value_expr_statistics ();
9122 lang_hooks.print_statistics ();
9123 }
9124
9125 #define FILE_FUNCTION_FORMAT "_GLOBAL__%s_%s"
9126
9127 /* Generate a crc32 of the low BYTES bytes of VALUE. */
9128
9129 unsigned
crc32_unsigned_n(unsigned chksum,unsigned value,unsigned bytes)9130 crc32_unsigned_n (unsigned chksum, unsigned value, unsigned bytes)
9131 {
9132 /* This relies on the raw feedback's top 4 bits being zero. */
9133 #define FEEDBACK(X) ((X) * 0x04c11db7)
9134 #define SYNDROME(X) (FEEDBACK ((X) & 1) ^ FEEDBACK ((X) & 2) \
9135 ^ FEEDBACK ((X) & 4) ^ FEEDBACK ((X) & 8))
9136 static const unsigned syndromes[16] =
9137 {
9138 SYNDROME(0x0), SYNDROME(0x1), SYNDROME(0x2), SYNDROME(0x3),
9139 SYNDROME(0x4), SYNDROME(0x5), SYNDROME(0x6), SYNDROME(0x7),
9140 SYNDROME(0x8), SYNDROME(0x9), SYNDROME(0xa), SYNDROME(0xb),
9141 SYNDROME(0xc), SYNDROME(0xd), SYNDROME(0xe), SYNDROME(0xf),
9142 };
9143 #undef FEEDBACK
9144 #undef SYNDROME
9145
9146 value <<= (32 - bytes * 8);
9147 for (unsigned ix = bytes * 2; ix--; value <<= 4)
9148 {
9149 unsigned feedback = syndromes[((value ^ chksum) >> 28) & 0xf];
9150
9151 chksum = (chksum << 4) ^ feedback;
9152 }
9153
9154 return chksum;
9155 }
9156
9157 /* Generate a crc32 of a string. */
9158
9159 unsigned
crc32_string(unsigned chksum,const char * string)9160 crc32_string (unsigned chksum, const char *string)
9161 {
9162 do
9163 chksum = crc32_byte (chksum, *string);
9164 while (*string++);
9165 return chksum;
9166 }
9167
9168 /* P is a string that will be used in a symbol. Mask out any characters
9169 that are not valid in that context. */
9170
9171 void
clean_symbol_name(char * p)9172 clean_symbol_name (char *p)
9173 {
9174 for (; *p; p++)
9175 if (! (ISALNUM (*p)
9176 #ifndef NO_DOLLAR_IN_LABEL /* this for `$'; unlikely, but... -- kr */
9177 || *p == '$'
9178 #endif
9179 #ifndef NO_DOT_IN_LABEL /* this for `.'; unlikely, but... */
9180 || *p == '.'
9181 #endif
9182 ))
9183 *p = '_';
9184 }
9185
9186 /* For anonymous aggregate types, we need some sort of name to
9187 hold on to. In practice, this should not appear, but it should
9188 not be harmful if it does. */
9189 bool
anon_aggrname_p(const_tree id_node)9190 anon_aggrname_p(const_tree id_node)
9191 {
9192 #ifndef NO_DOT_IN_LABEL
9193 return (IDENTIFIER_POINTER (id_node)[0] == '.'
9194 && IDENTIFIER_POINTER (id_node)[1] == '_');
9195 #else /* NO_DOT_IN_LABEL */
9196 #ifndef NO_DOLLAR_IN_LABEL
9197 return (IDENTIFIER_POINTER (id_node)[0] == '$' \
9198 && IDENTIFIER_POINTER (id_node)[1] == '_');
9199 #else /* NO_DOLLAR_IN_LABEL */
9200 #define ANON_AGGRNAME_PREFIX "__anon_"
9201 return (!strncmp (IDENTIFIER_POINTER (id_node), ANON_AGGRNAME_PREFIX,
9202 sizeof (ANON_AGGRNAME_PREFIX) - 1));
9203 #endif /* NO_DOLLAR_IN_LABEL */
9204 #endif /* NO_DOT_IN_LABEL */
9205 }
9206
9207 /* Return a format for an anonymous aggregate name. */
9208 const char *
anon_aggrname_format()9209 anon_aggrname_format()
9210 {
9211 #ifndef NO_DOT_IN_LABEL
9212 return "._%d";
9213 #else /* NO_DOT_IN_LABEL */
9214 #ifndef NO_DOLLAR_IN_LABEL
9215 return "$_%d";
9216 #else /* NO_DOLLAR_IN_LABEL */
9217 return "__anon_%d";
9218 #endif /* NO_DOLLAR_IN_LABEL */
9219 #endif /* NO_DOT_IN_LABEL */
9220 }
9221
9222 /* Generate a name for a special-purpose function.
9223 The generated name may need to be unique across the whole link.
9224 Changes to this function may also require corresponding changes to
9225 xstrdup_mask_random.
9226 TYPE is some string to identify the purpose of this function to the
9227 linker or collect2; it must start with an uppercase letter,
9228 one of:
9229 I - for constructors
9230 D - for destructors
9231 N - for C++ anonymous namespaces
9232 F - for DWARF unwind frame information. */
9233
9234 tree
get_file_function_name(const char * type)9235 get_file_function_name (const char *type)
9236 {
9237 char *buf;
9238 const char *p;
9239 char *q;
9240
9241 /* If we already have a name we know to be unique, just use that. */
9242 if (first_global_object_name)
9243 p = q = ASTRDUP (first_global_object_name);
9244 /* If the target is handling the constructors/destructors, they
9245 will be local to this file and the name is only necessary for
9246 debugging purposes.
9247 We also assign sub_I and sub_D sufixes to constructors called from
9248 the global static constructors. These are always local. */
9249 else if (((type[0] == 'I' || type[0] == 'D') && targetm.have_ctors_dtors)
9250 || (strncmp (type, "sub_", 4) == 0
9251 && (type[4] == 'I' || type[4] == 'D')))
9252 {
9253 const char *file = main_input_filename;
9254 if (! file)
9255 file = LOCATION_FILE (input_location);
9256 /* Just use the file's basename, because the full pathname
9257 might be quite long. */
9258 p = q = ASTRDUP (lbasename (file));
9259 }
9260 else
9261 {
9262 /* Otherwise, the name must be unique across the entire link.
9263 We don't have anything that we know to be unique to this translation
9264 unit, so use what we do have and throw in some randomness. */
9265 unsigned len;
9266 const char *name = weak_global_object_name;
9267 const char *file = main_input_filename;
9268
9269 if (! name)
9270 name = "";
9271 if (! file)
9272 file = LOCATION_FILE (input_location);
9273
9274 len = strlen (file);
9275 q = (char *) alloca (9 + 19 + len + 1);
9276 memcpy (q, file, len + 1);
9277
9278 snprintf (q + len, 9 + 19 + 1, "_%08X_" HOST_WIDE_INT_PRINT_HEX,
9279 crc32_string (0, name), get_random_seed (false));
9280
9281 p = q;
9282 }
9283
9284 clean_symbol_name (q);
9285 buf = (char *) alloca (sizeof (FILE_FUNCTION_FORMAT) + strlen (p)
9286 + strlen (type));
9287
9288 /* Set up the name of the file-level functions we may need.
9289 Use a global object (which is already required to be unique over
9290 the program) rather than the file name (which imposes extra
9291 constraints). */
9292 sprintf (buf, FILE_FUNCTION_FORMAT, type, p);
9293
9294 return get_identifier (buf);
9295 }
9296
9297 #if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
9298
9299 /* Complain that the tree code of NODE does not match the expected 0
9300 terminated list of trailing codes. The trailing code list can be
9301 empty, for a more vague error message. FILE, LINE, and FUNCTION
9302 are of the caller. */
9303
9304 void
tree_check_failed(const_tree node,const char * file,int line,const char * function,...)9305 tree_check_failed (const_tree node, const char *file,
9306 int line, const char *function, ...)
9307 {
9308 va_list args;
9309 const char *buffer;
9310 unsigned length = 0;
9311 enum tree_code code;
9312
9313 va_start (args, function);
9314 while ((code = (enum tree_code) va_arg (args, int)))
9315 length += 4 + strlen (get_tree_code_name (code));
9316 va_end (args);
9317 if (length)
9318 {
9319 char *tmp;
9320 va_start (args, function);
9321 length += strlen ("expected ");
9322 buffer = tmp = (char *) alloca (length);
9323 length = 0;
9324 while ((code = (enum tree_code) va_arg (args, int)))
9325 {
9326 const char *prefix = length ? " or " : "expected ";
9327
9328 strcpy (tmp + length, prefix);
9329 length += strlen (prefix);
9330 strcpy (tmp + length, get_tree_code_name (code));
9331 length += strlen (get_tree_code_name (code));
9332 }
9333 va_end (args);
9334 }
9335 else
9336 buffer = "unexpected node";
9337
9338 internal_error ("tree check: %s, have %s in %s, at %s:%d",
9339 buffer, get_tree_code_name (TREE_CODE (node)),
9340 function, trim_filename (file), line);
9341 }
9342
9343 /* Complain that the tree code of NODE does match the expected 0
9344 terminated list of trailing codes. FILE, LINE, and FUNCTION are of
9345 the caller. */
9346
9347 void
tree_not_check_failed(const_tree node,const char * file,int line,const char * function,...)9348 tree_not_check_failed (const_tree node, const char *file,
9349 int line, const char *function, ...)
9350 {
9351 va_list args;
9352 char *buffer;
9353 unsigned length = 0;
9354 enum tree_code code;
9355
9356 va_start (args, function);
9357 while ((code = (enum tree_code) va_arg (args, int)))
9358 length += 4 + strlen (get_tree_code_name (code));
9359 va_end (args);
9360 va_start (args, function);
9361 buffer = (char *) alloca (length);
9362 length = 0;
9363 while ((code = (enum tree_code) va_arg (args, int)))
9364 {
9365 if (length)
9366 {
9367 strcpy (buffer + length, " or ");
9368 length += 4;
9369 }
9370 strcpy (buffer + length, get_tree_code_name (code));
9371 length += strlen (get_tree_code_name (code));
9372 }
9373 va_end (args);
9374
9375 internal_error ("tree check: expected none of %s, have %s in %s, at %s:%d",
9376 buffer, get_tree_code_name (TREE_CODE (node)),
9377 function, trim_filename (file), line);
9378 }
9379
9380 /* Similar to tree_check_failed, except that we check for a class of tree
9381 code, given in CL. */
9382
9383 void
tree_class_check_failed(const_tree node,const enum tree_code_class cl,const char * file,int line,const char * function)9384 tree_class_check_failed (const_tree node, const enum tree_code_class cl,
9385 const char *file, int line, const char *function)
9386 {
9387 internal_error
9388 ("tree check: expected class %qs, have %qs (%s) in %s, at %s:%d",
9389 TREE_CODE_CLASS_STRING (cl),
9390 TREE_CODE_CLASS_STRING (TREE_CODE_CLASS (TREE_CODE (node))),
9391 get_tree_code_name (TREE_CODE (node)), function, trim_filename (file), line);
9392 }
9393
9394 /* Similar to tree_check_failed, except that instead of specifying a
9395 dozen codes, use the knowledge that they're all sequential. */
9396
9397 void
tree_range_check_failed(const_tree node,const char * file,int line,const char * function,enum tree_code c1,enum tree_code c2)9398 tree_range_check_failed (const_tree node, const char *file, int line,
9399 const char *function, enum tree_code c1,
9400 enum tree_code c2)
9401 {
9402 char *buffer;
9403 unsigned length = 0;
9404 unsigned int c;
9405
9406 for (c = c1; c <= c2; ++c)
9407 length += 4 + strlen (get_tree_code_name ((enum tree_code) c));
9408
9409 length += strlen ("expected ");
9410 buffer = (char *) alloca (length);
9411 length = 0;
9412
9413 for (c = c1; c <= c2; ++c)
9414 {
9415 const char *prefix = length ? " or " : "expected ";
9416
9417 strcpy (buffer + length, prefix);
9418 length += strlen (prefix);
9419 strcpy (buffer + length, get_tree_code_name ((enum tree_code) c));
9420 length += strlen (get_tree_code_name ((enum tree_code) c));
9421 }
9422
9423 internal_error ("tree check: %s, have %s in %s, at %s:%d",
9424 buffer, get_tree_code_name (TREE_CODE (node)),
9425 function, trim_filename (file), line);
9426 }
9427
9428
9429 /* Similar to tree_check_failed, except that we check that a tree does
9430 not have the specified code, given in CL. */
9431
9432 void
tree_not_class_check_failed(const_tree node,const enum tree_code_class cl,const char * file,int line,const char * function)9433 tree_not_class_check_failed (const_tree node, const enum tree_code_class cl,
9434 const char *file, int line, const char *function)
9435 {
9436 internal_error
9437 ("tree check: did not expect class %qs, have %qs (%s) in %s, at %s:%d",
9438 TREE_CODE_CLASS_STRING (cl),
9439 TREE_CODE_CLASS_STRING (TREE_CODE_CLASS (TREE_CODE (node))),
9440 get_tree_code_name (TREE_CODE (node)), function, trim_filename (file), line);
9441 }
9442
9443
9444 /* Similar to tree_check_failed but applied to OMP_CLAUSE codes. */
9445
9446 void
omp_clause_check_failed(const_tree node,const char * file,int line,const char * function,enum omp_clause_code code)9447 omp_clause_check_failed (const_tree node, const char *file, int line,
9448 const char *function, enum omp_clause_code code)
9449 {
9450 internal_error ("tree check: expected omp_clause %s, have %s in %s, at %s:%d",
9451 omp_clause_code_name[code], get_tree_code_name (TREE_CODE (node)),
9452 function, trim_filename (file), line);
9453 }
9454
9455
9456 /* Similar to tree_range_check_failed but applied to OMP_CLAUSE codes. */
9457
9458 void
omp_clause_range_check_failed(const_tree node,const char * file,int line,const char * function,enum omp_clause_code c1,enum omp_clause_code c2)9459 omp_clause_range_check_failed (const_tree node, const char *file, int line,
9460 const char *function, enum omp_clause_code c1,
9461 enum omp_clause_code c2)
9462 {
9463 char *buffer;
9464 unsigned length = 0;
9465 unsigned int c;
9466
9467 for (c = c1; c <= c2; ++c)
9468 length += 4 + strlen (omp_clause_code_name[c]);
9469
9470 length += strlen ("expected ");
9471 buffer = (char *) alloca (length);
9472 length = 0;
9473
9474 for (c = c1; c <= c2; ++c)
9475 {
9476 const char *prefix = length ? " or " : "expected ";
9477
9478 strcpy (buffer + length, prefix);
9479 length += strlen (prefix);
9480 strcpy (buffer + length, omp_clause_code_name[c]);
9481 length += strlen (omp_clause_code_name[c]);
9482 }
9483
9484 internal_error ("tree check: %s, have %s in %s, at %s:%d",
9485 buffer, omp_clause_code_name[TREE_CODE (node)],
9486 function, trim_filename (file), line);
9487 }
9488
9489
9490 #undef DEFTREESTRUCT
9491 #define DEFTREESTRUCT(VAL, NAME) NAME,
9492
9493 static const char *ts_enum_names[] = {
9494 #include "treestruct.def"
9495 };
9496 #undef DEFTREESTRUCT
9497
9498 #define TS_ENUM_NAME(EN) (ts_enum_names[(EN)])
9499
9500 /* Similar to tree_class_check_failed, except that we check for
9501 whether CODE contains the tree structure identified by EN. */
9502
9503 void
tree_contains_struct_check_failed(const_tree node,const enum tree_node_structure_enum en,const char * file,int line,const char * function)9504 tree_contains_struct_check_failed (const_tree node,
9505 const enum tree_node_structure_enum en,
9506 const char *file, int line,
9507 const char *function)
9508 {
9509 internal_error
9510 ("tree check: expected tree that contains %qs structure, have %qs in %s, at %s:%d",
9511 TS_ENUM_NAME (en),
9512 get_tree_code_name (TREE_CODE (node)), function, trim_filename (file), line);
9513 }
9514
9515
9516 /* Similar to above, except that the check is for the bounds of a TREE_VEC's
9517 (dynamically sized) vector. */
9518
9519 void
tree_int_cst_elt_check_failed(int idx,int len,const char * file,int line,const char * function)9520 tree_int_cst_elt_check_failed (int idx, int len, const char *file, int line,
9521 const char *function)
9522 {
9523 internal_error
9524 ("tree check: accessed elt %d of tree_int_cst with %d elts in %s, at %s:%d",
9525 idx + 1, len, function, trim_filename (file), line);
9526 }
9527
9528 /* Similar to above, except that the check is for the bounds of a TREE_VEC's
9529 (dynamically sized) vector. */
9530
9531 void
tree_vec_elt_check_failed(int idx,int len,const char * file,int line,const char * function)9532 tree_vec_elt_check_failed (int idx, int len, const char *file, int line,
9533 const char *function)
9534 {
9535 internal_error
9536 ("tree check: accessed elt %d of tree_vec with %d elts in %s, at %s:%d",
9537 idx + 1, len, function, trim_filename (file), line);
9538 }
9539
9540 /* Similar to above, except that the check is for the bounds of the operand
9541 vector of an expression node EXP. */
9542
9543 void
tree_operand_check_failed(int idx,const_tree exp,const char * file,int line,const char * function)9544 tree_operand_check_failed (int idx, const_tree exp, const char *file,
9545 int line, const char *function)
9546 {
9547 enum tree_code code = TREE_CODE (exp);
9548 internal_error
9549 ("tree check: accessed operand %d of %s with %d operands in %s, at %s:%d",
9550 idx + 1, get_tree_code_name (code), TREE_OPERAND_LENGTH (exp),
9551 function, trim_filename (file), line);
9552 }
9553
9554 /* Similar to above, except that the check is for the number of
9555 operands of an OMP_CLAUSE node. */
9556
9557 void
omp_clause_operand_check_failed(int idx,const_tree t,const char * file,int line,const char * function)9558 omp_clause_operand_check_failed (int idx, const_tree t, const char *file,
9559 int line, const char *function)
9560 {
9561 internal_error
9562 ("tree check: accessed operand %d of omp_clause %s with %d operands "
9563 "in %s, at %s:%d", idx + 1, omp_clause_code_name[OMP_CLAUSE_CODE (t)],
9564 omp_clause_num_ops [OMP_CLAUSE_CODE (t)], function,
9565 trim_filename (file), line);
9566 }
9567 #endif /* ENABLE_TREE_CHECKING */
9568
9569 /* Create a new vector type node holding NUNITS units of type INNERTYPE,
9570 and mapped to the machine mode MODE. Initialize its fields and build
9571 the information necessary for debugging output. */
9572
9573 static tree
make_vector_type(tree innertype,poly_int64 nunits,machine_mode mode)9574 make_vector_type (tree innertype, poly_int64 nunits, machine_mode mode)
9575 {
9576 tree t;
9577 tree mv_innertype = TYPE_MAIN_VARIANT (innertype);
9578
9579 t = make_node (VECTOR_TYPE);
9580 TREE_TYPE (t) = mv_innertype;
9581 SET_TYPE_VECTOR_SUBPARTS (t, nunits);
9582 SET_TYPE_MODE (t, mode);
9583
9584 if (TYPE_STRUCTURAL_EQUALITY_P (mv_innertype) || in_lto_p)
9585 SET_TYPE_STRUCTURAL_EQUALITY (t);
9586 else if ((TYPE_CANONICAL (mv_innertype) != innertype
9587 || mode != VOIDmode)
9588 && !VECTOR_BOOLEAN_TYPE_P (t))
9589 TYPE_CANONICAL (t)
9590 = make_vector_type (TYPE_CANONICAL (mv_innertype), nunits, VOIDmode);
9591
9592 layout_type (t);
9593
9594 hashval_t hash = type_hash_canon_hash (t);
9595 t = type_hash_canon (hash, t);
9596
9597 /* We have built a main variant, based on the main variant of the
9598 inner type. Use it to build the variant we return. */
9599 if ((TYPE_ATTRIBUTES (innertype) || TYPE_QUALS (innertype))
9600 && TREE_TYPE (t) != innertype)
9601 return build_type_attribute_qual_variant (t,
9602 TYPE_ATTRIBUTES (innertype),
9603 TYPE_QUALS (innertype));
9604
9605 return t;
9606 }
9607
9608 static tree
make_or_reuse_type(unsigned size,int unsignedp)9609 make_or_reuse_type (unsigned size, int unsignedp)
9610 {
9611 int i;
9612
9613 if (size == INT_TYPE_SIZE)
9614 return unsignedp ? unsigned_type_node : integer_type_node;
9615 if (size == CHAR_TYPE_SIZE)
9616 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
9617 if (size == SHORT_TYPE_SIZE)
9618 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
9619 if (size == LONG_TYPE_SIZE)
9620 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
9621 if (size == LONG_LONG_TYPE_SIZE)
9622 return (unsignedp ? long_long_unsigned_type_node
9623 : long_long_integer_type_node);
9624
9625 for (i = 0; i < NUM_INT_N_ENTS; i ++)
9626 if (size == int_n_data[i].bitsize
9627 && int_n_enabled_p[i])
9628 return (unsignedp ? int_n_trees[i].unsigned_type
9629 : int_n_trees[i].signed_type);
9630
9631 if (unsignedp)
9632 return make_unsigned_type (size);
9633 else
9634 return make_signed_type (size);
9635 }
9636
9637 /* Create or reuse a fract type by SIZE, UNSIGNEDP, and SATP. */
9638
9639 static tree
make_or_reuse_fract_type(unsigned size,int unsignedp,int satp)9640 make_or_reuse_fract_type (unsigned size, int unsignedp, int satp)
9641 {
9642 if (satp)
9643 {
9644 if (size == SHORT_FRACT_TYPE_SIZE)
9645 return unsignedp ? sat_unsigned_short_fract_type_node
9646 : sat_short_fract_type_node;
9647 if (size == FRACT_TYPE_SIZE)
9648 return unsignedp ? sat_unsigned_fract_type_node : sat_fract_type_node;
9649 if (size == LONG_FRACT_TYPE_SIZE)
9650 return unsignedp ? sat_unsigned_long_fract_type_node
9651 : sat_long_fract_type_node;
9652 if (size == LONG_LONG_FRACT_TYPE_SIZE)
9653 return unsignedp ? sat_unsigned_long_long_fract_type_node
9654 : sat_long_long_fract_type_node;
9655 }
9656 else
9657 {
9658 if (size == SHORT_FRACT_TYPE_SIZE)
9659 return unsignedp ? unsigned_short_fract_type_node
9660 : short_fract_type_node;
9661 if (size == FRACT_TYPE_SIZE)
9662 return unsignedp ? unsigned_fract_type_node : fract_type_node;
9663 if (size == LONG_FRACT_TYPE_SIZE)
9664 return unsignedp ? unsigned_long_fract_type_node
9665 : long_fract_type_node;
9666 if (size == LONG_LONG_FRACT_TYPE_SIZE)
9667 return unsignedp ? unsigned_long_long_fract_type_node
9668 : long_long_fract_type_node;
9669 }
9670
9671 return make_fract_type (size, unsignedp, satp);
9672 }
9673
9674 /* Create or reuse an accum type by SIZE, UNSIGNEDP, and SATP. */
9675
9676 static tree
make_or_reuse_accum_type(unsigned size,int unsignedp,int satp)9677 make_or_reuse_accum_type (unsigned size, int unsignedp, int satp)
9678 {
9679 if (satp)
9680 {
9681 if (size == SHORT_ACCUM_TYPE_SIZE)
9682 return unsignedp ? sat_unsigned_short_accum_type_node
9683 : sat_short_accum_type_node;
9684 if (size == ACCUM_TYPE_SIZE)
9685 return unsignedp ? sat_unsigned_accum_type_node : sat_accum_type_node;
9686 if (size == LONG_ACCUM_TYPE_SIZE)
9687 return unsignedp ? sat_unsigned_long_accum_type_node
9688 : sat_long_accum_type_node;
9689 if (size == LONG_LONG_ACCUM_TYPE_SIZE)
9690 return unsignedp ? sat_unsigned_long_long_accum_type_node
9691 : sat_long_long_accum_type_node;
9692 }
9693 else
9694 {
9695 if (size == SHORT_ACCUM_TYPE_SIZE)
9696 return unsignedp ? unsigned_short_accum_type_node
9697 : short_accum_type_node;
9698 if (size == ACCUM_TYPE_SIZE)
9699 return unsignedp ? unsigned_accum_type_node : accum_type_node;
9700 if (size == LONG_ACCUM_TYPE_SIZE)
9701 return unsignedp ? unsigned_long_accum_type_node
9702 : long_accum_type_node;
9703 if (size == LONG_LONG_ACCUM_TYPE_SIZE)
9704 return unsignedp ? unsigned_long_long_accum_type_node
9705 : long_long_accum_type_node;
9706 }
9707
9708 return make_accum_type (size, unsignedp, satp);
9709 }
9710
9711
9712 /* Create an atomic variant node for TYPE. This routine is called
9713 during initialization of data types to create the 5 basic atomic
9714 types. The generic build_variant_type function requires these to
9715 already be set up in order to function properly, so cannot be
9716 called from there. If ALIGN is non-zero, then ensure alignment is
9717 overridden to this value. */
9718
9719 static tree
build_atomic_base(tree type,unsigned int align)9720 build_atomic_base (tree type, unsigned int align)
9721 {
9722 tree t;
9723
9724 /* Make sure its not already registered. */
9725 if ((t = get_qualified_type (type, TYPE_QUAL_ATOMIC)))
9726 return t;
9727
9728 t = build_variant_type_copy (type);
9729 set_type_quals (t, TYPE_QUAL_ATOMIC);
9730
9731 if (align)
9732 SET_TYPE_ALIGN (t, align);
9733
9734 return t;
9735 }
9736
9737 /* Information about the _FloatN and _FloatNx types. This must be in
9738 the same order as the corresponding TI_* enum values. */
9739 const floatn_type_info floatn_nx_types[NUM_FLOATN_NX_TYPES] =
9740 {
9741 { 16, false },
9742 { 32, false },
9743 { 64, false },
9744 { 128, false },
9745 { 32, true },
9746 { 64, true },
9747 { 128, true },
9748 };
9749
9750
9751 /* Create nodes for all integer types (and error_mark_node) using the sizes
9752 of C datatypes. SIGNED_CHAR specifies whether char is signed. */
9753
9754 void
build_common_tree_nodes(bool signed_char)9755 build_common_tree_nodes (bool signed_char)
9756 {
9757 int i;
9758
9759 error_mark_node = make_node (ERROR_MARK);
9760 TREE_TYPE (error_mark_node) = error_mark_node;
9761
9762 initialize_sizetypes ();
9763
9764 /* Define both `signed char' and `unsigned char'. */
9765 signed_char_type_node = make_signed_type (CHAR_TYPE_SIZE);
9766 TYPE_STRING_FLAG (signed_char_type_node) = 1;
9767 unsigned_char_type_node = make_unsigned_type (CHAR_TYPE_SIZE);
9768 TYPE_STRING_FLAG (unsigned_char_type_node) = 1;
9769
9770 /* Define `char', which is like either `signed char' or `unsigned char'
9771 but not the same as either. */
9772 char_type_node
9773 = (signed_char
9774 ? make_signed_type (CHAR_TYPE_SIZE)
9775 : make_unsigned_type (CHAR_TYPE_SIZE));
9776 TYPE_STRING_FLAG (char_type_node) = 1;
9777
9778 short_integer_type_node = make_signed_type (SHORT_TYPE_SIZE);
9779 short_unsigned_type_node = make_unsigned_type (SHORT_TYPE_SIZE);
9780 integer_type_node = make_signed_type (INT_TYPE_SIZE);
9781 unsigned_type_node = make_unsigned_type (INT_TYPE_SIZE);
9782 long_integer_type_node = make_signed_type (LONG_TYPE_SIZE);
9783 long_unsigned_type_node = make_unsigned_type (LONG_TYPE_SIZE);
9784 long_long_integer_type_node = make_signed_type (LONG_LONG_TYPE_SIZE);
9785 long_long_unsigned_type_node = make_unsigned_type (LONG_LONG_TYPE_SIZE);
9786
9787 for (i = 0; i < NUM_INT_N_ENTS; i ++)
9788 {
9789 int_n_trees[i].signed_type = make_signed_type (int_n_data[i].bitsize);
9790 int_n_trees[i].unsigned_type = make_unsigned_type (int_n_data[i].bitsize);
9791 TYPE_SIZE (int_n_trees[i].signed_type) = bitsize_int (int_n_data[i].bitsize);
9792 TYPE_SIZE (int_n_trees[i].unsigned_type) = bitsize_int (int_n_data[i].bitsize);
9793
9794 if (int_n_enabled_p[i])
9795 {
9796 integer_types[itk_intN_0 + i * 2] = int_n_trees[i].signed_type;
9797 integer_types[itk_unsigned_intN_0 + i * 2] = int_n_trees[i].unsigned_type;
9798 }
9799 }
9800
9801 /* Define a boolean type. This type only represents boolean values but
9802 may be larger than char depending on the value of BOOL_TYPE_SIZE. */
9803 boolean_type_node = make_unsigned_type (BOOL_TYPE_SIZE);
9804 TREE_SET_CODE (boolean_type_node, BOOLEAN_TYPE);
9805 TYPE_PRECISION (boolean_type_node) = 1;
9806 TYPE_MAX_VALUE (boolean_type_node) = build_int_cst (boolean_type_node, 1);
9807
9808 /* Define what type to use for size_t. */
9809 if (strcmp (SIZE_TYPE, "unsigned int") == 0)
9810 size_type_node = unsigned_type_node;
9811 else if (strcmp (SIZE_TYPE, "long unsigned int") == 0)
9812 size_type_node = long_unsigned_type_node;
9813 else if (strcmp (SIZE_TYPE, "long long unsigned int") == 0)
9814 size_type_node = long_long_unsigned_type_node;
9815 else if (strcmp (SIZE_TYPE, "short unsigned int") == 0)
9816 size_type_node = short_unsigned_type_node;
9817 else
9818 {
9819 int i;
9820
9821 size_type_node = NULL_TREE;
9822 for (i = 0; i < NUM_INT_N_ENTS; i++)
9823 if (int_n_enabled_p[i])
9824 {
9825 char name[50];
9826 sprintf (name, "__int%d unsigned", int_n_data[i].bitsize);
9827
9828 if (strcmp (name, SIZE_TYPE) == 0)
9829 {
9830 size_type_node = int_n_trees[i].unsigned_type;
9831 }
9832 }
9833 if (size_type_node == NULL_TREE)
9834 gcc_unreachable ();
9835 }
9836
9837 /* Define what type to use for ptrdiff_t. */
9838 if (strcmp (PTRDIFF_TYPE, "int") == 0)
9839 ptrdiff_type_node = integer_type_node;
9840 else if (strcmp (PTRDIFF_TYPE, "long int") == 0)
9841 ptrdiff_type_node = long_integer_type_node;
9842 else if (strcmp (PTRDIFF_TYPE, "long long int") == 0)
9843 ptrdiff_type_node = long_long_integer_type_node;
9844 else if (strcmp (PTRDIFF_TYPE, "short int") == 0)
9845 ptrdiff_type_node = short_integer_type_node;
9846 else
9847 {
9848 ptrdiff_type_node = NULL_TREE;
9849 for (int i = 0; i < NUM_INT_N_ENTS; i++)
9850 if (int_n_enabled_p[i])
9851 {
9852 char name[50];
9853 sprintf (name, "__int%d", int_n_data[i].bitsize);
9854 if (strcmp (name, PTRDIFF_TYPE) == 0)
9855 ptrdiff_type_node = int_n_trees[i].signed_type;
9856 }
9857 if (ptrdiff_type_node == NULL_TREE)
9858 gcc_unreachable ();
9859 }
9860
9861 /* Fill in the rest of the sized types. Reuse existing type nodes
9862 when possible. */
9863 intQI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (QImode), 0);
9864 intHI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (HImode), 0);
9865 intSI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (SImode), 0);
9866 intDI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (DImode), 0);
9867 intTI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (TImode), 0);
9868
9869 unsigned_intQI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (QImode), 1);
9870 unsigned_intHI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (HImode), 1);
9871 unsigned_intSI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (SImode), 1);
9872 unsigned_intDI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (DImode), 1);
9873 unsigned_intTI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (TImode), 1);
9874
9875 /* Don't call build_qualified type for atomics. That routine does
9876 special processing for atomics, and until they are initialized
9877 it's better not to make that call.
9878
9879 Check to see if there is a target override for atomic types. */
9880
9881 atomicQI_type_node = build_atomic_base (unsigned_intQI_type_node,
9882 targetm.atomic_align_for_mode (QImode));
9883 atomicHI_type_node = build_atomic_base (unsigned_intHI_type_node,
9884 targetm.atomic_align_for_mode (HImode));
9885 atomicSI_type_node = build_atomic_base (unsigned_intSI_type_node,
9886 targetm.atomic_align_for_mode (SImode));
9887 atomicDI_type_node = build_atomic_base (unsigned_intDI_type_node,
9888 targetm.atomic_align_for_mode (DImode));
9889 atomicTI_type_node = build_atomic_base (unsigned_intTI_type_node,
9890 targetm.atomic_align_for_mode (TImode));
9891
9892 access_public_node = get_identifier ("public");
9893 access_protected_node = get_identifier ("protected");
9894 access_private_node = get_identifier ("private");
9895
9896 /* Define these next since types below may used them. */
9897 integer_zero_node = build_int_cst (integer_type_node, 0);
9898 integer_one_node = build_int_cst (integer_type_node, 1);
9899 integer_three_node = build_int_cst (integer_type_node, 3);
9900 integer_minus_one_node = build_int_cst (integer_type_node, -1);
9901
9902 size_zero_node = size_int (0);
9903 size_one_node = size_int (1);
9904 bitsize_zero_node = bitsize_int (0);
9905 bitsize_one_node = bitsize_int (1);
9906 bitsize_unit_node = bitsize_int (BITS_PER_UNIT);
9907
9908 boolean_false_node = TYPE_MIN_VALUE (boolean_type_node);
9909 boolean_true_node = TYPE_MAX_VALUE (boolean_type_node);
9910
9911 void_type_node = make_node (VOID_TYPE);
9912 layout_type (void_type_node);
9913
9914 pointer_bounds_type_node = targetm.chkp_bound_type ();
9915
9916 /* We are not going to have real types in C with less than byte alignment,
9917 so we might as well not have any types that claim to have it. */
9918 SET_TYPE_ALIGN (void_type_node, BITS_PER_UNIT);
9919 TYPE_USER_ALIGN (void_type_node) = 0;
9920
9921 void_node = make_node (VOID_CST);
9922 TREE_TYPE (void_node) = void_type_node;
9923
9924 null_pointer_node = build_int_cst (build_pointer_type (void_type_node), 0);
9925 layout_type (TREE_TYPE (null_pointer_node));
9926
9927 ptr_type_node = build_pointer_type (void_type_node);
9928 const_ptr_type_node
9929 = build_pointer_type (build_type_variant (void_type_node, 1, 0));
9930 for (unsigned i = 0;
9931 i < sizeof (builtin_structptr_types) / sizeof (builtin_structptr_type);
9932 ++i)
9933 builtin_structptr_types[i].node = builtin_structptr_types[i].base;
9934
9935 pointer_sized_int_node = build_nonstandard_integer_type (POINTER_SIZE, 1);
9936
9937 float_type_node = make_node (REAL_TYPE);
9938 TYPE_PRECISION (float_type_node) = FLOAT_TYPE_SIZE;
9939 layout_type (float_type_node);
9940
9941 double_type_node = make_node (REAL_TYPE);
9942 TYPE_PRECISION (double_type_node) = DOUBLE_TYPE_SIZE;
9943 layout_type (double_type_node);
9944
9945 long_double_type_node = make_node (REAL_TYPE);
9946 TYPE_PRECISION (long_double_type_node) = LONG_DOUBLE_TYPE_SIZE;
9947 layout_type (long_double_type_node);
9948
9949 for (i = 0; i < NUM_FLOATN_NX_TYPES; i++)
9950 {
9951 int n = floatn_nx_types[i].n;
9952 bool extended = floatn_nx_types[i].extended;
9953 scalar_float_mode mode;
9954 if (!targetm.floatn_mode (n, extended).exists (&mode))
9955 continue;
9956 int precision = GET_MODE_PRECISION (mode);
9957 /* Work around the rs6000 KFmode having precision 113 not
9958 128. */
9959 const struct real_format *fmt = REAL_MODE_FORMAT (mode);
9960 gcc_assert (fmt->b == 2 && fmt->emin + fmt->emax == 3);
9961 int min_precision = fmt->p + ceil_log2 (fmt->emax - fmt->emin);
9962 if (!extended)
9963 gcc_assert (min_precision == n);
9964 if (precision < min_precision)
9965 precision = min_precision;
9966 FLOATN_NX_TYPE_NODE (i) = make_node (REAL_TYPE);
9967 TYPE_PRECISION (FLOATN_NX_TYPE_NODE (i)) = precision;
9968 layout_type (FLOATN_NX_TYPE_NODE (i));
9969 SET_TYPE_MODE (FLOATN_NX_TYPE_NODE (i), mode);
9970 }
9971
9972 float_ptr_type_node = build_pointer_type (float_type_node);
9973 double_ptr_type_node = build_pointer_type (double_type_node);
9974 long_double_ptr_type_node = build_pointer_type (long_double_type_node);
9975 integer_ptr_type_node = build_pointer_type (integer_type_node);
9976
9977 /* Fixed size integer types. */
9978 uint16_type_node = make_or_reuse_type (16, 1);
9979 uint32_type_node = make_or_reuse_type (32, 1);
9980 uint64_type_node = make_or_reuse_type (64, 1);
9981
9982 /* Decimal float types. */
9983 dfloat32_type_node = make_node (REAL_TYPE);
9984 TYPE_PRECISION (dfloat32_type_node) = DECIMAL32_TYPE_SIZE;
9985 SET_TYPE_MODE (dfloat32_type_node, SDmode);
9986 layout_type (dfloat32_type_node);
9987 dfloat32_ptr_type_node = build_pointer_type (dfloat32_type_node);
9988
9989 dfloat64_type_node = make_node (REAL_TYPE);
9990 TYPE_PRECISION (dfloat64_type_node) = DECIMAL64_TYPE_SIZE;
9991 SET_TYPE_MODE (dfloat64_type_node, DDmode);
9992 layout_type (dfloat64_type_node);
9993 dfloat64_ptr_type_node = build_pointer_type (dfloat64_type_node);
9994
9995 dfloat128_type_node = make_node (REAL_TYPE);
9996 TYPE_PRECISION (dfloat128_type_node) = DECIMAL128_TYPE_SIZE;
9997 SET_TYPE_MODE (dfloat128_type_node, TDmode);
9998 layout_type (dfloat128_type_node);
9999 dfloat128_ptr_type_node = build_pointer_type (dfloat128_type_node);
10000
10001 complex_integer_type_node = build_complex_type (integer_type_node, true);
10002 complex_float_type_node = build_complex_type (float_type_node, true);
10003 complex_double_type_node = build_complex_type (double_type_node, true);
10004 complex_long_double_type_node = build_complex_type (long_double_type_node,
10005 true);
10006
10007 for (i = 0; i < NUM_FLOATN_NX_TYPES; i++)
10008 {
10009 if (FLOATN_NX_TYPE_NODE (i) != NULL_TREE)
10010 COMPLEX_FLOATN_NX_TYPE_NODE (i)
10011 = build_complex_type (FLOATN_NX_TYPE_NODE (i));
10012 }
10013
10014 /* Make fixed-point nodes based on sat/non-sat and signed/unsigned. */
10015 #define MAKE_FIXED_TYPE_NODE(KIND,SIZE) \
10016 sat_ ## KIND ## _type_node = \
10017 make_sat_signed_ ## KIND ## _type (SIZE); \
10018 sat_unsigned_ ## KIND ## _type_node = \
10019 make_sat_unsigned_ ## KIND ## _type (SIZE); \
10020 KIND ## _type_node = make_signed_ ## KIND ## _type (SIZE); \
10021 unsigned_ ## KIND ## _type_node = \
10022 make_unsigned_ ## KIND ## _type (SIZE);
10023
10024 #define MAKE_FIXED_TYPE_NODE_WIDTH(KIND,WIDTH,SIZE) \
10025 sat_ ## WIDTH ## KIND ## _type_node = \
10026 make_sat_signed_ ## KIND ## _type (SIZE); \
10027 sat_unsigned_ ## WIDTH ## KIND ## _type_node = \
10028 make_sat_unsigned_ ## KIND ## _type (SIZE); \
10029 WIDTH ## KIND ## _type_node = make_signed_ ## KIND ## _type (SIZE); \
10030 unsigned_ ## WIDTH ## KIND ## _type_node = \
10031 make_unsigned_ ## KIND ## _type (SIZE);
10032
10033 /* Make fixed-point type nodes based on four different widths. */
10034 #define MAKE_FIXED_TYPE_NODE_FAMILY(N1,N2) \
10035 MAKE_FIXED_TYPE_NODE_WIDTH (N1, short_, SHORT_ ## N2 ## _TYPE_SIZE) \
10036 MAKE_FIXED_TYPE_NODE (N1, N2 ## _TYPE_SIZE) \
10037 MAKE_FIXED_TYPE_NODE_WIDTH (N1, long_, LONG_ ## N2 ## _TYPE_SIZE) \
10038 MAKE_FIXED_TYPE_NODE_WIDTH (N1, long_long_, LONG_LONG_ ## N2 ## _TYPE_SIZE)
10039
10040 /* Make fixed-point mode nodes based on sat/non-sat and signed/unsigned. */
10041 #define MAKE_FIXED_MODE_NODE(KIND,NAME,MODE) \
10042 NAME ## _type_node = \
10043 make_or_reuse_signed_ ## KIND ## _type (GET_MODE_BITSIZE (MODE ## mode)); \
10044 u ## NAME ## _type_node = \
10045 make_or_reuse_unsigned_ ## KIND ## _type \
10046 (GET_MODE_BITSIZE (U ## MODE ## mode)); \
10047 sat_ ## NAME ## _type_node = \
10048 make_or_reuse_sat_signed_ ## KIND ## _type \
10049 (GET_MODE_BITSIZE (MODE ## mode)); \
10050 sat_u ## NAME ## _type_node = \
10051 make_or_reuse_sat_unsigned_ ## KIND ## _type \
10052 (GET_MODE_BITSIZE (U ## MODE ## mode));
10053
10054 /* Fixed-point type and mode nodes. */
10055 MAKE_FIXED_TYPE_NODE_FAMILY (fract, FRACT)
10056 MAKE_FIXED_TYPE_NODE_FAMILY (accum, ACCUM)
10057 MAKE_FIXED_MODE_NODE (fract, qq, QQ)
10058 MAKE_FIXED_MODE_NODE (fract, hq, HQ)
10059 MAKE_FIXED_MODE_NODE (fract, sq, SQ)
10060 MAKE_FIXED_MODE_NODE (fract, dq, DQ)
10061 MAKE_FIXED_MODE_NODE (fract, tq, TQ)
10062 MAKE_FIXED_MODE_NODE (accum, ha, HA)
10063 MAKE_FIXED_MODE_NODE (accum, sa, SA)
10064 MAKE_FIXED_MODE_NODE (accum, da, DA)
10065 MAKE_FIXED_MODE_NODE (accum, ta, TA)
10066
10067 {
10068 tree t = targetm.build_builtin_va_list ();
10069
10070 /* Many back-ends define record types without setting TYPE_NAME.
10071 If we copied the record type here, we'd keep the original
10072 record type without a name. This breaks name mangling. So,
10073 don't copy record types and let c_common_nodes_and_builtins()
10074 declare the type to be __builtin_va_list. */
10075 if (TREE_CODE (t) != RECORD_TYPE)
10076 t = build_variant_type_copy (t);
10077
10078 va_list_type_node = t;
10079 }
10080 }
10081
10082 /* Modify DECL for given flags.
10083 TM_PURE attribute is set only on types, so the function will modify
10084 DECL's type when ECF_TM_PURE is used. */
10085
10086 void
set_call_expr_flags(tree decl,int flags)10087 set_call_expr_flags (tree decl, int flags)
10088 {
10089 if (flags & ECF_NOTHROW)
10090 TREE_NOTHROW (decl) = 1;
10091 if (flags & ECF_CONST)
10092 TREE_READONLY (decl) = 1;
10093 if (flags & ECF_PURE)
10094 DECL_PURE_P (decl) = 1;
10095 if (flags & ECF_LOOPING_CONST_OR_PURE)
10096 DECL_LOOPING_CONST_OR_PURE_P (decl) = 1;
10097 if (flags & ECF_NOVOPS)
10098 DECL_IS_NOVOPS (decl) = 1;
10099 if (flags & ECF_NORETURN)
10100 TREE_THIS_VOLATILE (decl) = 1;
10101 if (flags & ECF_MALLOC)
10102 DECL_IS_MALLOC (decl) = 1;
10103 if (flags & ECF_RETURNS_TWICE)
10104 DECL_IS_RETURNS_TWICE (decl) = 1;
10105 if (flags & ECF_LEAF)
10106 DECL_ATTRIBUTES (decl) = tree_cons (get_identifier ("leaf"),
10107 NULL, DECL_ATTRIBUTES (decl));
10108 if (flags & ECF_COLD)
10109 DECL_ATTRIBUTES (decl) = tree_cons (get_identifier ("cold"),
10110 NULL, DECL_ATTRIBUTES (decl));
10111 if (flags & ECF_RET1)
10112 DECL_ATTRIBUTES (decl)
10113 = tree_cons (get_identifier ("fn spec"),
10114 build_tree_list (NULL_TREE, build_string (1, "1")),
10115 DECL_ATTRIBUTES (decl));
10116 if ((flags & ECF_TM_PURE) && flag_tm)
10117 apply_tm_attr (decl, get_identifier ("transaction_pure"));
10118 /* Looping const or pure is implied by noreturn.
10119 There is currently no way to declare looping const or looping pure alone. */
10120 gcc_assert (!(flags & ECF_LOOPING_CONST_OR_PURE)
10121 || ((flags & ECF_NORETURN) && (flags & (ECF_CONST | ECF_PURE))));
10122 }
10123
10124
10125 /* A subroutine of build_common_builtin_nodes. Define a builtin function. */
10126
10127 static void
local_define_builtin(const char * name,tree type,enum built_in_function code,const char * library_name,int ecf_flags)10128 local_define_builtin (const char *name, tree type, enum built_in_function code,
10129 const char *library_name, int ecf_flags)
10130 {
10131 tree decl;
10132
10133 decl = add_builtin_function (name, type, code, BUILT_IN_NORMAL,
10134 library_name, NULL_TREE);
10135 set_call_expr_flags (decl, ecf_flags);
10136
10137 set_builtin_decl (code, decl, true);
10138 }
10139
10140 /* Call this function after instantiating all builtins that the language
10141 front end cares about. This will build the rest of the builtins
10142 and internal functions that are relied upon by the tree optimizers and
10143 the middle-end. */
10144
10145 void
build_common_builtin_nodes(void)10146 build_common_builtin_nodes (void)
10147 {
10148 tree tmp, ftype;
10149 int ecf_flags;
10150
10151 if (!builtin_decl_explicit_p (BUILT_IN_UNREACHABLE)
10152 || !builtin_decl_explicit_p (BUILT_IN_ABORT))
10153 {
10154 ftype = build_function_type (void_type_node, void_list_node);
10155 if (!builtin_decl_explicit_p (BUILT_IN_UNREACHABLE))
10156 local_define_builtin ("__builtin_unreachable", ftype,
10157 BUILT_IN_UNREACHABLE,
10158 "__builtin_unreachable",
10159 ECF_NOTHROW | ECF_LEAF | ECF_NORETURN
10160 | ECF_CONST | ECF_COLD);
10161 if (!builtin_decl_explicit_p (BUILT_IN_ABORT))
10162 local_define_builtin ("__builtin_abort", ftype, BUILT_IN_ABORT,
10163 "abort",
10164 ECF_LEAF | ECF_NORETURN | ECF_CONST | ECF_COLD);
10165 }
10166
10167 if (!builtin_decl_explicit_p (BUILT_IN_MEMCPY)
10168 || !builtin_decl_explicit_p (BUILT_IN_MEMMOVE))
10169 {
10170 ftype = build_function_type_list (ptr_type_node,
10171 ptr_type_node, const_ptr_type_node,
10172 size_type_node, NULL_TREE);
10173
10174 if (!builtin_decl_explicit_p (BUILT_IN_MEMCPY))
10175 local_define_builtin ("__builtin_memcpy", ftype, BUILT_IN_MEMCPY,
10176 "memcpy", ECF_NOTHROW | ECF_LEAF | ECF_RET1);
10177 if (!builtin_decl_explicit_p (BUILT_IN_MEMMOVE))
10178 local_define_builtin ("__builtin_memmove", ftype, BUILT_IN_MEMMOVE,
10179 "memmove", ECF_NOTHROW | ECF_LEAF | ECF_RET1);
10180 }
10181
10182 if (!builtin_decl_explicit_p (BUILT_IN_MEMCMP))
10183 {
10184 ftype = build_function_type_list (integer_type_node, const_ptr_type_node,
10185 const_ptr_type_node, size_type_node,
10186 NULL_TREE);
10187 local_define_builtin ("__builtin_memcmp", ftype, BUILT_IN_MEMCMP,
10188 "memcmp", ECF_PURE | ECF_NOTHROW | ECF_LEAF);
10189 }
10190
10191 if (!builtin_decl_explicit_p (BUILT_IN_MEMSET))
10192 {
10193 ftype = build_function_type_list (ptr_type_node,
10194 ptr_type_node, integer_type_node,
10195 size_type_node, NULL_TREE);
10196 local_define_builtin ("__builtin_memset", ftype, BUILT_IN_MEMSET,
10197 "memset", ECF_NOTHROW | ECF_LEAF | ECF_RET1);
10198 }
10199
10200 /* If we're checking the stack, `alloca' can throw. */
10201 const int alloca_flags
10202 = ECF_MALLOC | ECF_LEAF | (flag_stack_check ? 0 : ECF_NOTHROW);
10203
10204 if (!builtin_decl_explicit_p (BUILT_IN_ALLOCA))
10205 {
10206 ftype = build_function_type_list (ptr_type_node,
10207 size_type_node, NULL_TREE);
10208 local_define_builtin ("__builtin_alloca", ftype, BUILT_IN_ALLOCA,
10209 "alloca", alloca_flags);
10210 }
10211
10212 ftype = build_function_type_list (ptr_type_node, size_type_node,
10213 size_type_node, NULL_TREE);
10214 local_define_builtin ("__builtin_alloca_with_align", ftype,
10215 BUILT_IN_ALLOCA_WITH_ALIGN,
10216 "__builtin_alloca_with_align",
10217 alloca_flags);
10218
10219 ftype = build_function_type_list (ptr_type_node, size_type_node,
10220 size_type_node, size_type_node, NULL_TREE);
10221 local_define_builtin ("__builtin_alloca_with_align_and_max", ftype,
10222 BUILT_IN_ALLOCA_WITH_ALIGN_AND_MAX,
10223 "__builtin_alloca_with_align_and_max",
10224 alloca_flags);
10225
10226 ftype = build_function_type_list (void_type_node,
10227 ptr_type_node, ptr_type_node,
10228 ptr_type_node, NULL_TREE);
10229 local_define_builtin ("__builtin_init_trampoline", ftype,
10230 BUILT_IN_INIT_TRAMPOLINE,
10231 "__builtin_init_trampoline", ECF_NOTHROW | ECF_LEAF);
10232 local_define_builtin ("__builtin_init_heap_trampoline", ftype,
10233 BUILT_IN_INIT_HEAP_TRAMPOLINE,
10234 "__builtin_init_heap_trampoline",
10235 ECF_NOTHROW | ECF_LEAF);
10236 local_define_builtin ("__builtin_init_descriptor", ftype,
10237 BUILT_IN_INIT_DESCRIPTOR,
10238 "__builtin_init_descriptor", ECF_NOTHROW | ECF_LEAF);
10239
10240 ftype = build_function_type_list (ptr_type_node, ptr_type_node, NULL_TREE);
10241 local_define_builtin ("__builtin_adjust_trampoline", ftype,
10242 BUILT_IN_ADJUST_TRAMPOLINE,
10243 "__builtin_adjust_trampoline",
10244 ECF_CONST | ECF_NOTHROW);
10245 local_define_builtin ("__builtin_adjust_descriptor", ftype,
10246 BUILT_IN_ADJUST_DESCRIPTOR,
10247 "__builtin_adjust_descriptor",
10248 ECF_CONST | ECF_NOTHROW);
10249
10250 ftype = build_function_type_list (void_type_node,
10251 ptr_type_node, ptr_type_node, NULL_TREE);
10252 local_define_builtin ("__builtin_nonlocal_goto", ftype,
10253 BUILT_IN_NONLOCAL_GOTO,
10254 "__builtin_nonlocal_goto",
10255 ECF_NORETURN | ECF_NOTHROW);
10256
10257 ftype = build_function_type_list (void_type_node,
10258 ptr_type_node, ptr_type_node, NULL_TREE);
10259 local_define_builtin ("__builtin_setjmp_setup", ftype,
10260 BUILT_IN_SETJMP_SETUP,
10261 "__builtin_setjmp_setup", ECF_NOTHROW);
10262
10263 ftype = build_function_type_list (void_type_node, ptr_type_node, NULL_TREE);
10264 local_define_builtin ("__builtin_setjmp_receiver", ftype,
10265 BUILT_IN_SETJMP_RECEIVER,
10266 "__builtin_setjmp_receiver", ECF_NOTHROW | ECF_LEAF);
10267
10268 ftype = build_function_type_list (ptr_type_node, NULL_TREE);
10269 local_define_builtin ("__builtin_stack_save", ftype, BUILT_IN_STACK_SAVE,
10270 "__builtin_stack_save", ECF_NOTHROW | ECF_LEAF);
10271
10272 ftype = build_function_type_list (void_type_node, ptr_type_node, NULL_TREE);
10273 local_define_builtin ("__builtin_stack_restore", ftype,
10274 BUILT_IN_STACK_RESTORE,
10275 "__builtin_stack_restore", ECF_NOTHROW | ECF_LEAF);
10276
10277 ftype = build_function_type_list (integer_type_node, const_ptr_type_node,
10278 const_ptr_type_node, size_type_node,
10279 NULL_TREE);
10280 local_define_builtin ("__builtin_memcmp_eq", ftype, BUILT_IN_MEMCMP_EQ,
10281 "__builtin_memcmp_eq",
10282 ECF_PURE | ECF_NOTHROW | ECF_LEAF);
10283
10284 /* If there's a possibility that we might use the ARM EABI, build the
10285 alternate __cxa_end_cleanup node used to resume from C++. */
10286 if (targetm.arm_eabi_unwinder)
10287 {
10288 ftype = build_function_type_list (void_type_node, NULL_TREE);
10289 local_define_builtin ("__builtin_cxa_end_cleanup", ftype,
10290 BUILT_IN_CXA_END_CLEANUP,
10291 "__cxa_end_cleanup", ECF_NORETURN | ECF_LEAF);
10292 }
10293
10294 ftype = build_function_type_list (void_type_node, ptr_type_node, NULL_TREE);
10295 local_define_builtin ("__builtin_unwind_resume", ftype,
10296 BUILT_IN_UNWIND_RESUME,
10297 ((targetm_common.except_unwind_info (&global_options)
10298 == UI_SJLJ)
10299 ? "_Unwind_SjLj_Resume" : "_Unwind_Resume"),
10300 ECF_NORETURN);
10301
10302 if (builtin_decl_explicit (BUILT_IN_RETURN_ADDRESS) == NULL_TREE)
10303 {
10304 ftype = build_function_type_list (ptr_type_node, integer_type_node,
10305 NULL_TREE);
10306 local_define_builtin ("__builtin_return_address", ftype,
10307 BUILT_IN_RETURN_ADDRESS,
10308 "__builtin_return_address",
10309 ECF_NOTHROW);
10310 }
10311
10312 if (!builtin_decl_explicit_p (BUILT_IN_PROFILE_FUNC_ENTER)
10313 || !builtin_decl_explicit_p (BUILT_IN_PROFILE_FUNC_EXIT))
10314 {
10315 ftype = build_function_type_list (void_type_node, ptr_type_node,
10316 ptr_type_node, NULL_TREE);
10317 if (!builtin_decl_explicit_p (BUILT_IN_PROFILE_FUNC_ENTER))
10318 local_define_builtin ("__cyg_profile_func_enter", ftype,
10319 BUILT_IN_PROFILE_FUNC_ENTER,
10320 "__cyg_profile_func_enter", 0);
10321 if (!builtin_decl_explicit_p (BUILT_IN_PROFILE_FUNC_EXIT))
10322 local_define_builtin ("__cyg_profile_func_exit", ftype,
10323 BUILT_IN_PROFILE_FUNC_EXIT,
10324 "__cyg_profile_func_exit", 0);
10325 }
10326
10327 /* The exception object and filter values from the runtime. The argument
10328 must be zero before exception lowering, i.e. from the front end. After
10329 exception lowering, it will be the region number for the exception
10330 landing pad. These functions are PURE instead of CONST to prevent
10331 them from being hoisted past the exception edge that will initialize
10332 its value in the landing pad. */
10333 ftype = build_function_type_list (ptr_type_node,
10334 integer_type_node, NULL_TREE);
10335 ecf_flags = ECF_PURE | ECF_NOTHROW | ECF_LEAF;
10336 /* Only use TM_PURE if we have TM language support. */
10337 if (builtin_decl_explicit_p (BUILT_IN_TM_LOAD_1))
10338 ecf_flags |= ECF_TM_PURE;
10339 local_define_builtin ("__builtin_eh_pointer", ftype, BUILT_IN_EH_POINTER,
10340 "__builtin_eh_pointer", ecf_flags);
10341
10342 tmp = lang_hooks.types.type_for_mode (targetm.eh_return_filter_mode (), 0);
10343 ftype = build_function_type_list (tmp, integer_type_node, NULL_TREE);
10344 local_define_builtin ("__builtin_eh_filter", ftype, BUILT_IN_EH_FILTER,
10345 "__builtin_eh_filter", ECF_PURE | ECF_NOTHROW | ECF_LEAF);
10346
10347 ftype = build_function_type_list (void_type_node,
10348 integer_type_node, integer_type_node,
10349 NULL_TREE);
10350 local_define_builtin ("__builtin_eh_copy_values", ftype,
10351 BUILT_IN_EH_COPY_VALUES,
10352 "__builtin_eh_copy_values", ECF_NOTHROW);
10353
10354 /* Complex multiplication and division. These are handled as builtins
10355 rather than optabs because emit_library_call_value doesn't support
10356 complex. Further, we can do slightly better with folding these
10357 beasties if the real and complex parts of the arguments are separate. */
10358 {
10359 int mode;
10360
10361 for (mode = MIN_MODE_COMPLEX_FLOAT; mode <= MAX_MODE_COMPLEX_FLOAT; ++mode)
10362 {
10363 char mode_name_buf[4], *q;
10364 const char *p;
10365 enum built_in_function mcode, dcode;
10366 tree type, inner_type;
10367 const char *prefix = "__";
10368
10369 if (targetm.libfunc_gnu_prefix)
10370 prefix = "__gnu_";
10371
10372 type = lang_hooks.types.type_for_mode ((machine_mode) mode, 0);
10373 if (type == NULL)
10374 continue;
10375 inner_type = TREE_TYPE (type);
10376
10377 ftype = build_function_type_list (type, inner_type, inner_type,
10378 inner_type, inner_type, NULL_TREE);
10379
10380 mcode = ((enum built_in_function)
10381 (BUILT_IN_COMPLEX_MUL_MIN + mode - MIN_MODE_COMPLEX_FLOAT));
10382 dcode = ((enum built_in_function)
10383 (BUILT_IN_COMPLEX_DIV_MIN + mode - MIN_MODE_COMPLEX_FLOAT));
10384
10385 for (p = GET_MODE_NAME (mode), q = mode_name_buf; *p; p++, q++)
10386 *q = TOLOWER (*p);
10387 *q = '\0';
10388
10389 built_in_names[mcode] = concat (prefix, "mul", mode_name_buf, "3",
10390 NULL);
10391 local_define_builtin (built_in_names[mcode], ftype, mcode,
10392 built_in_names[mcode],
10393 ECF_CONST | ECF_NOTHROW | ECF_LEAF);
10394
10395 built_in_names[dcode] = concat (prefix, "div", mode_name_buf, "3",
10396 NULL);
10397 local_define_builtin (built_in_names[dcode], ftype, dcode,
10398 built_in_names[dcode],
10399 ECF_CONST | ECF_NOTHROW | ECF_LEAF);
10400 }
10401 }
10402
10403 init_internal_fns ();
10404 }
10405
10406 /* HACK. GROSS. This is absolutely disgusting. I wish there was a
10407 better way.
10408
10409 If we requested a pointer to a vector, build up the pointers that
10410 we stripped off while looking for the inner type. Similarly for
10411 return values from functions.
10412
10413 The argument TYPE is the top of the chain, and BOTTOM is the
10414 new type which we will point to. */
10415
10416 tree
reconstruct_complex_type(tree type,tree bottom)10417 reconstruct_complex_type (tree type, tree bottom)
10418 {
10419 tree inner, outer;
10420
10421 if (TREE_CODE (type) == POINTER_TYPE)
10422 {
10423 inner = reconstruct_complex_type (TREE_TYPE (type), bottom);
10424 outer = build_pointer_type_for_mode (inner, TYPE_MODE (type),
10425 TYPE_REF_CAN_ALIAS_ALL (type));
10426 }
10427 else if (TREE_CODE (type) == REFERENCE_TYPE)
10428 {
10429 inner = reconstruct_complex_type (TREE_TYPE (type), bottom);
10430 outer = build_reference_type_for_mode (inner, TYPE_MODE (type),
10431 TYPE_REF_CAN_ALIAS_ALL (type));
10432 }
10433 else if (TREE_CODE (type) == ARRAY_TYPE)
10434 {
10435 inner = reconstruct_complex_type (TREE_TYPE (type), bottom);
10436 outer = build_array_type (inner, TYPE_DOMAIN (type));
10437 }
10438 else if (TREE_CODE (type) == FUNCTION_TYPE)
10439 {
10440 inner = reconstruct_complex_type (TREE_TYPE (type), bottom);
10441 outer = build_function_type (inner, TYPE_ARG_TYPES (type));
10442 }
10443 else if (TREE_CODE (type) == METHOD_TYPE)
10444 {
10445 inner = reconstruct_complex_type (TREE_TYPE (type), bottom);
10446 /* The build_method_type_directly() routine prepends 'this' to argument list,
10447 so we must compensate by getting rid of it. */
10448 outer
10449 = build_method_type_directly
10450 (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (type))),
10451 inner,
10452 TREE_CHAIN (TYPE_ARG_TYPES (type)));
10453 }
10454 else if (TREE_CODE (type) == OFFSET_TYPE)
10455 {
10456 inner = reconstruct_complex_type (TREE_TYPE (type), bottom);
10457 outer = build_offset_type (TYPE_OFFSET_BASETYPE (type), inner);
10458 }
10459 else
10460 return bottom;
10461
10462 return build_type_attribute_qual_variant (outer, TYPE_ATTRIBUTES (type),
10463 TYPE_QUALS (type));
10464 }
10465
10466 /* Returns a vector tree node given a mode (integer, vector, or BLKmode) and
10467 the inner type. */
10468 tree
build_vector_type_for_mode(tree innertype,machine_mode mode)10469 build_vector_type_for_mode (tree innertype, machine_mode mode)
10470 {
10471 poly_int64 nunits;
10472 unsigned int bitsize;
10473
10474 switch (GET_MODE_CLASS (mode))
10475 {
10476 case MODE_VECTOR_BOOL:
10477 case MODE_VECTOR_INT:
10478 case MODE_VECTOR_FLOAT:
10479 case MODE_VECTOR_FRACT:
10480 case MODE_VECTOR_UFRACT:
10481 case MODE_VECTOR_ACCUM:
10482 case MODE_VECTOR_UACCUM:
10483 nunits = GET_MODE_NUNITS (mode);
10484 break;
10485
10486 case MODE_INT:
10487 /* Check that there are no leftover bits. */
10488 bitsize = GET_MODE_BITSIZE (as_a <scalar_int_mode> (mode));
10489 gcc_assert (bitsize % TREE_INT_CST_LOW (TYPE_SIZE (innertype)) == 0);
10490 nunits = bitsize / TREE_INT_CST_LOW (TYPE_SIZE (innertype));
10491 break;
10492
10493 default:
10494 gcc_unreachable ();
10495 }
10496
10497 return make_vector_type (innertype, nunits, mode);
10498 }
10499
10500 /* Similarly, but takes the inner type and number of units, which must be
10501 a power of two. */
10502
10503 tree
build_vector_type(tree innertype,poly_int64 nunits)10504 build_vector_type (tree innertype, poly_int64 nunits)
10505 {
10506 return make_vector_type (innertype, nunits, VOIDmode);
10507 }
10508
10509 /* Build truth vector with specified length and number of units. */
10510
10511 tree
build_truth_vector_type(poly_uint64 nunits,poly_uint64 vector_size)10512 build_truth_vector_type (poly_uint64 nunits, poly_uint64 vector_size)
10513 {
10514 machine_mode mask_mode
10515 = targetm.vectorize.get_mask_mode (nunits, vector_size).else_blk ();
10516
10517 poly_uint64 vsize;
10518 if (mask_mode == BLKmode)
10519 vsize = vector_size * BITS_PER_UNIT;
10520 else
10521 vsize = GET_MODE_BITSIZE (mask_mode);
10522
10523 unsigned HOST_WIDE_INT esize = vector_element_size (vsize, nunits);
10524
10525 tree bool_type = build_nonstandard_boolean_type (esize);
10526
10527 return make_vector_type (bool_type, nunits, mask_mode);
10528 }
10529
10530 /* Returns a vector type corresponding to a comparison of VECTYPE. */
10531
10532 tree
build_same_sized_truth_vector_type(tree vectype)10533 build_same_sized_truth_vector_type (tree vectype)
10534 {
10535 if (VECTOR_BOOLEAN_TYPE_P (vectype))
10536 return vectype;
10537
10538 poly_uint64 size = GET_MODE_SIZE (TYPE_MODE (vectype));
10539
10540 if (known_eq (size, 0U))
10541 size = tree_to_uhwi (TYPE_SIZE_UNIT (vectype));
10542
10543 return build_truth_vector_type (TYPE_VECTOR_SUBPARTS (vectype), size);
10544 }
10545
10546 /* Similarly, but builds a variant type with TYPE_VECTOR_OPAQUE set. */
10547
10548 tree
build_opaque_vector_type(tree innertype,poly_int64 nunits)10549 build_opaque_vector_type (tree innertype, poly_int64 nunits)
10550 {
10551 tree t = make_vector_type (innertype, nunits, VOIDmode);
10552 tree cand;
10553 /* We always build the non-opaque variant before the opaque one,
10554 so if it already exists, it is TYPE_NEXT_VARIANT of this one. */
10555 cand = TYPE_NEXT_VARIANT (t);
10556 if (cand
10557 && TYPE_VECTOR_OPAQUE (cand)
10558 && check_qualified_type (cand, t, TYPE_QUALS (t)))
10559 return cand;
10560 /* Othewise build a variant type and make sure to queue it after
10561 the non-opaque type. */
10562 cand = build_distinct_type_copy (t);
10563 TYPE_VECTOR_OPAQUE (cand) = true;
10564 TYPE_CANONICAL (cand) = TYPE_CANONICAL (t);
10565 TYPE_NEXT_VARIANT (cand) = TYPE_NEXT_VARIANT (t);
10566 TYPE_NEXT_VARIANT (t) = cand;
10567 TYPE_MAIN_VARIANT (cand) = TYPE_MAIN_VARIANT (t);
10568 return cand;
10569 }
10570
10571 /* Return the value of element I of VECTOR_CST T as a wide_int. */
10572
10573 wide_int
vector_cst_int_elt(const_tree t,unsigned int i)10574 vector_cst_int_elt (const_tree t, unsigned int i)
10575 {
10576 /* First handle elements that are directly encoded. */
10577 unsigned int encoded_nelts = vector_cst_encoded_nelts (t);
10578 if (i < encoded_nelts)
10579 return wi::to_wide (VECTOR_CST_ENCODED_ELT (t, i));
10580
10581 /* Identify the pattern that contains element I and work out the index of
10582 the last encoded element for that pattern. */
10583 unsigned int npatterns = VECTOR_CST_NPATTERNS (t);
10584 unsigned int pattern = i % npatterns;
10585 unsigned int count = i / npatterns;
10586 unsigned int final_i = encoded_nelts - npatterns + pattern;
10587
10588 /* If there are no steps, the final encoded value is the right one. */
10589 if (!VECTOR_CST_STEPPED_P (t))
10590 return wi::to_wide (VECTOR_CST_ENCODED_ELT (t, final_i));
10591
10592 /* Otherwise work out the value from the last two encoded elements. */
10593 tree v1 = VECTOR_CST_ENCODED_ELT (t, final_i - npatterns);
10594 tree v2 = VECTOR_CST_ENCODED_ELT (t, final_i);
10595 wide_int diff = wi::to_wide (v2) - wi::to_wide (v1);
10596 return wi::to_wide (v2) + (count - 2) * diff;
10597 }
10598
10599 /* Return the value of element I of VECTOR_CST T. */
10600
10601 tree
vector_cst_elt(const_tree t,unsigned int i)10602 vector_cst_elt (const_tree t, unsigned int i)
10603 {
10604 /* First handle elements that are directly encoded. */
10605 unsigned int encoded_nelts = vector_cst_encoded_nelts (t);
10606 if (i < encoded_nelts)
10607 return VECTOR_CST_ENCODED_ELT (t, i);
10608
10609 /* If there are no steps, the final encoded value is the right one. */
10610 if (!VECTOR_CST_STEPPED_P (t))
10611 {
10612 /* Identify the pattern that contains element I and work out the index of
10613 the last encoded element for that pattern. */
10614 unsigned int npatterns = VECTOR_CST_NPATTERNS (t);
10615 unsigned int pattern = i % npatterns;
10616 unsigned int final_i = encoded_nelts - npatterns + pattern;
10617 return VECTOR_CST_ENCODED_ELT (t, final_i);
10618 }
10619
10620 /* Otherwise work out the value from the last two encoded elements. */
10621 return wide_int_to_tree (TREE_TYPE (TREE_TYPE (t)),
10622 vector_cst_int_elt (t, i));
10623 }
10624
10625 /* Given an initializer INIT, return TRUE if INIT is zero or some
10626 aggregate of zeros. Otherwise return FALSE. */
10627 bool
initializer_zerop(const_tree init)10628 initializer_zerop (const_tree init)
10629 {
10630 tree elt;
10631
10632 STRIP_NOPS (init);
10633
10634 switch (TREE_CODE (init))
10635 {
10636 case INTEGER_CST:
10637 return integer_zerop (init);
10638
10639 case REAL_CST:
10640 /* ??? Note that this is not correct for C4X float formats. There,
10641 a bit pattern of all zeros is 1.0; 0.0 is encoded with the most
10642 negative exponent. */
10643 return real_zerop (init)
10644 && ! REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (init));
10645
10646 case FIXED_CST:
10647 return fixed_zerop (init);
10648
10649 case COMPLEX_CST:
10650 return integer_zerop (init)
10651 || (real_zerop (init)
10652 && ! REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (TREE_REALPART (init)))
10653 && ! REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (TREE_IMAGPART (init))));
10654
10655 case VECTOR_CST:
10656 return (VECTOR_CST_NPATTERNS (init) == 1
10657 && VECTOR_CST_DUPLICATE_P (init)
10658 && initializer_zerop (VECTOR_CST_ENCODED_ELT (init, 0)));
10659
10660 case CONSTRUCTOR:
10661 {
10662 unsigned HOST_WIDE_INT idx;
10663
10664 if (TREE_CLOBBER_P (init))
10665 return false;
10666 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (init), idx, elt)
10667 if (!initializer_zerop (elt))
10668 return false;
10669 return true;
10670 }
10671
10672 case STRING_CST:
10673 {
10674 int i;
10675
10676 /* We need to loop through all elements to handle cases like
10677 "\0" and "\0foobar". */
10678 for (i = 0; i < TREE_STRING_LENGTH (init); ++i)
10679 if (TREE_STRING_POINTER (init)[i] != '\0')
10680 return false;
10681
10682 return true;
10683 }
10684
10685 default:
10686 return false;
10687 }
10688 }
10689
10690 /* Check if vector VEC consists of all the equal elements and
10691 that the number of elements corresponds to the type of VEC.
10692 The function returns first element of the vector
10693 or NULL_TREE if the vector is not uniform. */
10694 tree
uniform_vector_p(const_tree vec)10695 uniform_vector_p (const_tree vec)
10696 {
10697 tree first, t;
10698 unsigned HOST_WIDE_INT i, nelts;
10699
10700 if (vec == NULL_TREE)
10701 return NULL_TREE;
10702
10703 gcc_assert (VECTOR_TYPE_P (TREE_TYPE (vec)));
10704
10705 if (TREE_CODE (vec) == VEC_DUPLICATE_EXPR)
10706 return TREE_OPERAND (vec, 0);
10707
10708 else if (TREE_CODE (vec) == VECTOR_CST)
10709 {
10710 if (VECTOR_CST_NPATTERNS (vec) == 1 && VECTOR_CST_DUPLICATE_P (vec))
10711 return VECTOR_CST_ENCODED_ELT (vec, 0);
10712 return NULL_TREE;
10713 }
10714
10715 else if (TREE_CODE (vec) == CONSTRUCTOR
10716 && TYPE_VECTOR_SUBPARTS (TREE_TYPE (vec)).is_constant (&nelts))
10717 {
10718 first = error_mark_node;
10719
10720 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (vec), i, t)
10721 {
10722 if (i == 0)
10723 {
10724 first = t;
10725 continue;
10726 }
10727 if (!operand_equal_p (first, t, 0))
10728 return NULL_TREE;
10729 }
10730 if (i != nelts)
10731 return NULL_TREE;
10732
10733 return first;
10734 }
10735
10736 return NULL_TREE;
10737 }
10738
10739 /* Build an empty statement at location LOC. */
10740
10741 tree
build_empty_stmt(location_t loc)10742 build_empty_stmt (location_t loc)
10743 {
10744 tree t = build1 (NOP_EXPR, void_type_node, size_zero_node);
10745 SET_EXPR_LOCATION (t, loc);
10746 return t;
10747 }
10748
10749
10750 /* Build an OpenMP clause with code CODE. LOC is the location of the
10751 clause. */
10752
10753 tree
build_omp_clause(location_t loc,enum omp_clause_code code)10754 build_omp_clause (location_t loc, enum omp_clause_code code)
10755 {
10756 tree t;
10757 int size, length;
10758
10759 length = omp_clause_num_ops[code];
10760 size = (sizeof (struct tree_omp_clause) + (length - 1) * sizeof (tree));
10761
10762 record_node_allocation_statistics (OMP_CLAUSE, size);
10763
10764 t = (tree) ggc_internal_alloc (size);
10765 memset (t, 0, size);
10766 TREE_SET_CODE (t, OMP_CLAUSE);
10767 OMP_CLAUSE_SET_CODE (t, code);
10768 OMP_CLAUSE_LOCATION (t) = loc;
10769
10770 return t;
10771 }
10772
10773 /* Build a tcc_vl_exp object with code CODE and room for LEN operands. LEN
10774 includes the implicit operand count in TREE_OPERAND 0, and so must be >= 1.
10775 Except for the CODE and operand count field, other storage for the
10776 object is initialized to zeros. */
10777
10778 tree
build_vl_exp(enum tree_code code,int len MEM_STAT_DECL)10779 build_vl_exp (enum tree_code code, int len MEM_STAT_DECL)
10780 {
10781 tree t;
10782 int length = (len - 1) * sizeof (tree) + sizeof (struct tree_exp);
10783
10784 gcc_assert (TREE_CODE_CLASS (code) == tcc_vl_exp);
10785 gcc_assert (len >= 1);
10786
10787 record_node_allocation_statistics (code, length);
10788
10789 t = ggc_alloc_cleared_tree_node_stat (length PASS_MEM_STAT);
10790
10791 TREE_SET_CODE (t, code);
10792
10793 /* Can't use TREE_OPERAND to store the length because if checking is
10794 enabled, it will try to check the length before we store it. :-P */
10795 t->exp.operands[0] = build_int_cst (sizetype, len);
10796
10797 return t;
10798 }
10799
10800 /* Helper function for build_call_* functions; build a CALL_EXPR with
10801 indicated RETURN_TYPE, FN, and NARGS, but do not initialize any of
10802 the argument slots. */
10803
10804 static tree
build_call_1(tree return_type,tree fn,int nargs)10805 build_call_1 (tree return_type, tree fn, int nargs)
10806 {
10807 tree t;
10808
10809 t = build_vl_exp (CALL_EXPR, nargs + 3);
10810 TREE_TYPE (t) = return_type;
10811 CALL_EXPR_FN (t) = fn;
10812 CALL_EXPR_STATIC_CHAIN (t) = NULL;
10813
10814 return t;
10815 }
10816
10817 /* Build a CALL_EXPR of class tcc_vl_exp with the indicated RETURN_TYPE and
10818 FN and a null static chain slot. NARGS is the number of call arguments
10819 which are specified as "..." arguments. */
10820
10821 tree
build_call_nary(tree return_type,tree fn,int nargs,...)10822 build_call_nary (tree return_type, tree fn, int nargs, ...)
10823 {
10824 tree ret;
10825 va_list args;
10826 va_start (args, nargs);
10827 ret = build_call_valist (return_type, fn, nargs, args);
10828 va_end (args);
10829 return ret;
10830 }
10831
10832 /* Build a CALL_EXPR of class tcc_vl_exp with the indicated RETURN_TYPE and
10833 FN and a null static chain slot. NARGS is the number of call arguments
10834 which are specified as a va_list ARGS. */
10835
10836 tree
build_call_valist(tree return_type,tree fn,int nargs,va_list args)10837 build_call_valist (tree return_type, tree fn, int nargs, va_list args)
10838 {
10839 tree t;
10840 int i;
10841
10842 t = build_call_1 (return_type, fn, nargs);
10843 for (i = 0; i < nargs; i++)
10844 CALL_EXPR_ARG (t, i) = va_arg (args, tree);
10845 process_call_operands (t);
10846 return t;
10847 }
10848
10849 /* Build a CALL_EXPR of class tcc_vl_exp with the indicated RETURN_TYPE and
10850 FN and a null static chain slot. NARGS is the number of call arguments
10851 which are specified as a tree array ARGS. */
10852
10853 tree
build_call_array_loc(location_t loc,tree return_type,tree fn,int nargs,const tree * args)10854 build_call_array_loc (location_t loc, tree return_type, tree fn,
10855 int nargs, const tree *args)
10856 {
10857 tree t;
10858 int i;
10859
10860 t = build_call_1 (return_type, fn, nargs);
10861 for (i = 0; i < nargs; i++)
10862 CALL_EXPR_ARG (t, i) = args[i];
10863 process_call_operands (t);
10864 SET_EXPR_LOCATION (t, loc);
10865 return t;
10866 }
10867
10868 /* Like build_call_array, but takes a vec. */
10869
10870 tree
build_call_vec(tree return_type,tree fn,vec<tree,va_gc> * args)10871 build_call_vec (tree return_type, tree fn, vec<tree, va_gc> *args)
10872 {
10873 tree ret, t;
10874 unsigned int ix;
10875
10876 ret = build_call_1 (return_type, fn, vec_safe_length (args));
10877 FOR_EACH_VEC_SAFE_ELT (args, ix, t)
10878 CALL_EXPR_ARG (ret, ix) = t;
10879 process_call_operands (ret);
10880 return ret;
10881 }
10882
10883 /* Conveniently construct a function call expression. FNDECL names the
10884 function to be called and N arguments are passed in the array
10885 ARGARRAY. */
10886
10887 tree
build_call_expr_loc_array(location_t loc,tree fndecl,int n,tree * argarray)10888 build_call_expr_loc_array (location_t loc, tree fndecl, int n, tree *argarray)
10889 {
10890 tree fntype = TREE_TYPE (fndecl);
10891 tree fn = build1 (ADDR_EXPR, build_pointer_type (fntype), fndecl);
10892
10893 return fold_build_call_array_loc (loc, TREE_TYPE (fntype), fn, n, argarray);
10894 }
10895
10896 /* Conveniently construct a function call expression. FNDECL names the
10897 function to be called and the arguments are passed in the vector
10898 VEC. */
10899
10900 tree
build_call_expr_loc_vec(location_t loc,tree fndecl,vec<tree,va_gc> * vec)10901 build_call_expr_loc_vec (location_t loc, tree fndecl, vec<tree, va_gc> *vec)
10902 {
10903 return build_call_expr_loc_array (loc, fndecl, vec_safe_length (vec),
10904 vec_safe_address (vec));
10905 }
10906
10907
10908 /* Conveniently construct a function call expression. FNDECL names the
10909 function to be called, N is the number of arguments, and the "..."
10910 parameters are the argument expressions. */
10911
10912 tree
build_call_expr_loc(location_t loc,tree fndecl,int n,...)10913 build_call_expr_loc (location_t loc, tree fndecl, int n, ...)
10914 {
10915 va_list ap;
10916 tree *argarray = XALLOCAVEC (tree, n);
10917 int i;
10918
10919 va_start (ap, n);
10920 for (i = 0; i < n; i++)
10921 argarray[i] = va_arg (ap, tree);
10922 va_end (ap);
10923 return build_call_expr_loc_array (loc, fndecl, n, argarray);
10924 }
10925
10926 /* Like build_call_expr_loc (UNKNOWN_LOCATION, ...). Duplicated because
10927 varargs macros aren't supported by all bootstrap compilers. */
10928
10929 tree
build_call_expr(tree fndecl,int n,...)10930 build_call_expr (tree fndecl, int n, ...)
10931 {
10932 va_list ap;
10933 tree *argarray = XALLOCAVEC (tree, n);
10934 int i;
10935
10936 va_start (ap, n);
10937 for (i = 0; i < n; i++)
10938 argarray[i] = va_arg (ap, tree);
10939 va_end (ap);
10940 return build_call_expr_loc_array (UNKNOWN_LOCATION, fndecl, n, argarray);
10941 }
10942
10943 /* Build an internal call to IFN, with arguments ARGS[0:N-1] and with return
10944 type TYPE. This is just like CALL_EXPR, except its CALL_EXPR_FN is NULL.
10945 It will get gimplified later into an ordinary internal function. */
10946
10947 tree
build_call_expr_internal_loc_array(location_t loc,internal_fn ifn,tree type,int n,const tree * args)10948 build_call_expr_internal_loc_array (location_t loc, internal_fn ifn,
10949 tree type, int n, const tree *args)
10950 {
10951 tree t = build_call_1 (type, NULL_TREE, n);
10952 for (int i = 0; i < n; ++i)
10953 CALL_EXPR_ARG (t, i) = args[i];
10954 SET_EXPR_LOCATION (t, loc);
10955 CALL_EXPR_IFN (t) = ifn;
10956 return t;
10957 }
10958
10959 /* Build internal call expression. This is just like CALL_EXPR, except
10960 its CALL_EXPR_FN is NULL. It will get gimplified later into ordinary
10961 internal function. */
10962
10963 tree
build_call_expr_internal_loc(location_t loc,enum internal_fn ifn,tree type,int n,...)10964 build_call_expr_internal_loc (location_t loc, enum internal_fn ifn,
10965 tree type, int n, ...)
10966 {
10967 va_list ap;
10968 tree *argarray = XALLOCAVEC (tree, n);
10969 int i;
10970
10971 va_start (ap, n);
10972 for (i = 0; i < n; i++)
10973 argarray[i] = va_arg (ap, tree);
10974 va_end (ap);
10975 return build_call_expr_internal_loc_array (loc, ifn, type, n, argarray);
10976 }
10977
10978 /* Return a function call to FN, if the target is guaranteed to support it,
10979 or null otherwise.
10980
10981 N is the number of arguments, passed in the "...", and TYPE is the
10982 type of the return value. */
10983
10984 tree
maybe_build_call_expr_loc(location_t loc,combined_fn fn,tree type,int n,...)10985 maybe_build_call_expr_loc (location_t loc, combined_fn fn, tree type,
10986 int n, ...)
10987 {
10988 va_list ap;
10989 tree *argarray = XALLOCAVEC (tree, n);
10990 int i;
10991
10992 va_start (ap, n);
10993 for (i = 0; i < n; i++)
10994 argarray[i] = va_arg (ap, tree);
10995 va_end (ap);
10996 if (internal_fn_p (fn))
10997 {
10998 internal_fn ifn = as_internal_fn (fn);
10999 if (direct_internal_fn_p (ifn))
11000 {
11001 tree_pair types = direct_internal_fn_types (ifn, type, argarray);
11002 if (!direct_internal_fn_supported_p (ifn, types,
11003 OPTIMIZE_FOR_BOTH))
11004 return NULL_TREE;
11005 }
11006 return build_call_expr_internal_loc_array (loc, ifn, type, n, argarray);
11007 }
11008 else
11009 {
11010 tree fndecl = builtin_decl_implicit (as_builtin_fn (fn));
11011 if (!fndecl)
11012 return NULL_TREE;
11013 return build_call_expr_loc_array (loc, fndecl, n, argarray);
11014 }
11015 }
11016
11017 /* Return a function call to the appropriate builtin alloca variant.
11018
11019 SIZE is the size to be allocated. ALIGN, if non-zero, is the requested
11020 alignment of the allocated area. MAX_SIZE, if non-negative, is an upper
11021 bound for SIZE in case it is not a fixed value. */
11022
11023 tree
build_alloca_call_expr(tree size,unsigned int align,HOST_WIDE_INT max_size)11024 build_alloca_call_expr (tree size, unsigned int align, HOST_WIDE_INT max_size)
11025 {
11026 if (max_size >= 0)
11027 {
11028 tree t = builtin_decl_explicit (BUILT_IN_ALLOCA_WITH_ALIGN_AND_MAX);
11029 return
11030 build_call_expr (t, 3, size, size_int (align), size_int (max_size));
11031 }
11032 else if (align > 0)
11033 {
11034 tree t = builtin_decl_explicit (BUILT_IN_ALLOCA_WITH_ALIGN);
11035 return build_call_expr (t, 2, size, size_int (align));
11036 }
11037 else
11038 {
11039 tree t = builtin_decl_explicit (BUILT_IN_ALLOCA);
11040 return build_call_expr (t, 1, size);
11041 }
11042 }
11043
11044 /* Create a new constant string literal and return a char* pointer to it.
11045 The STRING_CST value is the LEN characters at STR. */
11046 tree
build_string_literal(int len,const char * str)11047 build_string_literal (int len, const char *str)
11048 {
11049 tree t, elem, index, type;
11050
11051 t = build_string (len, str);
11052 elem = build_type_variant (char_type_node, 1, 0);
11053 index = build_index_type (size_int (len - 1));
11054 type = build_array_type (elem, index);
11055 TREE_TYPE (t) = type;
11056 TREE_CONSTANT (t) = 1;
11057 TREE_READONLY (t) = 1;
11058 TREE_STATIC (t) = 1;
11059
11060 type = build_pointer_type (elem);
11061 t = build1 (ADDR_EXPR, type,
11062 build4 (ARRAY_REF, elem,
11063 t, integer_zero_node, NULL_TREE, NULL_TREE));
11064 return t;
11065 }
11066
11067
11068
11069 /* Return true if T (assumed to be a DECL) must be assigned a memory
11070 location. */
11071
11072 bool
needs_to_live_in_memory(const_tree t)11073 needs_to_live_in_memory (const_tree t)
11074 {
11075 return (TREE_ADDRESSABLE (t)
11076 || is_global_var (t)
11077 || (TREE_CODE (t) == RESULT_DECL
11078 && !DECL_BY_REFERENCE (t)
11079 && aggregate_value_p (t, current_function_decl)));
11080 }
11081
11082 /* Return value of a constant X and sign-extend it. */
11083
11084 HOST_WIDE_INT
int_cst_value(const_tree x)11085 int_cst_value (const_tree x)
11086 {
11087 unsigned bits = TYPE_PRECISION (TREE_TYPE (x));
11088 unsigned HOST_WIDE_INT val = TREE_INT_CST_LOW (x);
11089
11090 /* Make sure the sign-extended value will fit in a HOST_WIDE_INT. */
11091 gcc_assert (cst_and_fits_in_hwi (x));
11092
11093 if (bits < HOST_BITS_PER_WIDE_INT)
11094 {
11095 bool negative = ((val >> (bits - 1)) & 1) != 0;
11096 if (negative)
11097 val |= HOST_WIDE_INT_M1U << (bits - 1) << 1;
11098 else
11099 val &= ~(HOST_WIDE_INT_M1U << (bits - 1) << 1);
11100 }
11101
11102 return val;
11103 }
11104
11105 /* If TYPE is an integral or pointer type, return an integer type with
11106 the same precision which is unsigned iff UNSIGNEDP is true, or itself
11107 if TYPE is already an integer type of signedness UNSIGNEDP. */
11108
11109 tree
signed_or_unsigned_type_for(int unsignedp,tree type)11110 signed_or_unsigned_type_for (int unsignedp, tree type)
11111 {
11112 if (TREE_CODE (type) == INTEGER_TYPE && TYPE_UNSIGNED (type) == unsignedp)
11113 return type;
11114
11115 if (TREE_CODE (type) == VECTOR_TYPE)
11116 {
11117 tree inner = TREE_TYPE (type);
11118 tree inner2 = signed_or_unsigned_type_for (unsignedp, inner);
11119 if (!inner2)
11120 return NULL_TREE;
11121 if (inner == inner2)
11122 return type;
11123 return build_vector_type (inner2, TYPE_VECTOR_SUBPARTS (type));
11124 }
11125
11126 if (!INTEGRAL_TYPE_P (type)
11127 && !POINTER_TYPE_P (type)
11128 && TREE_CODE (type) != OFFSET_TYPE)
11129 return NULL_TREE;
11130
11131 return build_nonstandard_integer_type (TYPE_PRECISION (type), unsignedp);
11132 }
11133
11134 /* If TYPE is an integral or pointer type, return an integer type with
11135 the same precision which is unsigned, or itself if TYPE is already an
11136 unsigned integer type. */
11137
11138 tree
unsigned_type_for(tree type)11139 unsigned_type_for (tree type)
11140 {
11141 return signed_or_unsigned_type_for (1, type);
11142 }
11143
11144 /* If TYPE is an integral or pointer type, return an integer type with
11145 the same precision which is signed, or itself if TYPE is already a
11146 signed integer type. */
11147
11148 tree
signed_type_for(tree type)11149 signed_type_for (tree type)
11150 {
11151 return signed_or_unsigned_type_for (0, type);
11152 }
11153
11154 /* If TYPE is a vector type, return a signed integer vector type with the
11155 same width and number of subparts. Otherwise return boolean_type_node. */
11156
11157 tree
truth_type_for(tree type)11158 truth_type_for (tree type)
11159 {
11160 if (TREE_CODE (type) == VECTOR_TYPE)
11161 {
11162 if (VECTOR_BOOLEAN_TYPE_P (type))
11163 return type;
11164 return build_truth_vector_type (TYPE_VECTOR_SUBPARTS (type),
11165 GET_MODE_SIZE (TYPE_MODE (type)));
11166 }
11167 else
11168 return boolean_type_node;
11169 }
11170
11171 /* Returns the largest value obtainable by casting something in INNER type to
11172 OUTER type. */
11173
11174 tree
upper_bound_in_type(tree outer,tree inner)11175 upper_bound_in_type (tree outer, tree inner)
11176 {
11177 unsigned int det = 0;
11178 unsigned oprec = TYPE_PRECISION (outer);
11179 unsigned iprec = TYPE_PRECISION (inner);
11180 unsigned prec;
11181
11182 /* Compute a unique number for every combination. */
11183 det |= (oprec > iprec) ? 4 : 0;
11184 det |= TYPE_UNSIGNED (outer) ? 2 : 0;
11185 det |= TYPE_UNSIGNED (inner) ? 1 : 0;
11186
11187 /* Determine the exponent to use. */
11188 switch (det)
11189 {
11190 case 0:
11191 case 1:
11192 /* oprec <= iprec, outer: signed, inner: don't care. */
11193 prec = oprec - 1;
11194 break;
11195 case 2:
11196 case 3:
11197 /* oprec <= iprec, outer: unsigned, inner: don't care. */
11198 prec = oprec;
11199 break;
11200 case 4:
11201 /* oprec > iprec, outer: signed, inner: signed. */
11202 prec = iprec - 1;
11203 break;
11204 case 5:
11205 /* oprec > iprec, outer: signed, inner: unsigned. */
11206 prec = iprec;
11207 break;
11208 case 6:
11209 /* oprec > iprec, outer: unsigned, inner: signed. */
11210 prec = oprec;
11211 break;
11212 case 7:
11213 /* oprec > iprec, outer: unsigned, inner: unsigned. */
11214 prec = iprec;
11215 break;
11216 default:
11217 gcc_unreachable ();
11218 }
11219
11220 return wide_int_to_tree (outer,
11221 wi::mask (prec, false, TYPE_PRECISION (outer)));
11222 }
11223
11224 /* Returns the smallest value obtainable by casting something in INNER type to
11225 OUTER type. */
11226
11227 tree
lower_bound_in_type(tree outer,tree inner)11228 lower_bound_in_type (tree outer, tree inner)
11229 {
11230 unsigned oprec = TYPE_PRECISION (outer);
11231 unsigned iprec = TYPE_PRECISION (inner);
11232
11233 /* If OUTER type is unsigned, we can definitely cast 0 to OUTER type
11234 and obtain 0. */
11235 if (TYPE_UNSIGNED (outer)
11236 /* If we are widening something of an unsigned type, OUTER type
11237 contains all values of INNER type. In particular, both INNER
11238 and OUTER types have zero in common. */
11239 || (oprec > iprec && TYPE_UNSIGNED (inner)))
11240 return build_int_cst (outer, 0);
11241 else
11242 {
11243 /* If we are widening a signed type to another signed type, we
11244 want to obtain -2^^(iprec-1). If we are keeping the
11245 precision or narrowing to a signed type, we want to obtain
11246 -2^(oprec-1). */
11247 unsigned prec = oprec > iprec ? iprec : oprec;
11248 return wide_int_to_tree (outer,
11249 wi::mask (prec - 1, true,
11250 TYPE_PRECISION (outer)));
11251 }
11252 }
11253
11254 /* Return nonzero if two operands that are suitable for PHI nodes are
11255 necessarily equal. Specifically, both ARG0 and ARG1 must be either
11256 SSA_NAME or invariant. Note that this is strictly an optimization.
11257 That is, callers of this function can directly call operand_equal_p
11258 and get the same result, only slower. */
11259
11260 int
operand_equal_for_phi_arg_p(const_tree arg0,const_tree arg1)11261 operand_equal_for_phi_arg_p (const_tree arg0, const_tree arg1)
11262 {
11263 if (arg0 == arg1)
11264 return 1;
11265 if (TREE_CODE (arg0) == SSA_NAME || TREE_CODE (arg1) == SSA_NAME)
11266 return 0;
11267 return operand_equal_p (arg0, arg1, 0);
11268 }
11269
11270 /* Returns number of zeros at the end of binary representation of X. */
11271
11272 tree
num_ending_zeros(const_tree x)11273 num_ending_zeros (const_tree x)
11274 {
11275 return build_int_cst (TREE_TYPE (x), wi::ctz (wi::to_wide (x)));
11276 }
11277
11278
11279 #define WALK_SUBTREE(NODE) \
11280 do \
11281 { \
11282 result = walk_tree_1 (&(NODE), func, data, pset, lh); \
11283 if (result) \
11284 return result; \
11285 } \
11286 while (0)
11287
11288 /* This is a subroutine of walk_tree that walks field of TYPE that are to
11289 be walked whenever a type is seen in the tree. Rest of operands and return
11290 value are as for walk_tree. */
11291
11292 static tree
walk_type_fields(tree type,walk_tree_fn func,void * data,hash_set<tree> * pset,walk_tree_lh lh)11293 walk_type_fields (tree type, walk_tree_fn func, void *data,
11294 hash_set<tree> *pset, walk_tree_lh lh)
11295 {
11296 tree result = NULL_TREE;
11297
11298 switch (TREE_CODE (type))
11299 {
11300 case POINTER_TYPE:
11301 case REFERENCE_TYPE:
11302 case VECTOR_TYPE:
11303 /* We have to worry about mutually recursive pointers. These can't
11304 be written in C. They can in Ada. It's pathological, but
11305 there's an ACATS test (c38102a) that checks it. Deal with this
11306 by checking if we're pointing to another pointer, that one
11307 points to another pointer, that one does too, and we have no htab.
11308 If so, get a hash table. We check three levels deep to avoid
11309 the cost of the hash table if we don't need one. */
11310 if (POINTER_TYPE_P (TREE_TYPE (type))
11311 && POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (type)))
11312 && POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (TREE_TYPE (type))))
11313 && !pset)
11314 {
11315 result = walk_tree_without_duplicates (&TREE_TYPE (type),
11316 func, data);
11317 if (result)
11318 return result;
11319
11320 break;
11321 }
11322
11323 /* fall through */
11324
11325 case COMPLEX_TYPE:
11326 WALK_SUBTREE (TREE_TYPE (type));
11327 break;
11328
11329 case METHOD_TYPE:
11330 WALK_SUBTREE (TYPE_METHOD_BASETYPE (type));
11331
11332 /* Fall through. */
11333
11334 case FUNCTION_TYPE:
11335 WALK_SUBTREE (TREE_TYPE (type));
11336 {
11337 tree arg;
11338
11339 /* We never want to walk into default arguments. */
11340 for (arg = TYPE_ARG_TYPES (type); arg; arg = TREE_CHAIN (arg))
11341 WALK_SUBTREE (TREE_VALUE (arg));
11342 }
11343 break;
11344
11345 case ARRAY_TYPE:
11346 /* Don't follow this nodes's type if a pointer for fear that
11347 we'll have infinite recursion. If we have a PSET, then we
11348 need not fear. */
11349 if (pset
11350 || (!POINTER_TYPE_P (TREE_TYPE (type))
11351 && TREE_CODE (TREE_TYPE (type)) != OFFSET_TYPE))
11352 WALK_SUBTREE (TREE_TYPE (type));
11353 WALK_SUBTREE (TYPE_DOMAIN (type));
11354 break;
11355
11356 case OFFSET_TYPE:
11357 WALK_SUBTREE (TREE_TYPE (type));
11358 WALK_SUBTREE (TYPE_OFFSET_BASETYPE (type));
11359 break;
11360
11361 default:
11362 break;
11363 }
11364
11365 return NULL_TREE;
11366 }
11367
11368 /* Apply FUNC to all the sub-trees of TP in a pre-order traversal. FUNC is
11369 called with the DATA and the address of each sub-tree. If FUNC returns a
11370 non-NULL value, the traversal is stopped, and the value returned by FUNC
11371 is returned. If PSET is non-NULL it is used to record the nodes visited,
11372 and to avoid visiting a node more than once. */
11373
11374 tree
walk_tree_1(tree * tp,walk_tree_fn func,void * data,hash_set<tree> * pset,walk_tree_lh lh)11375 walk_tree_1 (tree *tp, walk_tree_fn func, void *data,
11376 hash_set<tree> *pset, walk_tree_lh lh)
11377 {
11378 enum tree_code code;
11379 int walk_subtrees;
11380 tree result;
11381
11382 #define WALK_SUBTREE_TAIL(NODE) \
11383 do \
11384 { \
11385 tp = & (NODE); \
11386 goto tail_recurse; \
11387 } \
11388 while (0)
11389
11390 tail_recurse:
11391 /* Skip empty subtrees. */
11392 if (!*tp)
11393 return NULL_TREE;
11394
11395 /* Don't walk the same tree twice, if the user has requested
11396 that we avoid doing so. */
11397 if (pset && pset->add (*tp))
11398 return NULL_TREE;
11399
11400 /* Call the function. */
11401 walk_subtrees = 1;
11402 result = (*func) (tp, &walk_subtrees, data);
11403
11404 /* If we found something, return it. */
11405 if (result)
11406 return result;
11407
11408 code = TREE_CODE (*tp);
11409
11410 /* Even if we didn't, FUNC may have decided that there was nothing
11411 interesting below this point in the tree. */
11412 if (!walk_subtrees)
11413 {
11414 /* But we still need to check our siblings. */
11415 if (code == TREE_LIST)
11416 WALK_SUBTREE_TAIL (TREE_CHAIN (*tp));
11417 else if (code == OMP_CLAUSE)
11418 WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp));
11419 else
11420 return NULL_TREE;
11421 }
11422
11423 if (lh)
11424 {
11425 result = (*lh) (tp, &walk_subtrees, func, data, pset);
11426 if (result || !walk_subtrees)
11427 return result;
11428 }
11429
11430 switch (code)
11431 {
11432 case ERROR_MARK:
11433 case IDENTIFIER_NODE:
11434 case INTEGER_CST:
11435 case REAL_CST:
11436 case FIXED_CST:
11437 case VECTOR_CST:
11438 case STRING_CST:
11439 case BLOCK:
11440 case PLACEHOLDER_EXPR:
11441 case SSA_NAME:
11442 case FIELD_DECL:
11443 case RESULT_DECL:
11444 /* None of these have subtrees other than those already walked
11445 above. */
11446 break;
11447
11448 case TREE_LIST:
11449 WALK_SUBTREE (TREE_VALUE (*tp));
11450 WALK_SUBTREE_TAIL (TREE_CHAIN (*tp));
11451 break;
11452
11453 case TREE_VEC:
11454 {
11455 int len = TREE_VEC_LENGTH (*tp);
11456
11457 if (len == 0)
11458 break;
11459
11460 /* Walk all elements but the first. */
11461 while (--len)
11462 WALK_SUBTREE (TREE_VEC_ELT (*tp, len));
11463
11464 /* Now walk the first one as a tail call. */
11465 WALK_SUBTREE_TAIL (TREE_VEC_ELT (*tp, 0));
11466 }
11467
11468 case COMPLEX_CST:
11469 WALK_SUBTREE (TREE_REALPART (*tp));
11470 WALK_SUBTREE_TAIL (TREE_IMAGPART (*tp));
11471
11472 case CONSTRUCTOR:
11473 {
11474 unsigned HOST_WIDE_INT idx;
11475 constructor_elt *ce;
11476
11477 for (idx = 0; vec_safe_iterate (CONSTRUCTOR_ELTS (*tp), idx, &ce);
11478 idx++)
11479 WALK_SUBTREE (ce->value);
11480 }
11481 break;
11482
11483 case SAVE_EXPR:
11484 WALK_SUBTREE_TAIL (TREE_OPERAND (*tp, 0));
11485
11486 case BIND_EXPR:
11487 {
11488 tree decl;
11489 for (decl = BIND_EXPR_VARS (*tp); decl; decl = DECL_CHAIN (decl))
11490 {
11491 /* Walk the DECL_INITIAL and DECL_SIZE. We don't want to walk
11492 into declarations that are just mentioned, rather than
11493 declared; they don't really belong to this part of the tree.
11494 And, we can see cycles: the initializer for a declaration
11495 can refer to the declaration itself. */
11496 WALK_SUBTREE (DECL_INITIAL (decl));
11497 WALK_SUBTREE (DECL_SIZE (decl));
11498 WALK_SUBTREE (DECL_SIZE_UNIT (decl));
11499 }
11500 WALK_SUBTREE_TAIL (BIND_EXPR_BODY (*tp));
11501 }
11502
11503 case STATEMENT_LIST:
11504 {
11505 tree_stmt_iterator i;
11506 for (i = tsi_start (*tp); !tsi_end_p (i); tsi_next (&i))
11507 WALK_SUBTREE (*tsi_stmt_ptr (i));
11508 }
11509 break;
11510
11511 case OMP_CLAUSE:
11512 switch (OMP_CLAUSE_CODE (*tp))
11513 {
11514 case OMP_CLAUSE_GANG:
11515 case OMP_CLAUSE__GRIDDIM_:
11516 WALK_SUBTREE (OMP_CLAUSE_OPERAND (*tp, 1));
11517 /* FALLTHRU */
11518
11519 case OMP_CLAUSE_ASYNC:
11520 case OMP_CLAUSE_WAIT:
11521 case OMP_CLAUSE_WORKER:
11522 case OMP_CLAUSE_VECTOR:
11523 case OMP_CLAUSE_NUM_GANGS:
11524 case OMP_CLAUSE_NUM_WORKERS:
11525 case OMP_CLAUSE_VECTOR_LENGTH:
11526 case OMP_CLAUSE_PRIVATE:
11527 case OMP_CLAUSE_SHARED:
11528 case OMP_CLAUSE_FIRSTPRIVATE:
11529 case OMP_CLAUSE_COPYIN:
11530 case OMP_CLAUSE_COPYPRIVATE:
11531 case OMP_CLAUSE_FINAL:
11532 case OMP_CLAUSE_IF:
11533 case OMP_CLAUSE_NUM_THREADS:
11534 case OMP_CLAUSE_SCHEDULE:
11535 case OMP_CLAUSE_UNIFORM:
11536 case OMP_CLAUSE_DEPEND:
11537 case OMP_CLAUSE_NUM_TEAMS:
11538 case OMP_CLAUSE_THREAD_LIMIT:
11539 case OMP_CLAUSE_DEVICE:
11540 case OMP_CLAUSE_DIST_SCHEDULE:
11541 case OMP_CLAUSE_SAFELEN:
11542 case OMP_CLAUSE_SIMDLEN:
11543 case OMP_CLAUSE_ORDERED:
11544 case OMP_CLAUSE_PRIORITY:
11545 case OMP_CLAUSE_GRAINSIZE:
11546 case OMP_CLAUSE_NUM_TASKS:
11547 case OMP_CLAUSE_HINT:
11548 case OMP_CLAUSE_TO_DECLARE:
11549 case OMP_CLAUSE_LINK:
11550 case OMP_CLAUSE_USE_DEVICE_PTR:
11551 case OMP_CLAUSE_IS_DEVICE_PTR:
11552 case OMP_CLAUSE__LOOPTEMP_:
11553 case OMP_CLAUSE__SIMDUID_:
11554 WALK_SUBTREE (OMP_CLAUSE_OPERAND (*tp, 0));
11555 /* FALLTHRU */
11556
11557 case OMP_CLAUSE_INDEPENDENT:
11558 case OMP_CLAUSE_NOWAIT:
11559 case OMP_CLAUSE_DEFAULT:
11560 case OMP_CLAUSE_UNTIED:
11561 case OMP_CLAUSE_MERGEABLE:
11562 case OMP_CLAUSE_PROC_BIND:
11563 case OMP_CLAUSE_INBRANCH:
11564 case OMP_CLAUSE_NOTINBRANCH:
11565 case OMP_CLAUSE_FOR:
11566 case OMP_CLAUSE_PARALLEL:
11567 case OMP_CLAUSE_SECTIONS:
11568 case OMP_CLAUSE_TASKGROUP:
11569 case OMP_CLAUSE_NOGROUP:
11570 case OMP_CLAUSE_THREADS:
11571 case OMP_CLAUSE_SIMD:
11572 case OMP_CLAUSE_DEFAULTMAP:
11573 case OMP_CLAUSE_AUTO:
11574 case OMP_CLAUSE_SEQ:
11575 case OMP_CLAUSE_TILE:
11576 case OMP_CLAUSE__SIMT_:
11577 WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp));
11578
11579 case OMP_CLAUSE_LASTPRIVATE:
11580 WALK_SUBTREE (OMP_CLAUSE_DECL (*tp));
11581 WALK_SUBTREE (OMP_CLAUSE_LASTPRIVATE_STMT (*tp));
11582 WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp));
11583
11584 case OMP_CLAUSE_COLLAPSE:
11585 {
11586 int i;
11587 for (i = 0; i < 3; i++)
11588 WALK_SUBTREE (OMP_CLAUSE_OPERAND (*tp, i));
11589 WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp));
11590 }
11591
11592 case OMP_CLAUSE_LINEAR:
11593 WALK_SUBTREE (OMP_CLAUSE_DECL (*tp));
11594 WALK_SUBTREE (OMP_CLAUSE_LINEAR_STEP (*tp));
11595 WALK_SUBTREE (OMP_CLAUSE_LINEAR_STMT (*tp));
11596 WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp));
11597
11598 case OMP_CLAUSE_ALIGNED:
11599 case OMP_CLAUSE_FROM:
11600 case OMP_CLAUSE_TO:
11601 case OMP_CLAUSE_MAP:
11602 case OMP_CLAUSE__CACHE_:
11603 WALK_SUBTREE (OMP_CLAUSE_DECL (*tp));
11604 WALK_SUBTREE (OMP_CLAUSE_OPERAND (*tp, 1));
11605 WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp));
11606
11607 case OMP_CLAUSE_REDUCTION:
11608 {
11609 int i;
11610 for (i = 0; i < 5; i++)
11611 WALK_SUBTREE (OMP_CLAUSE_OPERAND (*tp, i));
11612 WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp));
11613 }
11614
11615 default:
11616 gcc_unreachable ();
11617 }
11618 break;
11619
11620 case TARGET_EXPR:
11621 {
11622 int i, len;
11623
11624 /* TARGET_EXPRs are peculiar: operands 1 and 3 can be the same.
11625 But, we only want to walk once. */
11626 len = (TREE_OPERAND (*tp, 3) == TREE_OPERAND (*tp, 1)) ? 2 : 3;
11627 for (i = 0; i < len; ++i)
11628 WALK_SUBTREE (TREE_OPERAND (*tp, i));
11629 WALK_SUBTREE_TAIL (TREE_OPERAND (*tp, len));
11630 }
11631
11632 case DECL_EXPR:
11633 /* If this is a TYPE_DECL, walk into the fields of the type that it's
11634 defining. We only want to walk into these fields of a type in this
11635 case and not in the general case of a mere reference to the type.
11636
11637 The criterion is as follows: if the field can be an expression, it
11638 must be walked only here. This should be in keeping with the fields
11639 that are directly gimplified in gimplify_type_sizes in order for the
11640 mark/copy-if-shared/unmark machinery of the gimplifier to work with
11641 variable-sized types.
11642
11643 Note that DECLs get walked as part of processing the BIND_EXPR. */
11644 if (TREE_CODE (DECL_EXPR_DECL (*tp)) == TYPE_DECL)
11645 {
11646 tree *type_p = &TREE_TYPE (DECL_EXPR_DECL (*tp));
11647 if (TREE_CODE (*type_p) == ERROR_MARK)
11648 return NULL_TREE;
11649
11650 /* Call the function for the type. See if it returns anything or
11651 doesn't want us to continue. If we are to continue, walk both
11652 the normal fields and those for the declaration case. */
11653 result = (*func) (type_p, &walk_subtrees, data);
11654 if (result || !walk_subtrees)
11655 return result;
11656
11657 /* But do not walk a pointed-to type since it may itself need to
11658 be walked in the declaration case if it isn't anonymous. */
11659 if (!POINTER_TYPE_P (*type_p))
11660 {
11661 result = walk_type_fields (*type_p, func, data, pset, lh);
11662 if (result)
11663 return result;
11664 }
11665
11666 /* If this is a record type, also walk the fields. */
11667 if (RECORD_OR_UNION_TYPE_P (*type_p))
11668 {
11669 tree field;
11670
11671 for (field = TYPE_FIELDS (*type_p); field;
11672 field = DECL_CHAIN (field))
11673 {
11674 /* We'd like to look at the type of the field, but we can
11675 easily get infinite recursion. So assume it's pointed
11676 to elsewhere in the tree. Also, ignore things that
11677 aren't fields. */
11678 if (TREE_CODE (field) != FIELD_DECL)
11679 continue;
11680
11681 WALK_SUBTREE (DECL_FIELD_OFFSET (field));
11682 WALK_SUBTREE (DECL_SIZE (field));
11683 WALK_SUBTREE (DECL_SIZE_UNIT (field));
11684 if (TREE_CODE (*type_p) == QUAL_UNION_TYPE)
11685 WALK_SUBTREE (DECL_QUALIFIER (field));
11686 }
11687 }
11688
11689 /* Same for scalar types. */
11690 else if (TREE_CODE (*type_p) == BOOLEAN_TYPE
11691 || TREE_CODE (*type_p) == ENUMERAL_TYPE
11692 || TREE_CODE (*type_p) == INTEGER_TYPE
11693 || TREE_CODE (*type_p) == FIXED_POINT_TYPE
11694 || TREE_CODE (*type_p) == REAL_TYPE)
11695 {
11696 WALK_SUBTREE (TYPE_MIN_VALUE (*type_p));
11697 WALK_SUBTREE (TYPE_MAX_VALUE (*type_p));
11698 }
11699
11700 WALK_SUBTREE (TYPE_SIZE (*type_p));
11701 WALK_SUBTREE_TAIL (TYPE_SIZE_UNIT (*type_p));
11702 }
11703 /* FALLTHRU */
11704
11705 default:
11706 if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (code)))
11707 {
11708 int i, len;
11709
11710 /* Walk over all the sub-trees of this operand. */
11711 len = TREE_OPERAND_LENGTH (*tp);
11712
11713 /* Go through the subtrees. We need to do this in forward order so
11714 that the scope of a FOR_EXPR is handled properly. */
11715 if (len)
11716 {
11717 for (i = 0; i < len - 1; ++i)
11718 WALK_SUBTREE (TREE_OPERAND (*tp, i));
11719 WALK_SUBTREE_TAIL (TREE_OPERAND (*tp, len - 1));
11720 }
11721 }
11722 /* If this is a type, walk the needed fields in the type. */
11723 else if (TYPE_P (*tp))
11724 return walk_type_fields (*tp, func, data, pset, lh);
11725 break;
11726 }
11727
11728 /* We didn't find what we were looking for. */
11729 return NULL_TREE;
11730
11731 #undef WALK_SUBTREE_TAIL
11732 }
11733 #undef WALK_SUBTREE
11734
11735 /* Like walk_tree, but does not walk duplicate nodes more than once. */
11736
11737 tree
walk_tree_without_duplicates_1(tree * tp,walk_tree_fn func,void * data,walk_tree_lh lh)11738 walk_tree_without_duplicates_1 (tree *tp, walk_tree_fn func, void *data,
11739 walk_tree_lh lh)
11740 {
11741 tree result;
11742
11743 hash_set<tree> pset;
11744 result = walk_tree_1 (tp, func, data, &pset, lh);
11745 return result;
11746 }
11747
11748
11749 tree
tree_block(tree t)11750 tree_block (tree t)
11751 {
11752 const enum tree_code_class c = TREE_CODE_CLASS (TREE_CODE (t));
11753
11754 if (IS_EXPR_CODE_CLASS (c))
11755 return LOCATION_BLOCK (t->exp.locus);
11756 gcc_unreachable ();
11757 return NULL;
11758 }
11759
11760 void
tree_set_block(tree t,tree b)11761 tree_set_block (tree t, tree b)
11762 {
11763 const enum tree_code_class c = TREE_CODE_CLASS (TREE_CODE (t));
11764
11765 if (IS_EXPR_CODE_CLASS (c))
11766 {
11767 t->exp.locus = set_block (t->exp.locus, b);
11768 }
11769 else
11770 gcc_unreachable ();
11771 }
11772
11773 /* Create a nameless artificial label and put it in the current
11774 function context. The label has a location of LOC. Returns the
11775 newly created label. */
11776
11777 tree
create_artificial_label(location_t loc)11778 create_artificial_label (location_t loc)
11779 {
11780 tree lab = build_decl (loc,
11781 LABEL_DECL, NULL_TREE, void_type_node);
11782
11783 DECL_ARTIFICIAL (lab) = 1;
11784 DECL_IGNORED_P (lab) = 1;
11785 DECL_CONTEXT (lab) = current_function_decl;
11786 return lab;
11787 }
11788
11789 /* Given a tree, try to return a useful variable name that we can use
11790 to prefix a temporary that is being assigned the value of the tree.
11791 I.E. given <temp> = &A, return A. */
11792
11793 const char *
get_name(tree t)11794 get_name (tree t)
11795 {
11796 tree stripped_decl;
11797
11798 stripped_decl = t;
11799 STRIP_NOPS (stripped_decl);
11800 if (DECL_P (stripped_decl) && DECL_NAME (stripped_decl))
11801 return IDENTIFIER_POINTER (DECL_NAME (stripped_decl));
11802 else if (TREE_CODE (stripped_decl) == SSA_NAME)
11803 {
11804 tree name = SSA_NAME_IDENTIFIER (stripped_decl);
11805 if (!name)
11806 return NULL;
11807 return IDENTIFIER_POINTER (name);
11808 }
11809 else
11810 {
11811 switch (TREE_CODE (stripped_decl))
11812 {
11813 case ADDR_EXPR:
11814 return get_name (TREE_OPERAND (stripped_decl, 0));
11815 default:
11816 return NULL;
11817 }
11818 }
11819 }
11820
11821 /* Return true if TYPE has a variable argument list. */
11822
11823 bool
stdarg_p(const_tree fntype)11824 stdarg_p (const_tree fntype)
11825 {
11826 function_args_iterator args_iter;
11827 tree n = NULL_TREE, t;
11828
11829 if (!fntype)
11830 return false;
11831
11832 FOREACH_FUNCTION_ARGS (fntype, t, args_iter)
11833 {
11834 n = t;
11835 }
11836
11837 return n != NULL_TREE && n != void_type_node;
11838 }
11839
11840 /* Return true if TYPE has a prototype. */
11841
11842 bool
prototype_p(const_tree fntype)11843 prototype_p (const_tree fntype)
11844 {
11845 tree t;
11846
11847 gcc_assert (fntype != NULL_TREE);
11848
11849 t = TYPE_ARG_TYPES (fntype);
11850 return (t != NULL_TREE);
11851 }
11852
11853 /* If BLOCK is inlined from an __attribute__((__artificial__))
11854 routine, return pointer to location from where it has been
11855 called. */
11856 location_t *
block_nonartificial_location(tree block)11857 block_nonartificial_location (tree block)
11858 {
11859 location_t *ret = NULL;
11860
11861 while (block && TREE_CODE (block) == BLOCK
11862 && BLOCK_ABSTRACT_ORIGIN (block))
11863 {
11864 tree ao = BLOCK_ABSTRACT_ORIGIN (block);
11865
11866 while (TREE_CODE (ao) == BLOCK
11867 && BLOCK_ABSTRACT_ORIGIN (ao)
11868 && BLOCK_ABSTRACT_ORIGIN (ao) != ao)
11869 ao = BLOCK_ABSTRACT_ORIGIN (ao);
11870
11871 if (TREE_CODE (ao) == FUNCTION_DECL)
11872 {
11873 /* If AO is an artificial inline, point RET to the
11874 call site locus at which it has been inlined and continue
11875 the loop, in case AO's caller is also an artificial
11876 inline. */
11877 if (DECL_DECLARED_INLINE_P (ao)
11878 && lookup_attribute ("artificial", DECL_ATTRIBUTES (ao)))
11879 ret = &BLOCK_SOURCE_LOCATION (block);
11880 else
11881 break;
11882 }
11883 else if (TREE_CODE (ao) != BLOCK)
11884 break;
11885
11886 block = BLOCK_SUPERCONTEXT (block);
11887 }
11888 return ret;
11889 }
11890
11891
11892 /* If EXP is inlined from an __attribute__((__artificial__))
11893 function, return the location of the original call expression. */
11894
11895 location_t
tree_nonartificial_location(tree exp)11896 tree_nonartificial_location (tree exp)
11897 {
11898 location_t *loc = block_nonartificial_location (TREE_BLOCK (exp));
11899
11900 if (loc)
11901 return *loc;
11902 else
11903 return EXPR_LOCATION (exp);
11904 }
11905
11906
11907 /* These are the hash table functions for the hash table of OPTIMIZATION_NODEq
11908 nodes. */
11909
11910 /* Return the hash code X, an OPTIMIZATION_NODE or TARGET_OPTION code. */
11911
11912 hashval_t
hash(tree x)11913 cl_option_hasher::hash (tree x)
11914 {
11915 const_tree const t = x;
11916 const char *p;
11917 size_t i;
11918 size_t len = 0;
11919 hashval_t hash = 0;
11920
11921 if (TREE_CODE (t) == OPTIMIZATION_NODE)
11922 {
11923 p = (const char *)TREE_OPTIMIZATION (t);
11924 len = sizeof (struct cl_optimization);
11925 }
11926
11927 else if (TREE_CODE (t) == TARGET_OPTION_NODE)
11928 return cl_target_option_hash (TREE_TARGET_OPTION (t));
11929
11930 else
11931 gcc_unreachable ();
11932
11933 /* assume most opt flags are just 0/1, some are 2-3, and a few might be
11934 something else. */
11935 for (i = 0; i < len; i++)
11936 if (p[i])
11937 hash = (hash << 4) ^ ((i << 2) | p[i]);
11938
11939 return hash;
11940 }
11941
11942 /* Return nonzero if the value represented by *X (an OPTIMIZATION or
11943 TARGET_OPTION tree node) is the same as that given by *Y, which is the
11944 same. */
11945
11946 bool
equal(tree x,tree y)11947 cl_option_hasher::equal (tree x, tree y)
11948 {
11949 const_tree const xt = x;
11950 const_tree const yt = y;
11951 const char *xp;
11952 const char *yp;
11953 size_t len;
11954
11955 if (TREE_CODE (xt) != TREE_CODE (yt))
11956 return 0;
11957
11958 if (TREE_CODE (xt) == OPTIMIZATION_NODE)
11959 {
11960 xp = (const char *)TREE_OPTIMIZATION (xt);
11961 yp = (const char *)TREE_OPTIMIZATION (yt);
11962 len = sizeof (struct cl_optimization);
11963 }
11964
11965 else if (TREE_CODE (xt) == TARGET_OPTION_NODE)
11966 {
11967 return cl_target_option_eq (TREE_TARGET_OPTION (xt),
11968 TREE_TARGET_OPTION (yt));
11969 }
11970
11971 else
11972 gcc_unreachable ();
11973
11974 return (memcmp (xp, yp, len) == 0);
11975 }
11976
11977 /* Build an OPTIMIZATION_NODE based on the options in OPTS. */
11978
11979 tree
build_optimization_node(struct gcc_options * opts)11980 build_optimization_node (struct gcc_options *opts)
11981 {
11982 tree t;
11983
11984 /* Use the cache of optimization nodes. */
11985
11986 cl_optimization_save (TREE_OPTIMIZATION (cl_optimization_node),
11987 opts);
11988
11989 tree *slot = cl_option_hash_table->find_slot (cl_optimization_node, INSERT);
11990 t = *slot;
11991 if (!t)
11992 {
11993 /* Insert this one into the hash table. */
11994 t = cl_optimization_node;
11995 *slot = t;
11996
11997 /* Make a new node for next time round. */
11998 cl_optimization_node = make_node (OPTIMIZATION_NODE);
11999 }
12000
12001 return t;
12002 }
12003
12004 /* Build a TARGET_OPTION_NODE based on the options in OPTS. */
12005
12006 tree
build_target_option_node(struct gcc_options * opts)12007 build_target_option_node (struct gcc_options *opts)
12008 {
12009 tree t;
12010
12011 /* Use the cache of optimization nodes. */
12012
12013 cl_target_option_save (TREE_TARGET_OPTION (cl_target_option_node),
12014 opts);
12015
12016 tree *slot = cl_option_hash_table->find_slot (cl_target_option_node, INSERT);
12017 t = *slot;
12018 if (!t)
12019 {
12020 /* Insert this one into the hash table. */
12021 t = cl_target_option_node;
12022 *slot = t;
12023
12024 /* Make a new node for next time round. */
12025 cl_target_option_node = make_node (TARGET_OPTION_NODE);
12026 }
12027
12028 return t;
12029 }
12030
12031 /* Clear TREE_TARGET_GLOBALS of all TARGET_OPTION_NODE trees,
12032 so that they aren't saved during PCH writing. */
12033
12034 void
prepare_target_option_nodes_for_pch(void)12035 prepare_target_option_nodes_for_pch (void)
12036 {
12037 hash_table<cl_option_hasher>::iterator iter = cl_option_hash_table->begin ();
12038 for (; iter != cl_option_hash_table->end (); ++iter)
12039 if (TREE_CODE (*iter) == TARGET_OPTION_NODE)
12040 TREE_TARGET_GLOBALS (*iter) = NULL;
12041 }
12042
12043 /* Determine the "ultimate origin" of a block. The block may be an inlined
12044 instance of an inlined instance of a block which is local to an inline
12045 function, so we have to trace all of the way back through the origin chain
12046 to find out what sort of node actually served as the original seed for the
12047 given block. */
12048
12049 tree
block_ultimate_origin(const_tree block)12050 block_ultimate_origin (const_tree block)
12051 {
12052 tree immediate_origin = BLOCK_ABSTRACT_ORIGIN (block);
12053
12054 /* BLOCK_ABSTRACT_ORIGIN can point to itself; ignore that if
12055 we're trying to output the abstract instance of this function. */
12056 if (BLOCK_ABSTRACT (block) && immediate_origin == block)
12057 return NULL_TREE;
12058
12059 if (immediate_origin == NULL_TREE)
12060 return NULL_TREE;
12061 else
12062 {
12063 tree ret_val;
12064 tree lookahead = immediate_origin;
12065
12066 do
12067 {
12068 ret_val = lookahead;
12069 lookahead = (TREE_CODE (ret_val) == BLOCK
12070 ? BLOCK_ABSTRACT_ORIGIN (ret_val) : NULL);
12071 }
12072 while (lookahead != NULL && lookahead != ret_val);
12073
12074 /* The block's abstract origin chain may not be the *ultimate* origin of
12075 the block. It could lead to a DECL that has an abstract origin set.
12076 If so, we want that DECL's abstract origin (which is what DECL_ORIGIN
12077 will give us if it has one). Note that DECL's abstract origins are
12078 supposed to be the most distant ancestor (or so decl_ultimate_origin
12079 claims), so we don't need to loop following the DECL origins. */
12080 if (DECL_P (ret_val))
12081 return DECL_ORIGIN (ret_val);
12082
12083 return ret_val;
12084 }
12085 }
12086
12087 /* Return true iff conversion from INNER_TYPE to OUTER_TYPE generates
12088 no instruction. */
12089
12090 bool
tree_nop_conversion_p(const_tree outer_type,const_tree inner_type)12091 tree_nop_conversion_p (const_tree outer_type, const_tree inner_type)
12092 {
12093 /* Do not strip casts into or out of differing address spaces. */
12094 if (POINTER_TYPE_P (outer_type)
12095 && TYPE_ADDR_SPACE (TREE_TYPE (outer_type)) != ADDR_SPACE_GENERIC)
12096 {
12097 if (!POINTER_TYPE_P (inner_type)
12098 || (TYPE_ADDR_SPACE (TREE_TYPE (outer_type))
12099 != TYPE_ADDR_SPACE (TREE_TYPE (inner_type))))
12100 return false;
12101 }
12102 else if (POINTER_TYPE_P (inner_type)
12103 && TYPE_ADDR_SPACE (TREE_TYPE (inner_type)) != ADDR_SPACE_GENERIC)
12104 {
12105 /* We already know that outer_type is not a pointer with
12106 a non-generic address space. */
12107 return false;
12108 }
12109
12110 /* Use precision rather then machine mode when we can, which gives
12111 the correct answer even for submode (bit-field) types. */
12112 if ((INTEGRAL_TYPE_P (outer_type)
12113 || POINTER_TYPE_P (outer_type)
12114 || TREE_CODE (outer_type) == OFFSET_TYPE)
12115 && (INTEGRAL_TYPE_P (inner_type)
12116 || POINTER_TYPE_P (inner_type)
12117 || TREE_CODE (inner_type) == OFFSET_TYPE))
12118 return TYPE_PRECISION (outer_type) == TYPE_PRECISION (inner_type);
12119
12120 /* Otherwise fall back on comparing machine modes (e.g. for
12121 aggregate types, floats). */
12122 return TYPE_MODE (outer_type) == TYPE_MODE (inner_type);
12123 }
12124
12125 /* Return true iff conversion in EXP generates no instruction. Mark
12126 it inline so that we fully inline into the stripping functions even
12127 though we have two uses of this function. */
12128
12129 static inline bool
tree_nop_conversion(const_tree exp)12130 tree_nop_conversion (const_tree exp)
12131 {
12132 tree outer_type, inner_type;
12133
12134 if (location_wrapper_p (exp))
12135 return true;
12136 if (!CONVERT_EXPR_P (exp)
12137 && TREE_CODE (exp) != NON_LVALUE_EXPR)
12138 return false;
12139 if (TREE_OPERAND (exp, 0) == error_mark_node)
12140 return false;
12141
12142 outer_type = TREE_TYPE (exp);
12143 inner_type = TREE_TYPE (TREE_OPERAND (exp, 0));
12144
12145 if (!inner_type)
12146 return false;
12147
12148 return tree_nop_conversion_p (outer_type, inner_type);
12149 }
12150
12151 /* Return true iff conversion in EXP generates no instruction. Don't
12152 consider conversions changing the signedness. */
12153
12154 static bool
tree_sign_nop_conversion(const_tree exp)12155 tree_sign_nop_conversion (const_tree exp)
12156 {
12157 tree outer_type, inner_type;
12158
12159 if (!tree_nop_conversion (exp))
12160 return false;
12161
12162 outer_type = TREE_TYPE (exp);
12163 inner_type = TREE_TYPE (TREE_OPERAND (exp, 0));
12164
12165 return (TYPE_UNSIGNED (outer_type) == TYPE_UNSIGNED (inner_type)
12166 && POINTER_TYPE_P (outer_type) == POINTER_TYPE_P (inner_type));
12167 }
12168
12169 /* Strip conversions from EXP according to tree_nop_conversion and
12170 return the resulting expression. */
12171
12172 tree
tree_strip_nop_conversions(tree exp)12173 tree_strip_nop_conversions (tree exp)
12174 {
12175 while (tree_nop_conversion (exp))
12176 exp = TREE_OPERAND (exp, 0);
12177 return exp;
12178 }
12179
12180 /* Strip conversions from EXP according to tree_sign_nop_conversion
12181 and return the resulting expression. */
12182
12183 tree
tree_strip_sign_nop_conversions(tree exp)12184 tree_strip_sign_nop_conversions (tree exp)
12185 {
12186 while (tree_sign_nop_conversion (exp))
12187 exp = TREE_OPERAND (exp, 0);
12188 return exp;
12189 }
12190
12191 /* Avoid any floating point extensions from EXP. */
12192 tree
strip_float_extensions(tree exp)12193 strip_float_extensions (tree exp)
12194 {
12195 tree sub, expt, subt;
12196
12197 /* For floating point constant look up the narrowest type that can hold
12198 it properly and handle it like (type)(narrowest_type)constant.
12199 This way we can optimize for instance a=a*2.0 where "a" is float
12200 but 2.0 is double constant. */
12201 if (TREE_CODE (exp) == REAL_CST && !DECIMAL_FLOAT_TYPE_P (TREE_TYPE (exp)))
12202 {
12203 REAL_VALUE_TYPE orig;
12204 tree type = NULL;
12205
12206 orig = TREE_REAL_CST (exp);
12207 if (TYPE_PRECISION (TREE_TYPE (exp)) > TYPE_PRECISION (float_type_node)
12208 && exact_real_truncate (TYPE_MODE (float_type_node), &orig))
12209 type = float_type_node;
12210 else if (TYPE_PRECISION (TREE_TYPE (exp))
12211 > TYPE_PRECISION (double_type_node)
12212 && exact_real_truncate (TYPE_MODE (double_type_node), &orig))
12213 type = double_type_node;
12214 if (type)
12215 return build_real_truncate (type, orig);
12216 }
12217
12218 if (!CONVERT_EXPR_P (exp))
12219 return exp;
12220
12221 sub = TREE_OPERAND (exp, 0);
12222 subt = TREE_TYPE (sub);
12223 expt = TREE_TYPE (exp);
12224
12225 if (!FLOAT_TYPE_P (subt))
12226 return exp;
12227
12228 if (DECIMAL_FLOAT_TYPE_P (expt) != DECIMAL_FLOAT_TYPE_P (subt))
12229 return exp;
12230
12231 if (TYPE_PRECISION (subt) > TYPE_PRECISION (expt))
12232 return exp;
12233
12234 return strip_float_extensions (sub);
12235 }
12236
12237 /* Strip out all handled components that produce invariant
12238 offsets. */
12239
12240 const_tree
strip_invariant_refs(const_tree op)12241 strip_invariant_refs (const_tree op)
12242 {
12243 while (handled_component_p (op))
12244 {
12245 switch (TREE_CODE (op))
12246 {
12247 case ARRAY_REF:
12248 case ARRAY_RANGE_REF:
12249 if (!is_gimple_constant (TREE_OPERAND (op, 1))
12250 || TREE_OPERAND (op, 2) != NULL_TREE
12251 || TREE_OPERAND (op, 3) != NULL_TREE)
12252 return NULL;
12253 break;
12254
12255 case COMPONENT_REF:
12256 if (TREE_OPERAND (op, 2) != NULL_TREE)
12257 return NULL;
12258 break;
12259
12260 default:;
12261 }
12262 op = TREE_OPERAND (op, 0);
12263 }
12264
12265 return op;
12266 }
12267
12268 static GTY(()) tree gcc_eh_personality_decl;
12269
12270 /* Return the GCC personality function decl. */
12271
12272 tree
lhd_gcc_personality(void)12273 lhd_gcc_personality (void)
12274 {
12275 if (!gcc_eh_personality_decl)
12276 gcc_eh_personality_decl = build_personality_function ("gcc");
12277 return gcc_eh_personality_decl;
12278 }
12279
12280 /* TARGET is a call target of GIMPLE call statement
12281 (obtained by gimple_call_fn). Return true if it is
12282 OBJ_TYPE_REF representing an virtual call of C++ method.
12283 (As opposed to OBJ_TYPE_REF representing objc calls
12284 through a cast where middle-end devirtualization machinery
12285 can't apply.) */
12286
12287 bool
virtual_method_call_p(const_tree target)12288 virtual_method_call_p (const_tree target)
12289 {
12290 if (TREE_CODE (target) != OBJ_TYPE_REF)
12291 return false;
12292 tree t = TREE_TYPE (target);
12293 gcc_checking_assert (TREE_CODE (t) == POINTER_TYPE);
12294 t = TREE_TYPE (t);
12295 if (TREE_CODE (t) == FUNCTION_TYPE)
12296 return false;
12297 gcc_checking_assert (TREE_CODE (t) == METHOD_TYPE);
12298 /* If we do not have BINFO associated, it means that type was built
12299 without devirtualization enabled. Do not consider this a virtual
12300 call. */
12301 if (!TYPE_BINFO (obj_type_ref_class (target)))
12302 return false;
12303 return true;
12304 }
12305
12306 /* REF is OBJ_TYPE_REF, return the class the ref corresponds to. */
12307
12308 tree
obj_type_ref_class(const_tree ref)12309 obj_type_ref_class (const_tree ref)
12310 {
12311 gcc_checking_assert (TREE_CODE (ref) == OBJ_TYPE_REF);
12312 ref = TREE_TYPE (ref);
12313 gcc_checking_assert (TREE_CODE (ref) == POINTER_TYPE);
12314 ref = TREE_TYPE (ref);
12315 /* We look for type THIS points to. ObjC also builds
12316 OBJ_TYPE_REF with non-method calls, Their first parameter
12317 ID however also corresponds to class type. */
12318 gcc_checking_assert (TREE_CODE (ref) == METHOD_TYPE
12319 || TREE_CODE (ref) == FUNCTION_TYPE);
12320 ref = TREE_VALUE (TYPE_ARG_TYPES (ref));
12321 gcc_checking_assert (TREE_CODE (ref) == POINTER_TYPE);
12322 return TREE_TYPE (ref);
12323 }
12324
12325 /* Lookup sub-BINFO of BINFO of TYPE at offset POS. */
12326
12327 static tree
lookup_binfo_at_offset(tree binfo,tree type,HOST_WIDE_INT pos)12328 lookup_binfo_at_offset (tree binfo, tree type, HOST_WIDE_INT pos)
12329 {
12330 unsigned int i;
12331 tree base_binfo, b;
12332
12333 for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
12334 if (pos == tree_to_shwi (BINFO_OFFSET (base_binfo))
12335 && types_same_for_odr (TREE_TYPE (base_binfo), type))
12336 return base_binfo;
12337 else if ((b = lookup_binfo_at_offset (base_binfo, type, pos)) != NULL)
12338 return b;
12339 return NULL;
12340 }
12341
12342 /* Try to find a base info of BINFO that would have its field decl at offset
12343 OFFSET within the BINFO type and which is of EXPECTED_TYPE. If it can be
12344 found, return, otherwise return NULL_TREE. */
12345
12346 tree
get_binfo_at_offset(tree binfo,poly_int64 offset,tree expected_type)12347 get_binfo_at_offset (tree binfo, poly_int64 offset, tree expected_type)
12348 {
12349 tree type = BINFO_TYPE (binfo);
12350
12351 while (true)
12352 {
12353 HOST_WIDE_INT pos, size;
12354 tree fld;
12355 int i;
12356
12357 if (types_same_for_odr (type, expected_type))
12358 return binfo;
12359 if (maybe_lt (offset, 0))
12360 return NULL_TREE;
12361
12362 for (fld = TYPE_FIELDS (type); fld; fld = DECL_CHAIN (fld))
12363 {
12364 if (TREE_CODE (fld) != FIELD_DECL || !DECL_ARTIFICIAL (fld))
12365 continue;
12366
12367 pos = int_bit_position (fld);
12368 size = tree_to_uhwi (DECL_SIZE (fld));
12369 if (known_in_range_p (offset, pos, size))
12370 break;
12371 }
12372 if (!fld || TREE_CODE (TREE_TYPE (fld)) != RECORD_TYPE)
12373 return NULL_TREE;
12374
12375 /* Offset 0 indicates the primary base, whose vtable contents are
12376 represented in the binfo for the derived class. */
12377 else if (maybe_ne (offset, 0))
12378 {
12379 tree found_binfo = NULL, base_binfo;
12380 /* Offsets in BINFO are in bytes relative to the whole structure
12381 while POS is in bits relative to the containing field. */
12382 int binfo_offset = (tree_to_shwi (BINFO_OFFSET (binfo)) + pos
12383 / BITS_PER_UNIT);
12384
12385 for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
12386 if (tree_to_shwi (BINFO_OFFSET (base_binfo)) == binfo_offset
12387 && types_same_for_odr (TREE_TYPE (base_binfo), TREE_TYPE (fld)))
12388 {
12389 found_binfo = base_binfo;
12390 break;
12391 }
12392 if (found_binfo)
12393 binfo = found_binfo;
12394 else
12395 binfo = lookup_binfo_at_offset (binfo, TREE_TYPE (fld),
12396 binfo_offset);
12397 }
12398
12399 type = TREE_TYPE (fld);
12400 offset -= pos;
12401 }
12402 }
12403
12404 /* Returns true if X is a typedef decl. */
12405
12406 bool
is_typedef_decl(const_tree x)12407 is_typedef_decl (const_tree x)
12408 {
12409 return (x && TREE_CODE (x) == TYPE_DECL
12410 && DECL_ORIGINAL_TYPE (x) != NULL_TREE);
12411 }
12412
12413 /* Returns true iff TYPE is a type variant created for a typedef. */
12414
12415 bool
typedef_variant_p(const_tree type)12416 typedef_variant_p (const_tree type)
12417 {
12418 return is_typedef_decl (TYPE_NAME (type));
12419 }
12420
12421 /* Warn about a use of an identifier which was marked deprecated. */
12422 void
warn_deprecated_use(tree node,tree attr)12423 warn_deprecated_use (tree node, tree attr)
12424 {
12425 const char *msg;
12426
12427 if (node == 0 || !warn_deprecated_decl)
12428 return;
12429
12430 if (!attr)
12431 {
12432 if (DECL_P (node))
12433 attr = DECL_ATTRIBUTES (node);
12434 else if (TYPE_P (node))
12435 {
12436 tree decl = TYPE_STUB_DECL (node);
12437 if (decl)
12438 attr = lookup_attribute ("deprecated",
12439 TYPE_ATTRIBUTES (TREE_TYPE (decl)));
12440 }
12441 }
12442
12443 if (attr)
12444 attr = lookup_attribute ("deprecated", attr);
12445
12446 if (attr)
12447 msg = TREE_STRING_POINTER (TREE_VALUE (TREE_VALUE (attr)));
12448 else
12449 msg = NULL;
12450
12451 bool w;
12452 if (DECL_P (node))
12453 {
12454 if (msg)
12455 w = warning (OPT_Wdeprecated_declarations,
12456 "%qD is deprecated: %s", node, msg);
12457 else
12458 w = warning (OPT_Wdeprecated_declarations,
12459 "%qD is deprecated", node);
12460 if (w)
12461 inform (DECL_SOURCE_LOCATION (node), "declared here");
12462 }
12463 else if (TYPE_P (node))
12464 {
12465 tree what = NULL_TREE;
12466 tree decl = TYPE_STUB_DECL (node);
12467
12468 if (TYPE_NAME (node))
12469 {
12470 if (TREE_CODE (TYPE_NAME (node)) == IDENTIFIER_NODE)
12471 what = TYPE_NAME (node);
12472 else if (TREE_CODE (TYPE_NAME (node)) == TYPE_DECL
12473 && DECL_NAME (TYPE_NAME (node)))
12474 what = DECL_NAME (TYPE_NAME (node));
12475 }
12476
12477 if (decl)
12478 {
12479 if (what)
12480 {
12481 if (msg)
12482 w = warning (OPT_Wdeprecated_declarations,
12483 "%qE is deprecated: %s", what, msg);
12484 else
12485 w = warning (OPT_Wdeprecated_declarations,
12486 "%qE is deprecated", what);
12487 }
12488 else
12489 {
12490 if (msg)
12491 w = warning (OPT_Wdeprecated_declarations,
12492 "type is deprecated: %s", msg);
12493 else
12494 w = warning (OPT_Wdeprecated_declarations,
12495 "type is deprecated");
12496 }
12497 if (w)
12498 inform (DECL_SOURCE_LOCATION (decl), "declared here");
12499 }
12500 else
12501 {
12502 if (what)
12503 {
12504 if (msg)
12505 warning (OPT_Wdeprecated_declarations, "%qE is deprecated: %s",
12506 what, msg);
12507 else
12508 warning (OPT_Wdeprecated_declarations, "%qE is deprecated", what);
12509 }
12510 else
12511 {
12512 if (msg)
12513 warning (OPT_Wdeprecated_declarations, "type is deprecated: %s",
12514 msg);
12515 else
12516 warning (OPT_Wdeprecated_declarations, "type is deprecated");
12517 }
12518 }
12519 }
12520 }
12521
12522 /* Return true if REF has a COMPONENT_REF with a bit-field field declaration
12523 somewhere in it. */
12524
12525 bool
contains_bitfld_component_ref_p(const_tree ref)12526 contains_bitfld_component_ref_p (const_tree ref)
12527 {
12528 while (handled_component_p (ref))
12529 {
12530 if (TREE_CODE (ref) == COMPONENT_REF
12531 && DECL_BIT_FIELD (TREE_OPERAND (ref, 1)))
12532 return true;
12533 ref = TREE_OPERAND (ref, 0);
12534 }
12535
12536 return false;
12537 }
12538
12539 /* Try to determine whether a TRY_CATCH expression can fall through.
12540 This is a subroutine of block_may_fallthru. */
12541
12542 static bool
try_catch_may_fallthru(const_tree stmt)12543 try_catch_may_fallthru (const_tree stmt)
12544 {
12545 tree_stmt_iterator i;
12546
12547 /* If the TRY block can fall through, the whole TRY_CATCH can
12548 fall through. */
12549 if (block_may_fallthru (TREE_OPERAND (stmt, 0)))
12550 return true;
12551
12552 i = tsi_start (TREE_OPERAND (stmt, 1));
12553 switch (TREE_CODE (tsi_stmt (i)))
12554 {
12555 case CATCH_EXPR:
12556 /* We expect to see a sequence of CATCH_EXPR trees, each with a
12557 catch expression and a body. The whole TRY_CATCH may fall
12558 through iff any of the catch bodies falls through. */
12559 for (; !tsi_end_p (i); tsi_next (&i))
12560 {
12561 if (block_may_fallthru (CATCH_BODY (tsi_stmt (i))))
12562 return true;
12563 }
12564 return false;
12565
12566 case EH_FILTER_EXPR:
12567 /* The exception filter expression only matters if there is an
12568 exception. If the exception does not match EH_FILTER_TYPES,
12569 we will execute EH_FILTER_FAILURE, and we will fall through
12570 if that falls through. If the exception does match
12571 EH_FILTER_TYPES, the stack unwinder will continue up the
12572 stack, so we will not fall through. We don't know whether we
12573 will throw an exception which matches EH_FILTER_TYPES or not,
12574 so we just ignore EH_FILTER_TYPES and assume that we might
12575 throw an exception which doesn't match. */
12576 return block_may_fallthru (EH_FILTER_FAILURE (tsi_stmt (i)));
12577
12578 default:
12579 /* This case represents statements to be executed when an
12580 exception occurs. Those statements are implicitly followed
12581 by a RESX statement to resume execution after the exception.
12582 So in this case the TRY_CATCH never falls through. */
12583 return false;
12584 }
12585 }
12586
12587 /* Try to determine if we can fall out of the bottom of BLOCK. This guess
12588 need not be 100% accurate; simply be conservative and return true if we
12589 don't know. This is used only to avoid stupidly generating extra code.
12590 If we're wrong, we'll just delete the extra code later. */
12591
12592 bool
block_may_fallthru(const_tree block)12593 block_may_fallthru (const_tree block)
12594 {
12595 /* This CONST_CAST is okay because expr_last returns its argument
12596 unmodified and we assign it to a const_tree. */
12597 const_tree stmt = expr_last (CONST_CAST_TREE (block));
12598
12599 switch (stmt ? TREE_CODE (stmt) : ERROR_MARK)
12600 {
12601 case GOTO_EXPR:
12602 case RETURN_EXPR:
12603 /* Easy cases. If the last statement of the block implies
12604 control transfer, then we can't fall through. */
12605 return false;
12606
12607 case SWITCH_EXPR:
12608 /* If there is a default: label or case labels cover all possible
12609 SWITCH_COND values, then the SWITCH_EXPR will transfer control
12610 to some case label in all cases and all we care is whether the
12611 SWITCH_BODY falls through. */
12612 if (SWITCH_ALL_CASES_P (stmt))
12613 return block_may_fallthru (SWITCH_BODY (stmt));
12614 return true;
12615
12616 case COND_EXPR:
12617 if (block_may_fallthru (COND_EXPR_THEN (stmt)))
12618 return true;
12619 return block_may_fallthru (COND_EXPR_ELSE (stmt));
12620
12621 case BIND_EXPR:
12622 return block_may_fallthru (BIND_EXPR_BODY (stmt));
12623
12624 case TRY_CATCH_EXPR:
12625 return try_catch_may_fallthru (stmt);
12626
12627 case TRY_FINALLY_EXPR:
12628 /* The finally clause is always executed after the try clause,
12629 so if it does not fall through, then the try-finally will not
12630 fall through. Otherwise, if the try clause does not fall
12631 through, then when the finally clause falls through it will
12632 resume execution wherever the try clause was going. So the
12633 whole try-finally will only fall through if both the try
12634 clause and the finally clause fall through. */
12635 return (block_may_fallthru (TREE_OPERAND (stmt, 0))
12636 && block_may_fallthru (TREE_OPERAND (stmt, 1)));
12637
12638 case MODIFY_EXPR:
12639 if (TREE_CODE (TREE_OPERAND (stmt, 1)) == CALL_EXPR)
12640 stmt = TREE_OPERAND (stmt, 1);
12641 else
12642 return true;
12643 /* FALLTHRU */
12644
12645 case CALL_EXPR:
12646 /* Functions that do not return do not fall through. */
12647 return (call_expr_flags (stmt) & ECF_NORETURN) == 0;
12648
12649 case CLEANUP_POINT_EXPR:
12650 return block_may_fallthru (TREE_OPERAND (stmt, 0));
12651
12652 case TARGET_EXPR:
12653 return block_may_fallthru (TREE_OPERAND (stmt, 1));
12654
12655 case ERROR_MARK:
12656 return true;
12657
12658 default:
12659 return lang_hooks.block_may_fallthru (stmt);
12660 }
12661 }
12662
12663 /* True if we are using EH to handle cleanups. */
12664 static bool using_eh_for_cleanups_flag = false;
12665
12666 /* This routine is called from front ends to indicate eh should be used for
12667 cleanups. */
12668 void
using_eh_for_cleanups(void)12669 using_eh_for_cleanups (void)
12670 {
12671 using_eh_for_cleanups_flag = true;
12672 }
12673
12674 /* Query whether EH is used for cleanups. */
12675 bool
using_eh_for_cleanups_p(void)12676 using_eh_for_cleanups_p (void)
12677 {
12678 return using_eh_for_cleanups_flag;
12679 }
12680
12681 /* Wrapper for tree_code_name to ensure that tree code is valid */
12682 const char *
get_tree_code_name(enum tree_code code)12683 get_tree_code_name (enum tree_code code)
12684 {
12685 const char *invalid = "<invalid tree code>";
12686
12687 if (code >= MAX_TREE_CODES)
12688 return invalid;
12689
12690 return tree_code_name[code];
12691 }
12692
12693 /* Drops the TREE_OVERFLOW flag from T. */
12694
12695 tree
drop_tree_overflow(tree t)12696 drop_tree_overflow (tree t)
12697 {
12698 gcc_checking_assert (TREE_OVERFLOW (t));
12699
12700 /* For tree codes with a sharing machinery re-build the result. */
12701 if (poly_int_tree_p (t))
12702 return wide_int_to_tree (TREE_TYPE (t), wi::to_poly_wide (t));
12703
12704 /* For VECTOR_CST, remove the overflow bits from the encoded elements
12705 and canonicalize the result. */
12706 if (TREE_CODE (t) == VECTOR_CST)
12707 {
12708 tree_vector_builder builder;
12709 builder.new_unary_operation (TREE_TYPE (t), t, true);
12710 unsigned int count = builder.encoded_nelts ();
12711 for (unsigned int i = 0; i < count; ++i)
12712 {
12713 tree elt = VECTOR_CST_ELT (t, i);
12714 if (TREE_OVERFLOW (elt))
12715 elt = drop_tree_overflow (elt);
12716 builder.quick_push (elt);
12717 }
12718 return builder.build ();
12719 }
12720
12721 /* Otherwise, as all tcc_constants are possibly shared, copy the node
12722 and drop the flag. */
12723 t = copy_node (t);
12724 TREE_OVERFLOW (t) = 0;
12725
12726 /* For constants that contain nested constants, drop the flag
12727 from those as well. */
12728 if (TREE_CODE (t) == COMPLEX_CST)
12729 {
12730 if (TREE_OVERFLOW (TREE_REALPART (t)))
12731 TREE_REALPART (t) = drop_tree_overflow (TREE_REALPART (t));
12732 if (TREE_OVERFLOW (TREE_IMAGPART (t)))
12733 TREE_IMAGPART (t) = drop_tree_overflow (TREE_IMAGPART (t));
12734 }
12735
12736 return t;
12737 }
12738
12739 /* Given a memory reference expression T, return its base address.
12740 The base address of a memory reference expression is the main
12741 object being referenced. For instance, the base address for
12742 'array[i].fld[j]' is 'array'. You can think of this as stripping
12743 away the offset part from a memory address.
12744
12745 This function calls handled_component_p to strip away all the inner
12746 parts of the memory reference until it reaches the base object. */
12747
12748 tree
get_base_address(tree t)12749 get_base_address (tree t)
12750 {
12751 while (handled_component_p (t))
12752 t = TREE_OPERAND (t, 0);
12753
12754 if ((TREE_CODE (t) == MEM_REF
12755 || TREE_CODE (t) == TARGET_MEM_REF)
12756 && TREE_CODE (TREE_OPERAND (t, 0)) == ADDR_EXPR)
12757 t = TREE_OPERAND (TREE_OPERAND (t, 0), 0);
12758
12759 /* ??? Either the alias oracle or all callers need to properly deal
12760 with WITH_SIZE_EXPRs before we can look through those. */
12761 if (TREE_CODE (t) == WITH_SIZE_EXPR)
12762 return NULL_TREE;
12763
12764 return t;
12765 }
12766
12767 /* Return a tree of sizetype representing the size, in bytes, of the element
12768 of EXP, an ARRAY_REF or an ARRAY_RANGE_REF. */
12769
12770 tree
array_ref_element_size(tree exp)12771 array_ref_element_size (tree exp)
12772 {
12773 tree aligned_size = TREE_OPERAND (exp, 3);
12774 tree elmt_type = TREE_TYPE (TREE_TYPE (TREE_OPERAND (exp, 0)));
12775 location_t loc = EXPR_LOCATION (exp);
12776
12777 /* If a size was specified in the ARRAY_REF, it's the size measured
12778 in alignment units of the element type. So multiply by that value. */
12779 if (aligned_size)
12780 {
12781 /* ??? tree_ssa_useless_type_conversion will eliminate casts to
12782 sizetype from another type of the same width and signedness. */
12783 if (TREE_TYPE (aligned_size) != sizetype)
12784 aligned_size = fold_convert_loc (loc, sizetype, aligned_size);
12785 return size_binop_loc (loc, MULT_EXPR, aligned_size,
12786 size_int (TYPE_ALIGN_UNIT (elmt_type)));
12787 }
12788
12789 /* Otherwise, take the size from that of the element type. Substitute
12790 any PLACEHOLDER_EXPR that we have. */
12791 else
12792 return SUBSTITUTE_PLACEHOLDER_IN_EXPR (TYPE_SIZE_UNIT (elmt_type), exp);
12793 }
12794
12795 /* Return a tree representing the lower bound of the array mentioned in
12796 EXP, an ARRAY_REF or an ARRAY_RANGE_REF. */
12797
12798 tree
array_ref_low_bound(tree exp)12799 array_ref_low_bound (tree exp)
12800 {
12801 tree domain_type = TYPE_DOMAIN (TREE_TYPE (TREE_OPERAND (exp, 0)));
12802
12803 /* If a lower bound is specified in EXP, use it. */
12804 if (TREE_OPERAND (exp, 2))
12805 return TREE_OPERAND (exp, 2);
12806
12807 /* Otherwise, if there is a domain type and it has a lower bound, use it,
12808 substituting for a PLACEHOLDER_EXPR as needed. */
12809 if (domain_type && TYPE_MIN_VALUE (domain_type))
12810 return SUBSTITUTE_PLACEHOLDER_IN_EXPR (TYPE_MIN_VALUE (domain_type), exp);
12811
12812 /* Otherwise, return a zero of the appropriate type. */
12813 return build_int_cst (TREE_TYPE (TREE_OPERAND (exp, 1)), 0);
12814 }
12815
12816 /* Return a tree representing the upper bound of the array mentioned in
12817 EXP, an ARRAY_REF or an ARRAY_RANGE_REF. */
12818
12819 tree
array_ref_up_bound(tree exp)12820 array_ref_up_bound (tree exp)
12821 {
12822 tree domain_type = TYPE_DOMAIN (TREE_TYPE (TREE_OPERAND (exp, 0)));
12823
12824 /* If there is a domain type and it has an upper bound, use it, substituting
12825 for a PLACEHOLDER_EXPR as needed. */
12826 if (domain_type && TYPE_MAX_VALUE (domain_type))
12827 return SUBSTITUTE_PLACEHOLDER_IN_EXPR (TYPE_MAX_VALUE (domain_type), exp);
12828
12829 /* Otherwise fail. */
12830 return NULL_TREE;
12831 }
12832
12833 /* Returns true if REF is an array reference or a component reference
12834 to an array at the end of a structure.
12835 If this is the case, the array may be allocated larger
12836 than its upper bound implies. */
12837
12838 bool
array_at_struct_end_p(tree ref)12839 array_at_struct_end_p (tree ref)
12840 {
12841 tree atype;
12842
12843 if (TREE_CODE (ref) == ARRAY_REF
12844 || TREE_CODE (ref) == ARRAY_RANGE_REF)
12845 {
12846 atype = TREE_TYPE (TREE_OPERAND (ref, 0));
12847 ref = TREE_OPERAND (ref, 0);
12848 }
12849 else if (TREE_CODE (ref) == COMPONENT_REF
12850 && TREE_CODE (TREE_TYPE (TREE_OPERAND (ref, 1))) == ARRAY_TYPE)
12851 atype = TREE_TYPE (TREE_OPERAND (ref, 1));
12852 else
12853 return false;
12854
12855 if (TREE_CODE (ref) == STRING_CST)
12856 return false;
12857
12858 tree ref_to_array = ref;
12859 while (handled_component_p (ref))
12860 {
12861 /* If the reference chain contains a component reference to a
12862 non-union type and there follows another field the reference
12863 is not at the end of a structure. */
12864 if (TREE_CODE (ref) == COMPONENT_REF)
12865 {
12866 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (ref, 0))) == RECORD_TYPE)
12867 {
12868 tree nextf = DECL_CHAIN (TREE_OPERAND (ref, 1));
12869 while (nextf && TREE_CODE (nextf) != FIELD_DECL)
12870 nextf = DECL_CHAIN (nextf);
12871 if (nextf)
12872 return false;
12873 }
12874 }
12875 /* If we have a multi-dimensional array we do not consider
12876 a non-innermost dimension as flex array if the whole
12877 multi-dimensional array is at struct end.
12878 Same for an array of aggregates with a trailing array
12879 member. */
12880 else if (TREE_CODE (ref) == ARRAY_REF)
12881 return false;
12882 else if (TREE_CODE (ref) == ARRAY_RANGE_REF)
12883 ;
12884 /* If we view an underlying object as sth else then what we
12885 gathered up to now is what we have to rely on. */
12886 else if (TREE_CODE (ref) == VIEW_CONVERT_EXPR)
12887 break;
12888 else
12889 gcc_unreachable ();
12890
12891 ref = TREE_OPERAND (ref, 0);
12892 }
12893
12894 /* The array now is at struct end. Treat flexible arrays as
12895 always subject to extend, even into just padding constrained by
12896 an underlying decl. */
12897 if (! TYPE_SIZE (atype)
12898 || ! TYPE_DOMAIN (atype)
12899 || ! TYPE_MAX_VALUE (TYPE_DOMAIN (atype)))
12900 return true;
12901
12902 if (TREE_CODE (ref) == MEM_REF
12903 && TREE_CODE (TREE_OPERAND (ref, 0)) == ADDR_EXPR)
12904 ref = TREE_OPERAND (TREE_OPERAND (ref, 0), 0);
12905
12906 /* If the reference is based on a declared entity, the size of the array
12907 is constrained by its given domain. (Do not trust commons PR/69368). */
12908 if (DECL_P (ref)
12909 && !(flag_unconstrained_commons
12910 && VAR_P (ref) && DECL_COMMON (ref))
12911 && DECL_SIZE_UNIT (ref)
12912 && TREE_CODE (DECL_SIZE_UNIT (ref)) == INTEGER_CST)
12913 {
12914 /* Check whether the array domain covers all of the available
12915 padding. */
12916 poly_int64 offset;
12917 if (TREE_CODE (TYPE_SIZE_UNIT (TREE_TYPE (atype))) != INTEGER_CST
12918 || TREE_CODE (TYPE_MAX_VALUE (TYPE_DOMAIN (atype))) != INTEGER_CST
12919 || TREE_CODE (TYPE_MIN_VALUE (TYPE_DOMAIN (atype))) != INTEGER_CST)
12920 return true;
12921 if (! get_addr_base_and_unit_offset (ref_to_array, &offset))
12922 return true;
12923
12924 /* If at least one extra element fits it is a flexarray. */
12925 if (known_le ((wi::to_offset (TYPE_MAX_VALUE (TYPE_DOMAIN (atype)))
12926 - wi::to_offset (TYPE_MIN_VALUE (TYPE_DOMAIN (atype)))
12927 + 2)
12928 * wi::to_offset (TYPE_SIZE_UNIT (TREE_TYPE (atype))),
12929 wi::to_offset (DECL_SIZE_UNIT (ref)) - offset))
12930 return true;
12931
12932 return false;
12933 }
12934
12935 return true;
12936 }
12937
12938 /* Return a tree representing the offset, in bytes, of the field referenced
12939 by EXP. This does not include any offset in DECL_FIELD_BIT_OFFSET. */
12940
12941 tree
component_ref_field_offset(tree exp)12942 component_ref_field_offset (tree exp)
12943 {
12944 tree aligned_offset = TREE_OPERAND (exp, 2);
12945 tree field = TREE_OPERAND (exp, 1);
12946 location_t loc = EXPR_LOCATION (exp);
12947
12948 /* If an offset was specified in the COMPONENT_REF, it's the offset measured
12949 in units of DECL_OFFSET_ALIGN / BITS_PER_UNIT. So multiply by that
12950 value. */
12951 if (aligned_offset)
12952 {
12953 /* ??? tree_ssa_useless_type_conversion will eliminate casts to
12954 sizetype from another type of the same width and signedness. */
12955 if (TREE_TYPE (aligned_offset) != sizetype)
12956 aligned_offset = fold_convert_loc (loc, sizetype, aligned_offset);
12957 return size_binop_loc (loc, MULT_EXPR, aligned_offset,
12958 size_int (DECL_OFFSET_ALIGN (field)
12959 / BITS_PER_UNIT));
12960 }
12961
12962 /* Otherwise, take the offset from that of the field. Substitute
12963 any PLACEHOLDER_EXPR that we have. */
12964 else
12965 return SUBSTITUTE_PLACEHOLDER_IN_EXPR (DECL_FIELD_OFFSET (field), exp);
12966 }
12967
12968 /* Return the machine mode of T. For vectors, returns the mode of the
12969 inner type. The main use case is to feed the result to HONOR_NANS,
12970 avoiding the BLKmode that a direct TYPE_MODE (T) might return. */
12971
12972 machine_mode
element_mode(const_tree t)12973 element_mode (const_tree t)
12974 {
12975 if (!TYPE_P (t))
12976 t = TREE_TYPE (t);
12977 if (VECTOR_TYPE_P (t) || TREE_CODE (t) == COMPLEX_TYPE)
12978 t = TREE_TYPE (t);
12979 return TYPE_MODE (t);
12980 }
12981
12982 /* Vector types need to re-check the target flags each time we report
12983 the machine mode. We need to do this because attribute target can
12984 change the result of vector_mode_supported_p and have_regs_of_mode
12985 on a per-function basis. Thus the TYPE_MODE of a VECTOR_TYPE can
12986 change on a per-function basis. */
12987 /* ??? Possibly a better solution is to run through all the types
12988 referenced by a function and re-compute the TYPE_MODE once, rather
12989 than make the TYPE_MODE macro call a function. */
12990
12991 machine_mode
vector_type_mode(const_tree t)12992 vector_type_mode (const_tree t)
12993 {
12994 machine_mode mode;
12995
12996 gcc_assert (TREE_CODE (t) == VECTOR_TYPE);
12997
12998 mode = t->type_common.mode;
12999 if (VECTOR_MODE_P (mode)
13000 && (!targetm.vector_mode_supported_p (mode)
13001 || !have_regs_of_mode[mode]))
13002 {
13003 scalar_int_mode innermode;
13004
13005 /* For integers, try mapping it to a same-sized scalar mode. */
13006 if (is_int_mode (TREE_TYPE (t)->type_common.mode, &innermode))
13007 {
13008 poly_int64 size = (TYPE_VECTOR_SUBPARTS (t)
13009 * GET_MODE_BITSIZE (innermode));
13010 scalar_int_mode mode;
13011 if (int_mode_for_size (size, 0).exists (&mode)
13012 && have_regs_of_mode[mode])
13013 return mode;
13014 }
13015
13016 return BLKmode;
13017 }
13018
13019 return mode;
13020 }
13021
13022 /* Verify that basic properties of T match TV and thus T can be a variant of
13023 TV. TV should be the more specified variant (i.e. the main variant). */
13024
13025 static bool
verify_type_variant(const_tree t,tree tv)13026 verify_type_variant (const_tree t, tree tv)
13027 {
13028 /* Type variant can differ by:
13029
13030 - TYPE_QUALS: TYPE_READONLY, TYPE_VOLATILE, TYPE_ATOMIC, TYPE_RESTRICT,
13031 ENCODE_QUAL_ADDR_SPACE.
13032 - main variant may be TYPE_COMPLETE_P and variant types !TYPE_COMPLETE_P
13033 in this case some values may not be set in the variant types
13034 (see TYPE_COMPLETE_P checks).
13035 - it is possible to have TYPE_ARTIFICIAL variant of non-artifical type
13036 - by TYPE_NAME and attributes (i.e. when variant originate by typedef)
13037 - TYPE_CANONICAL (TYPE_ALIAS_SET is the same among variants)
13038 - by the alignment: TYPE_ALIGN and TYPE_USER_ALIGN
13039 - during LTO by TYPE_CONTEXT if type is TYPE_FILE_SCOPE_P
13040 this is necessary to make it possible to merge types form different TUs
13041 - arrays, pointers and references may have TREE_TYPE that is a variant
13042 of TREE_TYPE of their main variants.
13043 - aggregates may have new TYPE_FIELDS list that list variants of
13044 the main variant TYPE_FIELDS.
13045 - vector types may differ by TYPE_VECTOR_OPAQUE
13046 */
13047
13048 /* Convenience macro for matching individual fields. */
13049 #define verify_variant_match(flag) \
13050 do { \
13051 if (flag (tv) != flag (t)) \
13052 { \
13053 error ("type variant differs by %s", #flag); \
13054 debug_tree (tv); \
13055 return false; \
13056 } \
13057 } while (false)
13058
13059 /* tree_base checks. */
13060
13061 verify_variant_match (TREE_CODE);
13062 /* FIXME: Ada builds non-artificial variants of artificial types. */
13063 if (TYPE_ARTIFICIAL (tv) && 0)
13064 verify_variant_match (TYPE_ARTIFICIAL);
13065 if (POINTER_TYPE_P (tv))
13066 verify_variant_match (TYPE_REF_CAN_ALIAS_ALL);
13067 /* FIXME: TYPE_SIZES_GIMPLIFIED may differs for Ada build. */
13068 verify_variant_match (TYPE_UNSIGNED);
13069 verify_variant_match (TYPE_PACKED);
13070 if (TREE_CODE (t) == REFERENCE_TYPE)
13071 verify_variant_match (TYPE_REF_IS_RVALUE);
13072 if (AGGREGATE_TYPE_P (t))
13073 verify_variant_match (TYPE_REVERSE_STORAGE_ORDER);
13074 else
13075 verify_variant_match (TYPE_SATURATING);
13076 /* FIXME: This check trigger during libstdc++ build. */
13077 if (RECORD_OR_UNION_TYPE_P (t) && COMPLETE_TYPE_P (t) && 0)
13078 verify_variant_match (TYPE_FINAL_P);
13079
13080 /* tree_type_common checks. */
13081
13082 if (COMPLETE_TYPE_P (t))
13083 {
13084 verify_variant_match (TYPE_MODE);
13085 if (TREE_CODE (TYPE_SIZE (t)) != PLACEHOLDER_EXPR
13086 && TREE_CODE (TYPE_SIZE (tv)) != PLACEHOLDER_EXPR)
13087 verify_variant_match (TYPE_SIZE);
13088 if (TREE_CODE (TYPE_SIZE_UNIT (t)) != PLACEHOLDER_EXPR
13089 && TREE_CODE (TYPE_SIZE_UNIT (tv)) != PLACEHOLDER_EXPR
13090 && TYPE_SIZE_UNIT (t) != TYPE_SIZE_UNIT (tv))
13091 {
13092 gcc_assert (!operand_equal_p (TYPE_SIZE_UNIT (t),
13093 TYPE_SIZE_UNIT (tv), 0));
13094 error ("type variant has different TYPE_SIZE_UNIT");
13095 debug_tree (tv);
13096 error ("type variant's TYPE_SIZE_UNIT");
13097 debug_tree (TYPE_SIZE_UNIT (tv));
13098 error ("type's TYPE_SIZE_UNIT");
13099 debug_tree (TYPE_SIZE_UNIT (t));
13100 return false;
13101 }
13102 }
13103 verify_variant_match (TYPE_PRECISION);
13104 verify_variant_match (TYPE_NEEDS_CONSTRUCTING);
13105 if (RECORD_OR_UNION_TYPE_P (t))
13106 verify_variant_match (TYPE_TRANSPARENT_AGGR);
13107 else if (TREE_CODE (t) == ARRAY_TYPE)
13108 verify_variant_match (TYPE_NONALIASED_COMPONENT);
13109 /* During LTO we merge variant lists from diferent translation units
13110 that may differ BY TYPE_CONTEXT that in turn may point
13111 to TRANSLATION_UNIT_DECL.
13112 Ada also builds variants of types with different TYPE_CONTEXT. */
13113 if ((!in_lto_p || !TYPE_FILE_SCOPE_P (t)) && 0)
13114 verify_variant_match (TYPE_CONTEXT);
13115 verify_variant_match (TYPE_STRING_FLAG);
13116 if (TYPE_ALIAS_SET_KNOWN_P (t))
13117 {
13118 error ("type variant with TYPE_ALIAS_SET_KNOWN_P");
13119 debug_tree (tv);
13120 return false;
13121 }
13122
13123 /* tree_type_non_common checks. */
13124
13125 /* FIXME: C FE uses TYPE_VFIELD to record C_TYPE_INCOMPLETE_VARS
13126 and dangle the pointer from time to time. */
13127 if (RECORD_OR_UNION_TYPE_P (t) && TYPE_VFIELD (t) != TYPE_VFIELD (tv)
13128 && (in_lto_p || !TYPE_VFIELD (tv)
13129 || TREE_CODE (TYPE_VFIELD (tv)) != TREE_LIST))
13130 {
13131 error ("type variant has different TYPE_VFIELD");
13132 debug_tree (tv);
13133 return false;
13134 }
13135 if ((TREE_CODE (t) == ENUMERAL_TYPE && COMPLETE_TYPE_P (t))
13136 || TREE_CODE (t) == INTEGER_TYPE
13137 || TREE_CODE (t) == BOOLEAN_TYPE
13138 || TREE_CODE (t) == REAL_TYPE
13139 || TREE_CODE (t) == FIXED_POINT_TYPE)
13140 {
13141 verify_variant_match (TYPE_MAX_VALUE);
13142 verify_variant_match (TYPE_MIN_VALUE);
13143 }
13144 if (TREE_CODE (t) == METHOD_TYPE)
13145 verify_variant_match (TYPE_METHOD_BASETYPE);
13146 if (TREE_CODE (t) == OFFSET_TYPE)
13147 verify_variant_match (TYPE_OFFSET_BASETYPE);
13148 if (TREE_CODE (t) == ARRAY_TYPE)
13149 verify_variant_match (TYPE_ARRAY_MAX_SIZE);
13150 /* FIXME: Be lax and allow TYPE_BINFO to be missing in variant types
13151 or even type's main variant. This is needed to make bootstrap pass
13152 and the bug seems new in GCC 5.
13153 C++ FE should be updated to make this consistent and we should check
13154 that TYPE_BINFO is always NULL for !COMPLETE_TYPE_P and otherwise there
13155 is a match with main variant.
13156
13157 Also disable the check for Java for now because of parser hack that builds
13158 first an dummy BINFO and then sometimes replace it by real BINFO in some
13159 of the copies. */
13160 if (RECORD_OR_UNION_TYPE_P (t) && TYPE_BINFO (t) && TYPE_BINFO (tv)
13161 && TYPE_BINFO (t) != TYPE_BINFO (tv)
13162 /* FIXME: Java sometimes keep dump TYPE_BINFOs on variant types.
13163 Since there is no cheap way to tell C++/Java type w/o LTO, do checking
13164 at LTO time only. */
13165 && (in_lto_p && odr_type_p (t)))
13166 {
13167 error ("type variant has different TYPE_BINFO");
13168 debug_tree (tv);
13169 error ("type variant's TYPE_BINFO");
13170 debug_tree (TYPE_BINFO (tv));
13171 error ("type's TYPE_BINFO");
13172 debug_tree (TYPE_BINFO (t));
13173 return false;
13174 }
13175
13176 /* Check various uses of TYPE_VALUES_RAW. */
13177 if (TREE_CODE (t) == ENUMERAL_TYPE)
13178 verify_variant_match (TYPE_VALUES);
13179 else if (TREE_CODE (t) == ARRAY_TYPE)
13180 verify_variant_match (TYPE_DOMAIN);
13181 /* Permit incomplete variants of complete type. While FEs may complete
13182 all variants, this does not happen for C++ templates in all cases. */
13183 else if (RECORD_OR_UNION_TYPE_P (t)
13184 && COMPLETE_TYPE_P (t)
13185 && TYPE_FIELDS (t) != TYPE_FIELDS (tv))
13186 {
13187 tree f1, f2;
13188
13189 /* Fortran builds qualified variants as new records with items of
13190 qualified type. Verify that they looks same. */
13191 for (f1 = TYPE_FIELDS (t), f2 = TYPE_FIELDS (tv);
13192 f1 && f2;
13193 f1 = TREE_CHAIN (f1), f2 = TREE_CHAIN (f2))
13194 if (TREE_CODE (f1) != FIELD_DECL || TREE_CODE (f2) != FIELD_DECL
13195 || (TYPE_MAIN_VARIANT (TREE_TYPE (f1))
13196 != TYPE_MAIN_VARIANT (TREE_TYPE (f2))
13197 /* FIXME: gfc_nonrestricted_type builds all types as variants
13198 with exception of pointer types. It deeply copies the type
13199 which means that we may end up with a variant type
13200 referring non-variant pointer. We may change it to
13201 produce types as variants, too, like
13202 objc_get_protocol_qualified_type does. */
13203 && !POINTER_TYPE_P (TREE_TYPE (f1)))
13204 || DECL_FIELD_OFFSET (f1) != DECL_FIELD_OFFSET (f2)
13205 || DECL_FIELD_BIT_OFFSET (f1) != DECL_FIELD_BIT_OFFSET (f2))
13206 break;
13207 if (f1 || f2)
13208 {
13209 error ("type variant has different TYPE_FIELDS");
13210 debug_tree (tv);
13211 error ("first mismatch is field");
13212 debug_tree (f1);
13213 error ("and field");
13214 debug_tree (f2);
13215 return false;
13216 }
13217 }
13218 else if ((TREE_CODE (t) == FUNCTION_TYPE || TREE_CODE (t) == METHOD_TYPE))
13219 verify_variant_match (TYPE_ARG_TYPES);
13220 /* For C++ the qualified variant of array type is really an array type
13221 of qualified TREE_TYPE.
13222 objc builds variants of pointer where pointer to type is a variant, too
13223 in objc_get_protocol_qualified_type. */
13224 if (TREE_TYPE (t) != TREE_TYPE (tv)
13225 && ((TREE_CODE (t) != ARRAY_TYPE
13226 && !POINTER_TYPE_P (t))
13227 || TYPE_MAIN_VARIANT (TREE_TYPE (t))
13228 != TYPE_MAIN_VARIANT (TREE_TYPE (tv))))
13229 {
13230 error ("type variant has different TREE_TYPE");
13231 debug_tree (tv);
13232 error ("type variant's TREE_TYPE");
13233 debug_tree (TREE_TYPE (tv));
13234 error ("type's TREE_TYPE");
13235 debug_tree (TREE_TYPE (t));
13236 return false;
13237 }
13238 if (type_with_alias_set_p (t)
13239 && !gimple_canonical_types_compatible_p (t, tv, false))
13240 {
13241 error ("type is not compatible with its variant");
13242 debug_tree (tv);
13243 error ("type variant's TREE_TYPE");
13244 debug_tree (TREE_TYPE (tv));
13245 error ("type's TREE_TYPE");
13246 debug_tree (TREE_TYPE (t));
13247 return false;
13248 }
13249 return true;
13250 #undef verify_variant_match
13251 }
13252
13253
13254 /* The TYPE_CANONICAL merging machinery. It should closely resemble
13255 the middle-end types_compatible_p function. It needs to avoid
13256 claiming types are different for types that should be treated
13257 the same with respect to TBAA. Canonical types are also used
13258 for IL consistency checks via the useless_type_conversion_p
13259 predicate which does not handle all type kinds itself but falls
13260 back to pointer-comparison of TYPE_CANONICAL for aggregates
13261 for example. */
13262
13263 /* Return true if TYPE_UNSIGNED of TYPE should be ignored for canonical
13264 type calculation because we need to allow inter-operability between signed
13265 and unsigned variants. */
13266
13267 bool
type_with_interoperable_signedness(const_tree type)13268 type_with_interoperable_signedness (const_tree type)
13269 {
13270 /* Fortran standard require C_SIGNED_CHAR to be interoperable with both
13271 signed char and unsigned char. Similarly fortran FE builds
13272 C_SIZE_T as signed type, while C defines it unsigned. */
13273
13274 return tree_code_for_canonical_type_merging (TREE_CODE (type))
13275 == INTEGER_TYPE
13276 && (TYPE_PRECISION (type) == TYPE_PRECISION (signed_char_type_node)
13277 || TYPE_PRECISION (type) == TYPE_PRECISION (size_type_node));
13278 }
13279
13280 /* Return true iff T1 and T2 are structurally identical for what
13281 TBAA is concerned.
13282 This function is used both by lto.c canonical type merging and by the
13283 verifier. If TRUST_TYPE_CANONICAL we do not look into structure of types
13284 that have TYPE_CANONICAL defined and assume them equivalent. This is useful
13285 only for LTO because only in these cases TYPE_CANONICAL equivalence
13286 correspond to one defined by gimple_canonical_types_compatible_p. */
13287
13288 bool
gimple_canonical_types_compatible_p(const_tree t1,const_tree t2,bool trust_type_canonical)13289 gimple_canonical_types_compatible_p (const_tree t1, const_tree t2,
13290 bool trust_type_canonical)
13291 {
13292 /* Type variants should be same as the main variant. When not doing sanity
13293 checking to verify this fact, go to main variants and save some work. */
13294 if (trust_type_canonical)
13295 {
13296 t1 = TYPE_MAIN_VARIANT (t1);
13297 t2 = TYPE_MAIN_VARIANT (t2);
13298 }
13299
13300 /* Check first for the obvious case of pointer identity. */
13301 if (t1 == t2)
13302 return true;
13303
13304 /* Check that we have two types to compare. */
13305 if (t1 == NULL_TREE || t2 == NULL_TREE)
13306 return false;
13307
13308 /* We consider complete types always compatible with incomplete type.
13309 This does not make sense for canonical type calculation and thus we
13310 need to ensure that we are never called on it.
13311
13312 FIXME: For more correctness the function probably should have three modes
13313 1) mode assuming that types are complete mathcing their structure
13314 2) mode allowing incomplete types but producing equivalence classes
13315 and thus ignoring all info from complete types
13316 3) mode allowing incomplete types to match complete but checking
13317 compatibility between complete types.
13318
13319 1 and 2 can be used for canonical type calculation. 3 is the real
13320 definition of type compatibility that can be used i.e. for warnings during
13321 declaration merging. */
13322
13323 gcc_assert (!trust_type_canonical
13324 || (type_with_alias_set_p (t1) && type_with_alias_set_p (t2)));
13325 /* If the types have been previously registered and found equal
13326 they still are. */
13327
13328 if (TYPE_CANONICAL (t1) && TYPE_CANONICAL (t2)
13329 && trust_type_canonical)
13330 {
13331 /* Do not use TYPE_CANONICAL of pointer types. For LTO streamed types
13332 they are always NULL, but they are set to non-NULL for types
13333 constructed by build_pointer_type and variants. In this case the
13334 TYPE_CANONICAL is more fine grained than the equivalnce we test (where
13335 all pointers are considered equal. Be sure to not return false
13336 negatives. */
13337 gcc_checking_assert (canonical_type_used_p (t1)
13338 && canonical_type_used_p (t2));
13339 return TYPE_CANONICAL (t1) == TYPE_CANONICAL (t2);
13340 }
13341
13342 /* Can't be the same type if the types don't have the same code. */
13343 enum tree_code code = tree_code_for_canonical_type_merging (TREE_CODE (t1));
13344 if (code != tree_code_for_canonical_type_merging (TREE_CODE (t2)))
13345 return false;
13346
13347 /* Qualifiers do not matter for canonical type comparison purposes. */
13348
13349 /* Void types and nullptr types are always the same. */
13350 if (TREE_CODE (t1) == VOID_TYPE
13351 || TREE_CODE (t1) == NULLPTR_TYPE)
13352 return true;
13353
13354 /* Can't be the same type if they have different mode. */
13355 if (TYPE_MODE (t1) != TYPE_MODE (t2))
13356 return false;
13357
13358 /* Non-aggregate types can be handled cheaply. */
13359 if (INTEGRAL_TYPE_P (t1)
13360 || SCALAR_FLOAT_TYPE_P (t1)
13361 || FIXED_POINT_TYPE_P (t1)
13362 || TREE_CODE (t1) == VECTOR_TYPE
13363 || TREE_CODE (t1) == COMPLEX_TYPE
13364 || TREE_CODE (t1) == OFFSET_TYPE
13365 || POINTER_TYPE_P (t1))
13366 {
13367 /* Can't be the same type if they have different recision. */
13368 if (TYPE_PRECISION (t1) != TYPE_PRECISION (t2))
13369 return false;
13370
13371 /* In some cases the signed and unsigned types are required to be
13372 inter-operable. */
13373 if (TYPE_UNSIGNED (t1) != TYPE_UNSIGNED (t2)
13374 && !type_with_interoperable_signedness (t1))
13375 return false;
13376
13377 /* Fortran's C_SIGNED_CHAR is !TYPE_STRING_FLAG but needs to be
13378 interoperable with "signed char". Unless all frontends are revisited
13379 to agree on these types, we must ignore the flag completely. */
13380
13381 /* Fortran standard define C_PTR type that is compatible with every
13382 C pointer. For this reason we need to glob all pointers into one.
13383 Still pointers in different address spaces are not compatible. */
13384 if (POINTER_TYPE_P (t1))
13385 {
13386 if (TYPE_ADDR_SPACE (TREE_TYPE (t1))
13387 != TYPE_ADDR_SPACE (TREE_TYPE (t2)))
13388 return false;
13389 }
13390
13391 /* Tail-recurse to components. */
13392 if (TREE_CODE (t1) == VECTOR_TYPE
13393 || TREE_CODE (t1) == COMPLEX_TYPE)
13394 return gimple_canonical_types_compatible_p (TREE_TYPE (t1),
13395 TREE_TYPE (t2),
13396 trust_type_canonical);
13397
13398 return true;
13399 }
13400
13401 /* Do type-specific comparisons. */
13402 switch (TREE_CODE (t1))
13403 {
13404 case ARRAY_TYPE:
13405 /* Array types are the same if the element types are the same and
13406 the number of elements are the same. */
13407 if (!gimple_canonical_types_compatible_p (TREE_TYPE (t1), TREE_TYPE (t2),
13408 trust_type_canonical)
13409 || TYPE_STRING_FLAG (t1) != TYPE_STRING_FLAG (t2)
13410 || TYPE_REVERSE_STORAGE_ORDER (t1) != TYPE_REVERSE_STORAGE_ORDER (t2)
13411 || TYPE_NONALIASED_COMPONENT (t1) != TYPE_NONALIASED_COMPONENT (t2))
13412 return false;
13413 else
13414 {
13415 tree i1 = TYPE_DOMAIN (t1);
13416 tree i2 = TYPE_DOMAIN (t2);
13417
13418 /* For an incomplete external array, the type domain can be
13419 NULL_TREE. Check this condition also. */
13420 if (i1 == NULL_TREE && i2 == NULL_TREE)
13421 return true;
13422 else if (i1 == NULL_TREE || i2 == NULL_TREE)
13423 return false;
13424 else
13425 {
13426 tree min1 = TYPE_MIN_VALUE (i1);
13427 tree min2 = TYPE_MIN_VALUE (i2);
13428 tree max1 = TYPE_MAX_VALUE (i1);
13429 tree max2 = TYPE_MAX_VALUE (i2);
13430
13431 /* The minimum/maximum values have to be the same. */
13432 if ((min1 == min2
13433 || (min1 && min2
13434 && ((TREE_CODE (min1) == PLACEHOLDER_EXPR
13435 && TREE_CODE (min2) == PLACEHOLDER_EXPR)
13436 || operand_equal_p (min1, min2, 0))))
13437 && (max1 == max2
13438 || (max1 && max2
13439 && ((TREE_CODE (max1) == PLACEHOLDER_EXPR
13440 && TREE_CODE (max2) == PLACEHOLDER_EXPR)
13441 || operand_equal_p (max1, max2, 0)))))
13442 return true;
13443 else
13444 return false;
13445 }
13446 }
13447
13448 case METHOD_TYPE:
13449 case FUNCTION_TYPE:
13450 /* Function types are the same if the return type and arguments types
13451 are the same. */
13452 if (!gimple_canonical_types_compatible_p (TREE_TYPE (t1), TREE_TYPE (t2),
13453 trust_type_canonical))
13454 return false;
13455
13456 if (TYPE_ARG_TYPES (t1) == TYPE_ARG_TYPES (t2))
13457 return true;
13458 else
13459 {
13460 tree parms1, parms2;
13461
13462 for (parms1 = TYPE_ARG_TYPES (t1), parms2 = TYPE_ARG_TYPES (t2);
13463 parms1 && parms2;
13464 parms1 = TREE_CHAIN (parms1), parms2 = TREE_CHAIN (parms2))
13465 {
13466 if (!gimple_canonical_types_compatible_p
13467 (TREE_VALUE (parms1), TREE_VALUE (parms2),
13468 trust_type_canonical))
13469 return false;
13470 }
13471
13472 if (parms1 || parms2)
13473 return false;
13474
13475 return true;
13476 }
13477
13478 case RECORD_TYPE:
13479 case UNION_TYPE:
13480 case QUAL_UNION_TYPE:
13481 {
13482 tree f1, f2;
13483
13484 /* Don't try to compare variants of an incomplete type, before
13485 TYPE_FIELDS has been copied around. */
13486 if (!COMPLETE_TYPE_P (t1) && !COMPLETE_TYPE_P (t2))
13487 return true;
13488
13489
13490 if (TYPE_REVERSE_STORAGE_ORDER (t1) != TYPE_REVERSE_STORAGE_ORDER (t2))
13491 return false;
13492
13493 /* For aggregate types, all the fields must be the same. */
13494 for (f1 = TYPE_FIELDS (t1), f2 = TYPE_FIELDS (t2);
13495 f1 || f2;
13496 f1 = TREE_CHAIN (f1), f2 = TREE_CHAIN (f2))
13497 {
13498 /* Skip non-fields and zero-sized fields. */
13499 while (f1 && (TREE_CODE (f1) != FIELD_DECL
13500 || (DECL_SIZE (f1)
13501 && integer_zerop (DECL_SIZE (f1)))))
13502 f1 = TREE_CHAIN (f1);
13503 while (f2 && (TREE_CODE (f2) != FIELD_DECL
13504 || (DECL_SIZE (f2)
13505 && integer_zerop (DECL_SIZE (f2)))))
13506 f2 = TREE_CHAIN (f2);
13507 if (!f1 || !f2)
13508 break;
13509 /* The fields must have the same name, offset and type. */
13510 if (DECL_NONADDRESSABLE_P (f1) != DECL_NONADDRESSABLE_P (f2)
13511 || !gimple_compare_field_offset (f1, f2)
13512 || !gimple_canonical_types_compatible_p
13513 (TREE_TYPE (f1), TREE_TYPE (f2),
13514 trust_type_canonical))
13515 return false;
13516 }
13517
13518 /* If one aggregate has more fields than the other, they
13519 are not the same. */
13520 if (f1 || f2)
13521 return false;
13522
13523 return true;
13524 }
13525
13526 default:
13527 /* Consider all types with language specific trees in them mutually
13528 compatible. This is executed only from verify_type and false
13529 positives can be tolerated. */
13530 gcc_assert (!in_lto_p);
13531 return true;
13532 }
13533 }
13534
13535 /* Verify type T. */
13536
13537 void
verify_type(const_tree t)13538 verify_type (const_tree t)
13539 {
13540 bool error_found = false;
13541 tree mv = TYPE_MAIN_VARIANT (t);
13542 if (!mv)
13543 {
13544 error ("Main variant is not defined");
13545 error_found = true;
13546 }
13547 else if (mv != TYPE_MAIN_VARIANT (mv))
13548 {
13549 error ("TYPE_MAIN_VARIANT has different TYPE_MAIN_VARIANT");
13550 debug_tree (mv);
13551 error_found = true;
13552 }
13553 else if (t != mv && !verify_type_variant (t, mv))
13554 error_found = true;
13555
13556 tree ct = TYPE_CANONICAL (t);
13557 if (!ct)
13558 ;
13559 else if (TYPE_CANONICAL (t) != ct)
13560 {
13561 error ("TYPE_CANONICAL has different TYPE_CANONICAL");
13562 debug_tree (ct);
13563 error_found = true;
13564 }
13565 /* Method and function types can not be used to address memory and thus
13566 TYPE_CANONICAL really matters only for determining useless conversions.
13567
13568 FIXME: C++ FE produce declarations of builtin functions that are not
13569 compatible with main variants. */
13570 else if (TREE_CODE (t) == FUNCTION_TYPE)
13571 ;
13572 else if (t != ct
13573 /* FIXME: gimple_canonical_types_compatible_p can not compare types
13574 with variably sized arrays because their sizes possibly
13575 gimplified to different variables. */
13576 && !variably_modified_type_p (ct, NULL)
13577 && !gimple_canonical_types_compatible_p (t, ct, false))
13578 {
13579 error ("TYPE_CANONICAL is not compatible");
13580 debug_tree (ct);
13581 error_found = true;
13582 }
13583
13584 if (COMPLETE_TYPE_P (t) && TYPE_CANONICAL (t)
13585 && TYPE_MODE (t) != TYPE_MODE (TYPE_CANONICAL (t)))
13586 {
13587 error ("TYPE_MODE of TYPE_CANONICAL is not compatible");
13588 debug_tree (ct);
13589 error_found = true;
13590 }
13591 if (TYPE_MAIN_VARIANT (t) == t && ct && TYPE_MAIN_VARIANT (ct) != ct)
13592 {
13593 error ("TYPE_CANONICAL of main variant is not main variant");
13594 debug_tree (ct);
13595 debug_tree (TYPE_MAIN_VARIANT (ct));
13596 error_found = true;
13597 }
13598
13599
13600 /* Check various uses of TYPE_MIN_VALUE_RAW. */
13601 if (RECORD_OR_UNION_TYPE_P (t))
13602 {
13603 /* FIXME: C FE uses TYPE_VFIELD to record C_TYPE_INCOMPLETE_VARS
13604 and danagle the pointer from time to time. */
13605 if (TYPE_VFIELD (t)
13606 && TREE_CODE (TYPE_VFIELD (t)) != FIELD_DECL
13607 && TREE_CODE (TYPE_VFIELD (t)) != TREE_LIST)
13608 {
13609 error ("TYPE_VFIELD is not FIELD_DECL nor TREE_LIST");
13610 debug_tree (TYPE_VFIELD (t));
13611 error_found = true;
13612 }
13613 }
13614 else if (TREE_CODE (t) == POINTER_TYPE)
13615 {
13616 if (TYPE_NEXT_PTR_TO (t)
13617 && TREE_CODE (TYPE_NEXT_PTR_TO (t)) != POINTER_TYPE)
13618 {
13619 error ("TYPE_NEXT_PTR_TO is not POINTER_TYPE");
13620 debug_tree (TYPE_NEXT_PTR_TO (t));
13621 error_found = true;
13622 }
13623 }
13624 else if (TREE_CODE (t) == REFERENCE_TYPE)
13625 {
13626 if (TYPE_NEXT_REF_TO (t)
13627 && TREE_CODE (TYPE_NEXT_REF_TO (t)) != REFERENCE_TYPE)
13628 {
13629 error ("TYPE_NEXT_REF_TO is not REFERENCE_TYPE");
13630 debug_tree (TYPE_NEXT_REF_TO (t));
13631 error_found = true;
13632 }
13633 }
13634 else if (INTEGRAL_TYPE_P (t) || TREE_CODE (t) == REAL_TYPE
13635 || TREE_CODE (t) == FIXED_POINT_TYPE)
13636 {
13637 /* FIXME: The following check should pass:
13638 useless_type_conversion_p (const_cast <tree> (t),
13639 TREE_TYPE (TYPE_MIN_VALUE (t))
13640 but does not for C sizetypes in LTO. */
13641 }
13642
13643 /* Check various uses of TYPE_MAXVAL_RAW. */
13644 if (RECORD_OR_UNION_TYPE_P (t))
13645 {
13646 if (!TYPE_BINFO (t))
13647 ;
13648 else if (TREE_CODE (TYPE_BINFO (t)) != TREE_BINFO)
13649 {
13650 error ("TYPE_BINFO is not TREE_BINFO");
13651 debug_tree (TYPE_BINFO (t));
13652 error_found = true;
13653 }
13654 else if (TREE_TYPE (TYPE_BINFO (t)) != TYPE_MAIN_VARIANT (t))
13655 {
13656 error ("TYPE_BINFO type is not TYPE_MAIN_VARIANT");
13657 debug_tree (TREE_TYPE (TYPE_BINFO (t)));
13658 error_found = true;
13659 }
13660 }
13661 else if (TREE_CODE (t) == FUNCTION_TYPE || TREE_CODE (t) == METHOD_TYPE)
13662 {
13663 if (TYPE_METHOD_BASETYPE (t)
13664 && TREE_CODE (TYPE_METHOD_BASETYPE (t)) != RECORD_TYPE
13665 && TREE_CODE (TYPE_METHOD_BASETYPE (t)) != UNION_TYPE)
13666 {
13667 error ("TYPE_METHOD_BASETYPE is not record nor union");
13668 debug_tree (TYPE_METHOD_BASETYPE (t));
13669 error_found = true;
13670 }
13671 }
13672 else if (TREE_CODE (t) == OFFSET_TYPE)
13673 {
13674 if (TYPE_OFFSET_BASETYPE (t)
13675 && TREE_CODE (TYPE_OFFSET_BASETYPE (t)) != RECORD_TYPE
13676 && TREE_CODE (TYPE_OFFSET_BASETYPE (t)) != UNION_TYPE)
13677 {
13678 error ("TYPE_OFFSET_BASETYPE is not record nor union");
13679 debug_tree (TYPE_OFFSET_BASETYPE (t));
13680 error_found = true;
13681 }
13682 }
13683 else if (INTEGRAL_TYPE_P (t) || TREE_CODE (t) == REAL_TYPE
13684 || TREE_CODE (t) == FIXED_POINT_TYPE)
13685 {
13686 /* FIXME: The following check should pass:
13687 useless_type_conversion_p (const_cast <tree> (t),
13688 TREE_TYPE (TYPE_MAX_VALUE (t))
13689 but does not for C sizetypes in LTO. */
13690 }
13691 else if (TREE_CODE (t) == ARRAY_TYPE)
13692 {
13693 if (TYPE_ARRAY_MAX_SIZE (t)
13694 && TREE_CODE (TYPE_ARRAY_MAX_SIZE (t)) != INTEGER_CST)
13695 {
13696 error ("TYPE_ARRAY_MAX_SIZE not INTEGER_CST");
13697 debug_tree (TYPE_ARRAY_MAX_SIZE (t));
13698 error_found = true;
13699 }
13700 }
13701 else if (TYPE_MAX_VALUE_RAW (t))
13702 {
13703 error ("TYPE_MAX_VALUE_RAW non-NULL");
13704 debug_tree (TYPE_MAX_VALUE_RAW (t));
13705 error_found = true;
13706 }
13707
13708 if (TYPE_LANG_SLOT_1 (t) && in_lto_p)
13709 {
13710 error ("TYPE_LANG_SLOT_1 (binfo) field is non-NULL");
13711 debug_tree (TYPE_LANG_SLOT_1 (t));
13712 error_found = true;
13713 }
13714
13715 /* Check various uses of TYPE_VALUES_RAW. */
13716 if (TREE_CODE (t) == ENUMERAL_TYPE)
13717 for (tree l = TYPE_VALUES (t); l; l = TREE_CHAIN (l))
13718 {
13719 tree value = TREE_VALUE (l);
13720 tree name = TREE_PURPOSE (l);
13721
13722 /* C FE porduce INTEGER_CST of INTEGER_TYPE, while C++ FE uses
13723 CONST_DECL of ENUMERAL TYPE. */
13724 if (TREE_CODE (value) != INTEGER_CST && TREE_CODE (value) != CONST_DECL)
13725 {
13726 error ("Enum value is not CONST_DECL or INTEGER_CST");
13727 debug_tree (value);
13728 debug_tree (name);
13729 error_found = true;
13730 }
13731 if (TREE_CODE (TREE_TYPE (value)) != INTEGER_TYPE
13732 && !useless_type_conversion_p (const_cast <tree> (t), TREE_TYPE (value)))
13733 {
13734 error ("Enum value type is not INTEGER_TYPE nor convertible to the enum");
13735 debug_tree (value);
13736 debug_tree (name);
13737 error_found = true;
13738 }
13739 if (TREE_CODE (name) != IDENTIFIER_NODE)
13740 {
13741 error ("Enum value name is not IDENTIFIER_NODE");
13742 debug_tree (value);
13743 debug_tree (name);
13744 error_found = true;
13745 }
13746 }
13747 else if (TREE_CODE (t) == ARRAY_TYPE)
13748 {
13749 if (TYPE_DOMAIN (t) && TREE_CODE (TYPE_DOMAIN (t)) != INTEGER_TYPE)
13750 {
13751 error ("Array TYPE_DOMAIN is not integer type");
13752 debug_tree (TYPE_DOMAIN (t));
13753 error_found = true;
13754 }
13755 }
13756 else if (RECORD_OR_UNION_TYPE_P (t))
13757 {
13758 if (TYPE_FIELDS (t) && !COMPLETE_TYPE_P (t) && in_lto_p)
13759 {
13760 error ("TYPE_FIELDS defined in incomplete type");
13761 error_found = true;
13762 }
13763 for (tree fld = TYPE_FIELDS (t); fld; fld = TREE_CHAIN (fld))
13764 {
13765 /* TODO: verify properties of decls. */
13766 if (TREE_CODE (fld) == FIELD_DECL)
13767 ;
13768 else if (TREE_CODE (fld) == TYPE_DECL)
13769 ;
13770 else if (TREE_CODE (fld) == CONST_DECL)
13771 ;
13772 else if (VAR_P (fld))
13773 ;
13774 else if (TREE_CODE (fld) == TEMPLATE_DECL)
13775 ;
13776 else if (TREE_CODE (fld) == USING_DECL)
13777 ;
13778 else if (TREE_CODE (fld) == FUNCTION_DECL)
13779 ;
13780 else
13781 {
13782 error ("Wrong tree in TYPE_FIELDS list");
13783 debug_tree (fld);
13784 error_found = true;
13785 }
13786 }
13787 }
13788 else if (TREE_CODE (t) == INTEGER_TYPE
13789 || TREE_CODE (t) == BOOLEAN_TYPE
13790 || TREE_CODE (t) == OFFSET_TYPE
13791 || TREE_CODE (t) == REFERENCE_TYPE
13792 || TREE_CODE (t) == NULLPTR_TYPE
13793 || TREE_CODE (t) == POINTER_TYPE)
13794 {
13795 if (TYPE_CACHED_VALUES_P (t) != (TYPE_CACHED_VALUES (t) != NULL))
13796 {
13797 error ("TYPE_CACHED_VALUES_P is %i while TYPE_CACHED_VALUES is %p",
13798 TYPE_CACHED_VALUES_P (t), (void *)TYPE_CACHED_VALUES (t));
13799 error_found = true;
13800 }
13801 else if (TYPE_CACHED_VALUES_P (t) && TREE_CODE (TYPE_CACHED_VALUES (t)) != TREE_VEC)
13802 {
13803 error ("TYPE_CACHED_VALUES is not TREE_VEC");
13804 debug_tree (TYPE_CACHED_VALUES (t));
13805 error_found = true;
13806 }
13807 /* Verify just enough of cache to ensure that no one copied it to new type.
13808 All copying should go by copy_node that should clear it. */
13809 else if (TYPE_CACHED_VALUES_P (t))
13810 {
13811 int i;
13812 for (i = 0; i < TREE_VEC_LENGTH (TYPE_CACHED_VALUES (t)); i++)
13813 if (TREE_VEC_ELT (TYPE_CACHED_VALUES (t), i)
13814 && TREE_TYPE (TREE_VEC_ELT (TYPE_CACHED_VALUES (t), i)) != t)
13815 {
13816 error ("wrong TYPE_CACHED_VALUES entry");
13817 debug_tree (TREE_VEC_ELT (TYPE_CACHED_VALUES (t), i));
13818 error_found = true;
13819 break;
13820 }
13821 }
13822 }
13823 else if (TREE_CODE (t) == FUNCTION_TYPE || TREE_CODE (t) == METHOD_TYPE)
13824 for (tree l = TYPE_ARG_TYPES (t); l; l = TREE_CHAIN (l))
13825 {
13826 /* C++ FE uses TREE_PURPOSE to store initial values. */
13827 if (TREE_PURPOSE (l) && in_lto_p)
13828 {
13829 error ("TREE_PURPOSE is non-NULL in TYPE_ARG_TYPES list");
13830 debug_tree (l);
13831 error_found = true;
13832 }
13833 if (!TYPE_P (TREE_VALUE (l)))
13834 {
13835 error ("Wrong entry in TYPE_ARG_TYPES list");
13836 debug_tree (l);
13837 error_found = true;
13838 }
13839 }
13840 else if (!is_lang_specific (t) && TYPE_VALUES_RAW (t))
13841 {
13842 error ("TYPE_VALUES_RAW field is non-NULL");
13843 debug_tree (TYPE_VALUES_RAW (t));
13844 error_found = true;
13845 }
13846 if (TREE_CODE (t) != INTEGER_TYPE
13847 && TREE_CODE (t) != BOOLEAN_TYPE
13848 && TREE_CODE (t) != OFFSET_TYPE
13849 && TREE_CODE (t) != REFERENCE_TYPE
13850 && TREE_CODE (t) != NULLPTR_TYPE
13851 && TREE_CODE (t) != POINTER_TYPE
13852 && TYPE_CACHED_VALUES_P (t))
13853 {
13854 error ("TYPE_CACHED_VALUES_P is set while it should not");
13855 error_found = true;
13856 }
13857 if (TYPE_STRING_FLAG (t)
13858 && TREE_CODE (t) != ARRAY_TYPE && TREE_CODE (t) != INTEGER_TYPE)
13859 {
13860 error ("TYPE_STRING_FLAG is set on wrong type code");
13861 error_found = true;
13862 }
13863
13864 /* ipa-devirt makes an assumption that TYPE_METHOD_BASETYPE is always
13865 TYPE_MAIN_VARIANT and it would be odd to add methods only to variatns
13866 of a type. */
13867 if (TREE_CODE (t) == METHOD_TYPE
13868 && TYPE_MAIN_VARIANT (TYPE_METHOD_BASETYPE (t)) != TYPE_METHOD_BASETYPE (t))
13869 {
13870 error ("TYPE_METHOD_BASETYPE is not main variant");
13871 error_found = true;
13872 }
13873
13874 if (error_found)
13875 {
13876 debug_tree (const_cast <tree> (t));
13877 internal_error ("verify_type failed");
13878 }
13879 }
13880
13881
13882 /* Return 1 if ARG interpreted as signed in its precision is known to be
13883 always positive or 2 if ARG is known to be always negative, or 3 if
13884 ARG may be positive or negative. */
13885
13886 int
get_range_pos_neg(tree arg)13887 get_range_pos_neg (tree arg)
13888 {
13889 if (arg == error_mark_node)
13890 return 3;
13891
13892 int prec = TYPE_PRECISION (TREE_TYPE (arg));
13893 int cnt = 0;
13894 if (TREE_CODE (arg) == INTEGER_CST)
13895 {
13896 wide_int w = wi::sext (wi::to_wide (arg), prec);
13897 if (wi::neg_p (w))
13898 return 2;
13899 else
13900 return 1;
13901 }
13902 while (CONVERT_EXPR_P (arg)
13903 && INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (arg, 0)))
13904 && TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (arg, 0))) <= prec)
13905 {
13906 arg = TREE_OPERAND (arg, 0);
13907 /* Narrower value zero extended into wider type
13908 will always result in positive values. */
13909 if (TYPE_UNSIGNED (TREE_TYPE (arg))
13910 && TYPE_PRECISION (TREE_TYPE (arg)) < prec)
13911 return 1;
13912 prec = TYPE_PRECISION (TREE_TYPE (arg));
13913 if (++cnt > 30)
13914 return 3;
13915 }
13916
13917 if (TREE_CODE (arg) != SSA_NAME)
13918 return 3;
13919 wide_int arg_min, arg_max;
13920 while (get_range_info (arg, &arg_min, &arg_max) != VR_RANGE)
13921 {
13922 gimple *g = SSA_NAME_DEF_STMT (arg);
13923 if (is_gimple_assign (g)
13924 && CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (g)))
13925 {
13926 tree t = gimple_assign_rhs1 (g);
13927 if (INTEGRAL_TYPE_P (TREE_TYPE (t))
13928 && TYPE_PRECISION (TREE_TYPE (t)) <= prec)
13929 {
13930 if (TYPE_UNSIGNED (TREE_TYPE (t))
13931 && TYPE_PRECISION (TREE_TYPE (t)) < prec)
13932 return 1;
13933 prec = TYPE_PRECISION (TREE_TYPE (t));
13934 arg = t;
13935 if (++cnt > 30)
13936 return 3;
13937 continue;
13938 }
13939 }
13940 return 3;
13941 }
13942 if (TYPE_UNSIGNED (TREE_TYPE (arg)))
13943 {
13944 /* For unsigned values, the "positive" range comes
13945 below the "negative" range. */
13946 if (!wi::neg_p (wi::sext (arg_max, prec), SIGNED))
13947 return 1;
13948 if (wi::neg_p (wi::sext (arg_min, prec), SIGNED))
13949 return 2;
13950 }
13951 else
13952 {
13953 if (!wi::neg_p (wi::sext (arg_min, prec), SIGNED))
13954 return 1;
13955 if (wi::neg_p (wi::sext (arg_max, prec), SIGNED))
13956 return 2;
13957 }
13958 return 3;
13959 }
13960
13961
13962
13963
13964 /* Return true if ARG is marked with the nonnull attribute in the
13965 current function signature. */
13966
13967 bool
nonnull_arg_p(const_tree arg)13968 nonnull_arg_p (const_tree arg)
13969 {
13970 tree t, attrs, fntype;
13971 unsigned HOST_WIDE_INT arg_num;
13972
13973 gcc_assert (TREE_CODE (arg) == PARM_DECL
13974 && (POINTER_TYPE_P (TREE_TYPE (arg))
13975 || TREE_CODE (TREE_TYPE (arg)) == OFFSET_TYPE));
13976
13977 /* The static chain decl is always non null. */
13978 if (arg == cfun->static_chain_decl)
13979 return true;
13980
13981 /* THIS argument of method is always non-NULL. */
13982 if (TREE_CODE (TREE_TYPE (cfun->decl)) == METHOD_TYPE
13983 && arg == DECL_ARGUMENTS (cfun->decl)
13984 && flag_delete_null_pointer_checks)
13985 return true;
13986
13987 /* Values passed by reference are always non-NULL. */
13988 if (TREE_CODE (TREE_TYPE (arg)) == REFERENCE_TYPE
13989 && flag_delete_null_pointer_checks)
13990 return true;
13991
13992 fntype = TREE_TYPE (cfun->decl);
13993 for (attrs = TYPE_ATTRIBUTES (fntype); attrs; attrs = TREE_CHAIN (attrs))
13994 {
13995 attrs = lookup_attribute ("nonnull", attrs);
13996
13997 /* If "nonnull" wasn't specified, we know nothing about the argument. */
13998 if (attrs == NULL_TREE)
13999 return false;
14000
14001 /* If "nonnull" applies to all the arguments, then ARG is non-null. */
14002 if (TREE_VALUE (attrs) == NULL_TREE)
14003 return true;
14004
14005 /* Get the position number for ARG in the function signature. */
14006 for (arg_num = 1, t = DECL_ARGUMENTS (cfun->decl);
14007 t;
14008 t = DECL_CHAIN (t), arg_num++)
14009 {
14010 if (t == arg)
14011 break;
14012 }
14013
14014 gcc_assert (t == arg);
14015
14016 /* Now see if ARG_NUM is mentioned in the nonnull list. */
14017 for (t = TREE_VALUE (attrs); t; t = TREE_CHAIN (t))
14018 {
14019 if (compare_tree_int (TREE_VALUE (t), arg_num) == 0)
14020 return true;
14021 }
14022 }
14023
14024 return false;
14025 }
14026
14027 /* Combine LOC and BLOCK to a combined adhoc loc, retaining any range
14028 information. */
14029
14030 location_t
set_block(location_t loc,tree block)14031 set_block (location_t loc, tree block)
14032 {
14033 location_t pure_loc = get_pure_location (loc);
14034 source_range src_range = get_range_from_loc (line_table, loc);
14035 return COMBINE_LOCATION_DATA (line_table, pure_loc, src_range, block);
14036 }
14037
14038 location_t
set_source_range(tree expr,location_t start,location_t finish)14039 set_source_range (tree expr, location_t start, location_t finish)
14040 {
14041 source_range src_range;
14042 src_range.m_start = start;
14043 src_range.m_finish = finish;
14044 return set_source_range (expr, src_range);
14045 }
14046
14047 location_t
set_source_range(tree expr,source_range src_range)14048 set_source_range (tree expr, source_range src_range)
14049 {
14050 if (!EXPR_P (expr))
14051 return UNKNOWN_LOCATION;
14052
14053 location_t pure_loc = get_pure_location (EXPR_LOCATION (expr));
14054 location_t adhoc = COMBINE_LOCATION_DATA (line_table,
14055 pure_loc,
14056 src_range,
14057 NULL);
14058 SET_EXPR_LOCATION (expr, adhoc);
14059 return adhoc;
14060 }
14061
14062 /* Return EXPR, potentially wrapped with a node expression LOC,
14063 if !CAN_HAVE_LOCATION_P (expr).
14064
14065 NON_LVALUE_EXPR is used for wrapping constants, apart from STRING_CST.
14066 VIEW_CONVERT_EXPR is used for wrapping non-constants and STRING_CST.
14067
14068 Wrapper nodes can be identified using location_wrapper_p. */
14069
14070 tree
maybe_wrap_with_location(tree expr,location_t loc)14071 maybe_wrap_with_location (tree expr, location_t loc)
14072 {
14073 if (expr == NULL)
14074 return NULL;
14075 if (loc == UNKNOWN_LOCATION)
14076 return expr;
14077 if (CAN_HAVE_LOCATION_P (expr))
14078 return expr;
14079 /* We should only be adding wrappers for constants and for decls,
14080 or for some exceptional tree nodes (e.g. BASELINK in the C++ FE). */
14081 gcc_assert (CONSTANT_CLASS_P (expr)
14082 || DECL_P (expr)
14083 || EXCEPTIONAL_CLASS_P (expr));
14084
14085 /* For now, don't add wrappers to exceptional tree nodes, to minimize
14086 any impact of the wrapper nodes. */
14087 if (EXCEPTIONAL_CLASS_P (expr))
14088 return expr;
14089
14090 tree_code code
14091 = (((CONSTANT_CLASS_P (expr) && TREE_CODE (expr) != STRING_CST)
14092 || (TREE_CODE (expr) == CONST_DECL && !TREE_STATIC (expr)))
14093 ? NON_LVALUE_EXPR : VIEW_CONVERT_EXPR);
14094 tree wrapper = build1_loc (loc, code, TREE_TYPE (expr), expr);
14095 /* Mark this node as being a wrapper. */
14096 EXPR_LOCATION_WRAPPER_P (wrapper) = 1;
14097 return wrapper;
14098 }
14099
14100 /* Return the name of combined function FN, for debugging purposes. */
14101
14102 const char *
combined_fn_name(combined_fn fn)14103 combined_fn_name (combined_fn fn)
14104 {
14105 if (builtin_fn_p (fn))
14106 {
14107 tree fndecl = builtin_decl_explicit (as_builtin_fn (fn));
14108 return IDENTIFIER_POINTER (DECL_NAME (fndecl));
14109 }
14110 else
14111 return internal_fn_name (as_internal_fn (fn));
14112 }
14113
14114 /* Return a bitmap with a bit set corresponding to each argument in
14115 a function call type FNTYPE declared with attribute nonnull,
14116 or null if none of the function's argument are nonnull. The caller
14117 must free the bitmap. */
14118
14119 bitmap
get_nonnull_args(const_tree fntype)14120 get_nonnull_args (const_tree fntype)
14121 {
14122 if (fntype == NULL_TREE)
14123 return NULL;
14124
14125 tree attrs = TYPE_ATTRIBUTES (fntype);
14126 if (!attrs)
14127 return NULL;
14128
14129 bitmap argmap = NULL;
14130
14131 /* A function declaration can specify multiple attribute nonnull,
14132 each with zero or more arguments. The loop below creates a bitmap
14133 representing a union of all the arguments. An empty (but non-null)
14134 bitmap means that all arguments have been declaraed nonnull. */
14135 for ( ; attrs; attrs = TREE_CHAIN (attrs))
14136 {
14137 attrs = lookup_attribute ("nonnull", attrs);
14138 if (!attrs)
14139 break;
14140
14141 if (!argmap)
14142 argmap = BITMAP_ALLOC (NULL);
14143
14144 if (!TREE_VALUE (attrs))
14145 {
14146 /* Clear the bitmap in case a previous attribute nonnull
14147 set it and this one overrides it for all arguments. */
14148 bitmap_clear (argmap);
14149 return argmap;
14150 }
14151
14152 /* Iterate over the indices of the format arguments declared nonnull
14153 and set a bit for each. */
14154 for (tree idx = TREE_VALUE (attrs); idx; idx = TREE_CHAIN (idx))
14155 {
14156 unsigned int val = TREE_INT_CST_LOW (TREE_VALUE (idx)) - 1;
14157 bitmap_set_bit (argmap, val);
14158 }
14159 }
14160
14161 return argmap;
14162 }
14163
14164 /* Returns true if TYPE is a type where it and all of its subobjects
14165 (recursively) are of structure, union, or array type. */
14166
14167 static bool
default_is_empty_type(tree type)14168 default_is_empty_type (tree type)
14169 {
14170 if (RECORD_OR_UNION_TYPE_P (type))
14171 {
14172 for (tree field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
14173 if (TREE_CODE (field) == FIELD_DECL
14174 && !DECL_PADDING_P (field)
14175 && !default_is_empty_type (TREE_TYPE (field)))
14176 return false;
14177 return true;
14178 }
14179 else if (TREE_CODE (type) == ARRAY_TYPE)
14180 return (integer_minus_onep (array_type_nelts (type))
14181 || TYPE_DOMAIN (type) == NULL_TREE
14182 || default_is_empty_type (TREE_TYPE (type)));
14183 return false;
14184 }
14185
14186 /* Implement TARGET_EMPTY_RECORD_P. Return true if TYPE is an empty type
14187 that shouldn't be passed via stack. */
14188
14189 bool
default_is_empty_record(const_tree type)14190 default_is_empty_record (const_tree type)
14191 {
14192 if (!abi_version_at_least (12))
14193 return false;
14194
14195 if (type == error_mark_node)
14196 return false;
14197
14198 if (TREE_ADDRESSABLE (type))
14199 return false;
14200
14201 return default_is_empty_type (TYPE_MAIN_VARIANT (type));
14202 }
14203
14204 /* Like int_size_in_bytes, but handle empty records specially. */
14205
14206 HOST_WIDE_INT
arg_int_size_in_bytes(const_tree type)14207 arg_int_size_in_bytes (const_tree type)
14208 {
14209 return TYPE_EMPTY_P (type) ? 0 : int_size_in_bytes (type);
14210 }
14211
14212 /* Like size_in_bytes, but handle empty records specially. */
14213
14214 tree
arg_size_in_bytes(const_tree type)14215 arg_size_in_bytes (const_tree type)
14216 {
14217 return TYPE_EMPTY_P (type) ? size_zero_node : size_in_bytes (type);
14218 }
14219
14220 /* Return true if an expression with CODE has to have the same result type as
14221 its first operand. */
14222
14223 bool
expr_type_first_operand_type_p(tree_code code)14224 expr_type_first_operand_type_p (tree_code code)
14225 {
14226 switch (code)
14227 {
14228 case NEGATE_EXPR:
14229 case ABS_EXPR:
14230 case BIT_NOT_EXPR:
14231 case PAREN_EXPR:
14232 case CONJ_EXPR:
14233
14234 case PLUS_EXPR:
14235 case MINUS_EXPR:
14236 case MULT_EXPR:
14237 case TRUNC_DIV_EXPR:
14238 case CEIL_DIV_EXPR:
14239 case FLOOR_DIV_EXPR:
14240 case ROUND_DIV_EXPR:
14241 case TRUNC_MOD_EXPR:
14242 case CEIL_MOD_EXPR:
14243 case FLOOR_MOD_EXPR:
14244 case ROUND_MOD_EXPR:
14245 case RDIV_EXPR:
14246 case EXACT_DIV_EXPR:
14247 case MIN_EXPR:
14248 case MAX_EXPR:
14249 case BIT_IOR_EXPR:
14250 case BIT_XOR_EXPR:
14251 case BIT_AND_EXPR:
14252
14253 case LSHIFT_EXPR:
14254 case RSHIFT_EXPR:
14255 case LROTATE_EXPR:
14256 case RROTATE_EXPR:
14257 return true;
14258
14259 default:
14260 return false;
14261 }
14262 }
14263
14264 /* List of pointer types used to declare builtins before we have seen their
14265 real declaration.
14266
14267 Keep the size up to date in tree.h ! */
14268 const builtin_structptr_type builtin_structptr_types[6] =
14269 {
14270 { fileptr_type_node, ptr_type_node, "FILE" },
14271 { const_tm_ptr_type_node, const_ptr_type_node, "tm" },
14272 { fenv_t_ptr_type_node, ptr_type_node, "fenv_t" },
14273 { const_fenv_t_ptr_type_node, const_ptr_type_node, "fenv_t" },
14274 { fexcept_t_ptr_type_node, ptr_type_node, "fexcept_t" },
14275 { const_fexcept_t_ptr_type_node, const_ptr_type_node, "fexcept_t" }
14276 };
14277
14278 #if CHECKING_P
14279
14280 namespace selftest {
14281
14282 /* Selftests for tree. */
14283
14284 /* Verify that integer constants are sane. */
14285
14286 static void
test_integer_constants()14287 test_integer_constants ()
14288 {
14289 ASSERT_TRUE (integer_type_node != NULL);
14290 ASSERT_TRUE (build_int_cst (integer_type_node, 0) != NULL);
14291
14292 tree type = integer_type_node;
14293
14294 tree zero = build_zero_cst (type);
14295 ASSERT_EQ (INTEGER_CST, TREE_CODE (zero));
14296 ASSERT_EQ (type, TREE_TYPE (zero));
14297
14298 tree one = build_int_cst (type, 1);
14299 ASSERT_EQ (INTEGER_CST, TREE_CODE (one));
14300 ASSERT_EQ (type, TREE_TYPE (zero));
14301 }
14302
14303 /* Verify identifiers. */
14304
14305 static void
test_identifiers()14306 test_identifiers ()
14307 {
14308 tree identifier = get_identifier ("foo");
14309 ASSERT_EQ (3, IDENTIFIER_LENGTH (identifier));
14310 ASSERT_STREQ ("foo", IDENTIFIER_POINTER (identifier));
14311 }
14312
14313 /* Verify LABEL_DECL. */
14314
14315 static void
test_labels()14316 test_labels ()
14317 {
14318 tree identifier = get_identifier ("err");
14319 tree label_decl = build_decl (UNKNOWN_LOCATION, LABEL_DECL,
14320 identifier, void_type_node);
14321 ASSERT_EQ (-1, LABEL_DECL_UID (label_decl));
14322 ASSERT_FALSE (FORCED_LABEL (label_decl));
14323 }
14324
14325 /* Return a new VECTOR_CST node whose type is TYPE and whose values
14326 are given by VALS. */
14327
14328 static tree
build_vector(tree type,vec<tree> vals MEM_STAT_DECL)14329 build_vector (tree type, vec<tree> vals MEM_STAT_DECL)
14330 {
14331 gcc_assert (known_eq (vals.length (), TYPE_VECTOR_SUBPARTS (type)));
14332 tree_vector_builder builder (type, vals.length (), 1);
14333 builder.splice (vals);
14334 return builder.build ();
14335 }
14336
14337 /* Check that VECTOR_CST ACTUAL contains the elements in EXPECTED. */
14338
14339 static void
check_vector_cst(vec<tree> expected,tree actual)14340 check_vector_cst (vec<tree> expected, tree actual)
14341 {
14342 ASSERT_KNOWN_EQ (expected.length (),
14343 TYPE_VECTOR_SUBPARTS (TREE_TYPE (actual)));
14344 for (unsigned int i = 0; i < expected.length (); ++i)
14345 ASSERT_EQ (wi::to_wide (expected[i]),
14346 wi::to_wide (vector_cst_elt (actual, i)));
14347 }
14348
14349 /* Check that VECTOR_CST ACTUAL contains NPATTERNS duplicated elements,
14350 and that its elements match EXPECTED. */
14351
14352 static void
check_vector_cst_duplicate(vec<tree> expected,tree actual,unsigned int npatterns)14353 check_vector_cst_duplicate (vec<tree> expected, tree actual,
14354 unsigned int npatterns)
14355 {
14356 ASSERT_EQ (npatterns, VECTOR_CST_NPATTERNS (actual));
14357 ASSERT_EQ (1, VECTOR_CST_NELTS_PER_PATTERN (actual));
14358 ASSERT_EQ (npatterns, vector_cst_encoded_nelts (actual));
14359 ASSERT_TRUE (VECTOR_CST_DUPLICATE_P (actual));
14360 ASSERT_FALSE (VECTOR_CST_STEPPED_P (actual));
14361 check_vector_cst (expected, actual);
14362 }
14363
14364 /* Check that VECTOR_CST ACTUAL contains NPATTERNS foreground elements
14365 and NPATTERNS background elements, and that its elements match
14366 EXPECTED. */
14367
14368 static void
check_vector_cst_fill(vec<tree> expected,tree actual,unsigned int npatterns)14369 check_vector_cst_fill (vec<tree> expected, tree actual,
14370 unsigned int npatterns)
14371 {
14372 ASSERT_EQ (npatterns, VECTOR_CST_NPATTERNS (actual));
14373 ASSERT_EQ (2, VECTOR_CST_NELTS_PER_PATTERN (actual));
14374 ASSERT_EQ (2 * npatterns, vector_cst_encoded_nelts (actual));
14375 ASSERT_FALSE (VECTOR_CST_DUPLICATE_P (actual));
14376 ASSERT_FALSE (VECTOR_CST_STEPPED_P (actual));
14377 check_vector_cst (expected, actual);
14378 }
14379
14380 /* Check that VECTOR_CST ACTUAL contains NPATTERNS stepped patterns,
14381 and that its elements match EXPECTED. */
14382
14383 static void
check_vector_cst_stepped(vec<tree> expected,tree actual,unsigned int npatterns)14384 check_vector_cst_stepped (vec<tree> expected, tree actual,
14385 unsigned int npatterns)
14386 {
14387 ASSERT_EQ (npatterns, VECTOR_CST_NPATTERNS (actual));
14388 ASSERT_EQ (3, VECTOR_CST_NELTS_PER_PATTERN (actual));
14389 ASSERT_EQ (3 * npatterns, vector_cst_encoded_nelts (actual));
14390 ASSERT_FALSE (VECTOR_CST_DUPLICATE_P (actual));
14391 ASSERT_TRUE (VECTOR_CST_STEPPED_P (actual));
14392 check_vector_cst (expected, actual);
14393 }
14394
14395 /* Test the creation of VECTOR_CSTs. */
14396
14397 static void
test_vector_cst_patterns(ALONE_CXX_MEM_STAT_INFO)14398 test_vector_cst_patterns (ALONE_CXX_MEM_STAT_INFO)
14399 {
14400 auto_vec<tree, 8> elements (8);
14401 elements.quick_grow (8);
14402 tree element_type = build_nonstandard_integer_type (16, true);
14403 tree vector_type = build_vector_type (element_type, 8);
14404
14405 /* Test a simple linear series with a base of 0 and a step of 1:
14406 { 0, 1, 2, 3, 4, 5, 6, 7 }. */
14407 for (unsigned int i = 0; i < 8; ++i)
14408 elements[i] = build_int_cst (element_type, i);
14409 tree vector = build_vector (vector_type, elements PASS_MEM_STAT);
14410 check_vector_cst_stepped (elements, vector, 1);
14411
14412 /* Try the same with the first element replaced by 100:
14413 { 100, 1, 2, 3, 4, 5, 6, 7 }. */
14414 elements[0] = build_int_cst (element_type, 100);
14415 vector = build_vector (vector_type, elements PASS_MEM_STAT);
14416 check_vector_cst_stepped (elements, vector, 1);
14417
14418 /* Try a series that wraps around.
14419 { 100, 65531, 65532, 65533, 65534, 65535, 0, 1 }. */
14420 for (unsigned int i = 1; i < 8; ++i)
14421 elements[i] = build_int_cst (element_type, (65530 + i) & 0xffff);
14422 vector = build_vector (vector_type, elements PASS_MEM_STAT);
14423 check_vector_cst_stepped (elements, vector, 1);
14424
14425 /* Try a downward series:
14426 { 100, 79, 78, 77, 76, 75, 75, 73 }. */
14427 for (unsigned int i = 1; i < 8; ++i)
14428 elements[i] = build_int_cst (element_type, 80 - i);
14429 vector = build_vector (vector_type, elements PASS_MEM_STAT);
14430 check_vector_cst_stepped (elements, vector, 1);
14431
14432 /* Try two interleaved series with different bases and steps:
14433 { 100, 53, 66, 206, 62, 212, 58, 218 }. */
14434 elements[1] = build_int_cst (element_type, 53);
14435 for (unsigned int i = 2; i < 8; i += 2)
14436 {
14437 elements[i] = build_int_cst (element_type, 70 - i * 2);
14438 elements[i + 1] = build_int_cst (element_type, 200 + i * 3);
14439 }
14440 vector = build_vector (vector_type, elements PASS_MEM_STAT);
14441 check_vector_cst_stepped (elements, vector, 2);
14442
14443 /* Try a duplicated value:
14444 { 100, 100, 100, 100, 100, 100, 100, 100 }. */
14445 for (unsigned int i = 1; i < 8; ++i)
14446 elements[i] = elements[0];
14447 vector = build_vector (vector_type, elements PASS_MEM_STAT);
14448 check_vector_cst_duplicate (elements, vector, 1);
14449
14450 /* Try an interleaved duplicated value:
14451 { 100, 55, 100, 55, 100, 55, 100, 55 }. */
14452 elements[1] = build_int_cst (element_type, 55);
14453 for (unsigned int i = 2; i < 8; ++i)
14454 elements[i] = elements[i - 2];
14455 vector = build_vector (vector_type, elements PASS_MEM_STAT);
14456 check_vector_cst_duplicate (elements, vector, 2);
14457
14458 /* Try a duplicated value with 2 exceptions
14459 { 41, 97, 100, 55, 100, 55, 100, 55 }. */
14460 elements[0] = build_int_cst (element_type, 41);
14461 elements[1] = build_int_cst (element_type, 97);
14462 vector = build_vector (vector_type, elements PASS_MEM_STAT);
14463 check_vector_cst_fill (elements, vector, 2);
14464
14465 /* Try with and without a step
14466 { 41, 97, 100, 21, 100, 35, 100, 49 }. */
14467 for (unsigned int i = 3; i < 8; i += 2)
14468 elements[i] = build_int_cst (element_type, i * 7);
14469 vector = build_vector (vector_type, elements PASS_MEM_STAT);
14470 check_vector_cst_stepped (elements, vector, 2);
14471
14472 /* Try a fully-general constant:
14473 { 41, 97, 100, 21, 100, 9990, 100, 49 }. */
14474 elements[5] = build_int_cst (element_type, 9990);
14475 vector = build_vector (vector_type, elements PASS_MEM_STAT);
14476 check_vector_cst_fill (elements, vector, 4);
14477 }
14478
14479 /* Verify that STRIP_NOPS (NODE) is EXPECTED.
14480 Helper function for test_location_wrappers, to deal with STRIP_NOPS
14481 modifying its argument in-place. */
14482
14483 static void
check_strip_nops(tree node,tree expected)14484 check_strip_nops (tree node, tree expected)
14485 {
14486 STRIP_NOPS (node);
14487 ASSERT_EQ (expected, node);
14488 }
14489
14490 /* Verify location wrappers. */
14491
14492 static void
test_location_wrappers()14493 test_location_wrappers ()
14494 {
14495 location_t loc = BUILTINS_LOCATION;
14496
14497 ASSERT_EQ (NULL_TREE, maybe_wrap_with_location (NULL_TREE, loc));
14498
14499 /* Wrapping a constant. */
14500 tree int_cst = build_int_cst (integer_type_node, 42);
14501 ASSERT_FALSE (CAN_HAVE_LOCATION_P (int_cst));
14502 ASSERT_FALSE (location_wrapper_p (int_cst));
14503
14504 tree wrapped_int_cst = maybe_wrap_with_location (int_cst, loc);
14505 ASSERT_TRUE (location_wrapper_p (wrapped_int_cst));
14506 ASSERT_EQ (loc, EXPR_LOCATION (wrapped_int_cst));
14507 ASSERT_EQ (int_cst, tree_strip_any_location_wrapper (wrapped_int_cst));
14508
14509 /* We shouldn't add wrapper nodes for UNKNOWN_LOCATION. */
14510 ASSERT_EQ (int_cst, maybe_wrap_with_location (int_cst, UNKNOWN_LOCATION));
14511
14512 /* We shouldn't add wrapper nodes for nodes that CAN_HAVE_LOCATION_P. */
14513 tree cast = build1 (NOP_EXPR, char_type_node, int_cst);
14514 ASSERT_TRUE (CAN_HAVE_LOCATION_P (cast));
14515 ASSERT_EQ (cast, maybe_wrap_with_location (cast, loc));
14516
14517 /* Wrapping a STRING_CST. */
14518 tree string_cst = build_string (4, "foo");
14519 ASSERT_FALSE (CAN_HAVE_LOCATION_P (string_cst));
14520 ASSERT_FALSE (location_wrapper_p (string_cst));
14521
14522 tree wrapped_string_cst = maybe_wrap_with_location (string_cst, loc);
14523 ASSERT_TRUE (location_wrapper_p (wrapped_string_cst));
14524 ASSERT_EQ (VIEW_CONVERT_EXPR, TREE_CODE (wrapped_string_cst));
14525 ASSERT_EQ (loc, EXPR_LOCATION (wrapped_string_cst));
14526 ASSERT_EQ (string_cst, tree_strip_any_location_wrapper (wrapped_string_cst));
14527
14528
14529 /* Wrapping a variable. */
14530 tree int_var = build_decl (UNKNOWN_LOCATION, VAR_DECL,
14531 get_identifier ("some_int_var"),
14532 integer_type_node);
14533 ASSERT_FALSE (CAN_HAVE_LOCATION_P (int_var));
14534 ASSERT_FALSE (location_wrapper_p (int_var));
14535
14536 tree wrapped_int_var = maybe_wrap_with_location (int_var, loc);
14537 ASSERT_TRUE (location_wrapper_p (wrapped_int_var));
14538 ASSERT_EQ (loc, EXPR_LOCATION (wrapped_int_var));
14539 ASSERT_EQ (int_var, tree_strip_any_location_wrapper (wrapped_int_var));
14540
14541 /* Verify that "reinterpret_cast<int>(some_int_var)" is not a location
14542 wrapper. */
14543 tree r_cast = build1 (NON_LVALUE_EXPR, integer_type_node, int_var);
14544 ASSERT_FALSE (location_wrapper_p (r_cast));
14545 ASSERT_EQ (r_cast, tree_strip_any_location_wrapper (r_cast));
14546
14547 /* Verify that STRIP_NOPS removes wrappers. */
14548 check_strip_nops (wrapped_int_cst, int_cst);
14549 check_strip_nops (wrapped_string_cst, string_cst);
14550 check_strip_nops (wrapped_int_var, int_var);
14551 }
14552
14553 /* Run all of the selftests within this file. */
14554
14555 void
tree_c_tests()14556 tree_c_tests ()
14557 {
14558 test_integer_constants ();
14559 test_identifiers ();
14560 test_labels ();
14561 test_vector_cst_patterns ();
14562 test_location_wrappers ();
14563 }
14564
14565 } // namespace selftest
14566
14567 #endif /* CHECKING_P */
14568
14569 #include "gt-tree.h"
14570