1 /* Language-independent node constructors for parse phase of GNU compiler.
2 Copyright (C) 1987-2014 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 occasionally
28 calls language-dependent routines defined (for C) in typecheck.c. */
29
30 #include "config.h"
31 #include "system.h"
32 #include "coretypes.h"
33 #include "tm.h"
34 #include "flags.h"
35 #include "tree.h"
36 #include "stor-layout.h"
37 #include "calls.h"
38 #include "attribs.h"
39 #include "varasm.h"
40 #include "tm_p.h"
41 #include "function.h"
42 #include "obstack.h"
43 #include "toplev.h" /* get_random_seed */
44 #include "hashtab.h"
45 #include "filenames.h"
46 #include "output.h"
47 #include "target.h"
48 #include "common/common-target.h"
49 #include "langhooks.h"
50 #include "tree-inline.h"
51 #include "tree-iterator.h"
52 #include "basic-block.h"
53 #include "bitmap.h"
54 #include "pointer-set.h"
55 #include "tree-ssa-alias.h"
56 #include "internal-fn.h"
57 #include "gimple-expr.h"
58 #include "is-a.h"
59 #include "gimple.h"
60 #include "gimple-iterator.h"
61 #include "gimplify.h"
62 #include "gimple-ssa.h"
63 #include "cgraph.h"
64 #include "tree-phinodes.h"
65 #include "stringpool.h"
66 #include "tree-ssanames.h"
67 #include "expr.h"
68 #include "tree-dfa.h"
69 #include "params.h"
70 #include "tree-pass.h"
71 #include "langhooks-def.h"
72 #include "diagnostic.h"
73 #include "tree-diagnostic.h"
74 #include "tree-pretty-print.h"
75 #include "except.h"
76 #include "debug.h"
77 #include "intl.h"
78
79 /* Tree code classes. */
80
81 #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) TYPE,
82 #define END_OF_BASE_TREE_CODES tcc_exceptional,
83
84 const enum tree_code_class tree_code_type[] = {
85 #include "all-tree.def"
86 };
87
88 #undef DEFTREECODE
89 #undef END_OF_BASE_TREE_CODES
90
91 /* Table indexed by tree code giving number of expression
92 operands beyond the fixed part of the node structure.
93 Not used for types or decls. */
94
95 #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) LENGTH,
96 #define END_OF_BASE_TREE_CODES 0,
97
98 const unsigned char tree_code_length[] = {
99 #include "all-tree.def"
100 };
101
102 #undef DEFTREECODE
103 #undef END_OF_BASE_TREE_CODES
104
105 /* Names of tree components.
106 Used for printing out the tree and error messages. */
107 #define DEFTREECODE(SYM, NAME, TYPE, LEN) NAME,
108 #define END_OF_BASE_TREE_CODES "@dummy",
109
110 static const char *const tree_code_name[] = {
111 #include "all-tree.def"
112 };
113
114 #undef DEFTREECODE
115 #undef END_OF_BASE_TREE_CODES
116
117 /* Each tree code class has an associated string representation.
118 These must correspond to the tree_code_class entries. */
119
120 const char *const tree_code_class_strings[] =
121 {
122 "exceptional",
123 "constant",
124 "type",
125 "declaration",
126 "reference",
127 "comparison",
128 "unary",
129 "binary",
130 "statement",
131 "vl_exp",
132 "expression"
133 };
134
135 /* obstack.[ch] explicitly declined to prototype this. */
136 extern int _obstack_allocated_p (struct obstack *h, void *obj);
137
138 /* Statistics-gathering stuff. */
139
140 static int tree_code_counts[MAX_TREE_CODES];
141 int tree_node_counts[(int) all_kinds];
142 int tree_node_sizes[(int) all_kinds];
143
144 /* Keep in sync with tree.h:enum tree_node_kind. */
145 static const char * const tree_node_kind_names[] = {
146 "decls",
147 "types",
148 "blocks",
149 "stmts",
150 "refs",
151 "exprs",
152 "constants",
153 "identifiers",
154 "vecs",
155 "binfos",
156 "ssa names",
157 "constructors",
158 "random kinds",
159 "lang_decl kinds",
160 "lang_type kinds",
161 "omp clauses",
162 };
163
164 /* Unique id for next decl created. */
165 static GTY(()) int next_decl_uid;
166 /* Unique id for next type created. */
167 static GTY(()) int next_type_uid = 1;
168 /* Unique id for next debug decl created. Use negative numbers,
169 to catch erroneous uses. */
170 static GTY(()) int next_debug_decl_uid;
171
172 /* Since we cannot rehash a type after it is in the table, we have to
173 keep the hash code. */
174
175 struct GTY(()) type_hash {
176 unsigned long hash;
177 tree type;
178 };
179
180 /* Initial size of the hash table (rounded to next prime). */
181 #define TYPE_HASH_INITIAL_SIZE 1000
182
183 /* Now here is the hash table. When recording a type, it is added to
184 the slot whose index is the hash code. Note that the hash table is
185 used for several kinds of types (function types, array types and
186 array index range types, for now). While all these live in the
187 same table, they are completely independent, and the hash code is
188 computed differently for each of these. */
189
190 static GTY ((if_marked ("type_hash_marked_p"), param_is (struct type_hash)))
191 htab_t type_hash_table;
192
193 /* Hash table and temporary node for larger integer const values. */
194 static GTY (()) tree int_cst_node;
195 static GTY ((if_marked ("ggc_marked_p"), param_is (union tree_node)))
196 htab_t int_cst_hash_table;
197
198 /* Hash table for optimization flags and target option flags. Use the same
199 hash table for both sets of options. Nodes for building the current
200 optimization and target option nodes. The assumption is most of the time
201 the options created will already be in the hash table, so we avoid
202 allocating and freeing up a node repeatably. */
203 static GTY (()) tree cl_optimization_node;
204 static GTY (()) tree cl_target_option_node;
205 static GTY ((if_marked ("ggc_marked_p"), param_is (union tree_node)))
206 htab_t cl_option_hash_table;
207
208 /* General tree->tree mapping structure for use in hash tables. */
209
210
211 static GTY ((if_marked ("tree_decl_map_marked_p"), param_is (struct tree_decl_map)))
212 htab_t debug_expr_for_decl;
213
214 static GTY ((if_marked ("tree_decl_map_marked_p"), param_is (struct tree_decl_map)))
215 htab_t value_expr_for_decl;
216
217 static GTY ((if_marked ("tree_vec_map_marked_p"), param_is (struct tree_vec_map)))
218 htab_t debug_args_for_decl;
219
220 static GTY ((if_marked ("tree_priority_map_marked_p"),
221 param_is (struct tree_priority_map)))
222 htab_t init_priority_for_decl;
223
224 static void set_type_quals (tree, int);
225 static int type_hash_eq (const void *, const void *);
226 static hashval_t type_hash_hash (const void *);
227 static hashval_t int_cst_hash_hash (const void *);
228 static int int_cst_hash_eq (const void *, const void *);
229 static hashval_t cl_option_hash_hash (const void *);
230 static int cl_option_hash_eq (const void *, const void *);
231 static void print_type_hash_statistics (void);
232 static void print_debug_expr_statistics (void);
233 static void print_value_expr_statistics (void);
234 static int type_hash_marked_p (const void *);
235 static unsigned int type_hash_list (const_tree, hashval_t);
236 static unsigned int attribute_hash_list (const_tree, hashval_t);
237 static bool decls_same_for_odr (tree decl1, tree decl2);
238
239 tree global_trees[TI_MAX];
240 tree integer_types[itk_none];
241
242 unsigned char tree_contains_struct[MAX_TREE_CODES][64];
243
244 /* Number of operands for each OpenMP clause. */
245 unsigned const char omp_clause_num_ops[] =
246 {
247 0, /* OMP_CLAUSE_ERROR */
248 1, /* OMP_CLAUSE_PRIVATE */
249 1, /* OMP_CLAUSE_SHARED */
250 1, /* OMP_CLAUSE_FIRSTPRIVATE */
251 2, /* OMP_CLAUSE_LASTPRIVATE */
252 4, /* OMP_CLAUSE_REDUCTION */
253 1, /* OMP_CLAUSE_COPYIN */
254 1, /* OMP_CLAUSE_COPYPRIVATE */
255 3, /* OMP_CLAUSE_LINEAR */
256 2, /* OMP_CLAUSE_ALIGNED */
257 1, /* OMP_CLAUSE_DEPEND */
258 1, /* OMP_CLAUSE_UNIFORM */
259 2, /* OMP_CLAUSE_FROM */
260 2, /* OMP_CLAUSE_TO */
261 2, /* OMP_CLAUSE_MAP */
262 1, /* OMP_CLAUSE__LOOPTEMP_ */
263 1, /* OMP_CLAUSE_IF */
264 1, /* OMP_CLAUSE_NUM_THREADS */
265 1, /* OMP_CLAUSE_SCHEDULE */
266 0, /* OMP_CLAUSE_NOWAIT */
267 0, /* OMP_CLAUSE_ORDERED */
268 0, /* OMP_CLAUSE_DEFAULT */
269 3, /* OMP_CLAUSE_COLLAPSE */
270 0, /* OMP_CLAUSE_UNTIED */
271 1, /* OMP_CLAUSE_FINAL */
272 0, /* OMP_CLAUSE_MERGEABLE */
273 1, /* OMP_CLAUSE_DEVICE */
274 1, /* OMP_CLAUSE_DIST_SCHEDULE */
275 0, /* OMP_CLAUSE_INBRANCH */
276 0, /* OMP_CLAUSE_NOTINBRANCH */
277 1, /* OMP_CLAUSE_NUM_TEAMS */
278 1, /* OMP_CLAUSE_THREAD_LIMIT */
279 0, /* OMP_CLAUSE_PROC_BIND */
280 1, /* OMP_CLAUSE_SAFELEN */
281 1, /* OMP_CLAUSE_SIMDLEN */
282 0, /* OMP_CLAUSE_FOR */
283 0, /* OMP_CLAUSE_PARALLEL */
284 0, /* OMP_CLAUSE_SECTIONS */
285 0, /* OMP_CLAUSE_TASKGROUP */
286 1, /* OMP_CLAUSE__SIMDUID_ */
287 };
288
289 const char * const omp_clause_code_name[] =
290 {
291 "error_clause",
292 "private",
293 "shared",
294 "firstprivate",
295 "lastprivate",
296 "reduction",
297 "copyin",
298 "copyprivate",
299 "linear",
300 "aligned",
301 "depend",
302 "uniform",
303 "from",
304 "to",
305 "map",
306 "_looptemp_",
307 "if",
308 "num_threads",
309 "schedule",
310 "nowait",
311 "ordered",
312 "default",
313 "collapse",
314 "untied",
315 "final",
316 "mergeable",
317 "device",
318 "dist_schedule",
319 "inbranch",
320 "notinbranch",
321 "num_teams",
322 "thread_limit",
323 "proc_bind",
324 "safelen",
325 "simdlen",
326 "for",
327 "parallel",
328 "sections",
329 "taskgroup",
330 "_simduid_"
331 };
332
333
334 /* Return the tree node structure used by tree code CODE. */
335
336 static inline enum tree_node_structure_enum
tree_node_structure_for_code(enum tree_code code)337 tree_node_structure_for_code (enum tree_code code)
338 {
339 switch (TREE_CODE_CLASS (code))
340 {
341 case tcc_declaration:
342 {
343 switch (code)
344 {
345 case FIELD_DECL:
346 return TS_FIELD_DECL;
347 case PARM_DECL:
348 return TS_PARM_DECL;
349 case VAR_DECL:
350 return TS_VAR_DECL;
351 case LABEL_DECL:
352 return TS_LABEL_DECL;
353 case RESULT_DECL:
354 return TS_RESULT_DECL;
355 case DEBUG_EXPR_DECL:
356 return TS_DECL_WRTL;
357 case CONST_DECL:
358 return TS_CONST_DECL;
359 case TYPE_DECL:
360 return TS_TYPE_DECL;
361 case FUNCTION_DECL:
362 return TS_FUNCTION_DECL;
363 case TRANSLATION_UNIT_DECL:
364 return TS_TRANSLATION_UNIT_DECL;
365 default:
366 return TS_DECL_NON_COMMON;
367 }
368 }
369 case tcc_type:
370 return TS_TYPE_NON_COMMON;
371 case tcc_reference:
372 case tcc_comparison:
373 case tcc_unary:
374 case tcc_binary:
375 case tcc_expression:
376 case tcc_statement:
377 case tcc_vl_exp:
378 return TS_EXP;
379 default: /* tcc_constant and tcc_exceptional */
380 break;
381 }
382 switch (code)
383 {
384 /* tcc_constant cases. */
385 case INTEGER_CST: return TS_INT_CST;
386 case REAL_CST: return TS_REAL_CST;
387 case FIXED_CST: return TS_FIXED_CST;
388 case COMPLEX_CST: return TS_COMPLEX;
389 case VECTOR_CST: return TS_VECTOR;
390 case STRING_CST: return TS_STRING;
391 /* tcc_exceptional cases. */
392 case ERROR_MARK: return TS_COMMON;
393 case IDENTIFIER_NODE: return TS_IDENTIFIER;
394 case TREE_LIST: return TS_LIST;
395 case TREE_VEC: return TS_VEC;
396 case SSA_NAME: return TS_SSA_NAME;
397 case PLACEHOLDER_EXPR: return TS_COMMON;
398 case STATEMENT_LIST: return TS_STATEMENT_LIST;
399 case BLOCK: return TS_BLOCK;
400 case CONSTRUCTOR: return TS_CONSTRUCTOR;
401 case TREE_BINFO: return TS_BINFO;
402 case OMP_CLAUSE: return TS_OMP_CLAUSE;
403 case OPTIMIZATION_NODE: return TS_OPTIMIZATION;
404 case TARGET_OPTION_NODE: return TS_TARGET_OPTION;
405
406 default:
407 gcc_unreachable ();
408 }
409 }
410
411
412 /* Initialize tree_contains_struct to describe the hierarchy of tree
413 nodes. */
414
415 static void
initialize_tree_contains_struct(void)416 initialize_tree_contains_struct (void)
417 {
418 unsigned i;
419
420 for (i = ERROR_MARK; i < LAST_AND_UNUSED_TREE_CODE; i++)
421 {
422 enum tree_code code;
423 enum tree_node_structure_enum ts_code;
424
425 code = (enum tree_code) i;
426 ts_code = tree_node_structure_for_code (code);
427
428 /* Mark the TS structure itself. */
429 tree_contains_struct[code][ts_code] = 1;
430
431 /* Mark all the structures that TS is derived from. */
432 switch (ts_code)
433 {
434 case TS_TYPED:
435 case TS_BLOCK:
436 MARK_TS_BASE (code);
437 break;
438
439 case TS_COMMON:
440 case TS_INT_CST:
441 case TS_REAL_CST:
442 case TS_FIXED_CST:
443 case TS_VECTOR:
444 case TS_STRING:
445 case TS_COMPLEX:
446 case TS_SSA_NAME:
447 case TS_CONSTRUCTOR:
448 case TS_EXP:
449 case TS_STATEMENT_LIST:
450 MARK_TS_TYPED (code);
451 break;
452
453 case TS_IDENTIFIER:
454 case TS_DECL_MINIMAL:
455 case TS_TYPE_COMMON:
456 case TS_LIST:
457 case TS_VEC:
458 case TS_BINFO:
459 case TS_OMP_CLAUSE:
460 case TS_OPTIMIZATION:
461 case TS_TARGET_OPTION:
462 MARK_TS_COMMON (code);
463 break;
464
465 case TS_TYPE_WITH_LANG_SPECIFIC:
466 MARK_TS_TYPE_COMMON (code);
467 break;
468
469 case TS_TYPE_NON_COMMON:
470 MARK_TS_TYPE_WITH_LANG_SPECIFIC (code);
471 break;
472
473 case TS_DECL_COMMON:
474 MARK_TS_DECL_MINIMAL (code);
475 break;
476
477 case TS_DECL_WRTL:
478 case TS_CONST_DECL:
479 MARK_TS_DECL_COMMON (code);
480 break;
481
482 case TS_DECL_NON_COMMON:
483 MARK_TS_DECL_WITH_VIS (code);
484 break;
485
486 case TS_DECL_WITH_VIS:
487 case TS_PARM_DECL:
488 case TS_LABEL_DECL:
489 case TS_RESULT_DECL:
490 MARK_TS_DECL_WRTL (code);
491 break;
492
493 case TS_FIELD_DECL:
494 MARK_TS_DECL_COMMON (code);
495 break;
496
497 case TS_VAR_DECL:
498 MARK_TS_DECL_WITH_VIS (code);
499 break;
500
501 case TS_TYPE_DECL:
502 case TS_FUNCTION_DECL:
503 MARK_TS_DECL_NON_COMMON (code);
504 break;
505
506 case TS_TRANSLATION_UNIT_DECL:
507 MARK_TS_DECL_COMMON (code);
508 break;
509
510 default:
511 gcc_unreachable ();
512 }
513 }
514
515 /* Basic consistency checks for attributes used in fold. */
516 gcc_assert (tree_contains_struct[FUNCTION_DECL][TS_DECL_NON_COMMON]);
517 gcc_assert (tree_contains_struct[TYPE_DECL][TS_DECL_NON_COMMON]);
518 gcc_assert (tree_contains_struct[CONST_DECL][TS_DECL_COMMON]);
519 gcc_assert (tree_contains_struct[VAR_DECL][TS_DECL_COMMON]);
520 gcc_assert (tree_contains_struct[PARM_DECL][TS_DECL_COMMON]);
521 gcc_assert (tree_contains_struct[RESULT_DECL][TS_DECL_COMMON]);
522 gcc_assert (tree_contains_struct[FUNCTION_DECL][TS_DECL_COMMON]);
523 gcc_assert (tree_contains_struct[TYPE_DECL][TS_DECL_COMMON]);
524 gcc_assert (tree_contains_struct[TRANSLATION_UNIT_DECL][TS_DECL_COMMON]);
525 gcc_assert (tree_contains_struct[LABEL_DECL][TS_DECL_COMMON]);
526 gcc_assert (tree_contains_struct[FIELD_DECL][TS_DECL_COMMON]);
527 gcc_assert (tree_contains_struct[VAR_DECL][TS_DECL_WRTL]);
528 gcc_assert (tree_contains_struct[PARM_DECL][TS_DECL_WRTL]);
529 gcc_assert (tree_contains_struct[RESULT_DECL][TS_DECL_WRTL]);
530 gcc_assert (tree_contains_struct[FUNCTION_DECL][TS_DECL_WRTL]);
531 gcc_assert (tree_contains_struct[LABEL_DECL][TS_DECL_WRTL]);
532 gcc_assert (tree_contains_struct[CONST_DECL][TS_DECL_MINIMAL]);
533 gcc_assert (tree_contains_struct[VAR_DECL][TS_DECL_MINIMAL]);
534 gcc_assert (tree_contains_struct[PARM_DECL][TS_DECL_MINIMAL]);
535 gcc_assert (tree_contains_struct[RESULT_DECL][TS_DECL_MINIMAL]);
536 gcc_assert (tree_contains_struct[FUNCTION_DECL][TS_DECL_MINIMAL]);
537 gcc_assert (tree_contains_struct[TYPE_DECL][TS_DECL_MINIMAL]);
538 gcc_assert (tree_contains_struct[TRANSLATION_UNIT_DECL][TS_DECL_MINIMAL]);
539 gcc_assert (tree_contains_struct[LABEL_DECL][TS_DECL_MINIMAL]);
540 gcc_assert (tree_contains_struct[FIELD_DECL][TS_DECL_MINIMAL]);
541 gcc_assert (tree_contains_struct[VAR_DECL][TS_DECL_WITH_VIS]);
542 gcc_assert (tree_contains_struct[FUNCTION_DECL][TS_DECL_WITH_VIS]);
543 gcc_assert (tree_contains_struct[TYPE_DECL][TS_DECL_WITH_VIS]);
544 gcc_assert (tree_contains_struct[VAR_DECL][TS_VAR_DECL]);
545 gcc_assert (tree_contains_struct[FIELD_DECL][TS_FIELD_DECL]);
546 gcc_assert (tree_contains_struct[PARM_DECL][TS_PARM_DECL]);
547 gcc_assert (tree_contains_struct[LABEL_DECL][TS_LABEL_DECL]);
548 gcc_assert (tree_contains_struct[RESULT_DECL][TS_RESULT_DECL]);
549 gcc_assert (tree_contains_struct[CONST_DECL][TS_CONST_DECL]);
550 gcc_assert (tree_contains_struct[TYPE_DECL][TS_TYPE_DECL]);
551 gcc_assert (tree_contains_struct[FUNCTION_DECL][TS_FUNCTION_DECL]);
552 gcc_assert (tree_contains_struct[IMPORTED_DECL][TS_DECL_MINIMAL]);
553 gcc_assert (tree_contains_struct[IMPORTED_DECL][TS_DECL_COMMON]);
554 gcc_assert (tree_contains_struct[NAMELIST_DECL][TS_DECL_MINIMAL]);
555 gcc_assert (tree_contains_struct[NAMELIST_DECL][TS_DECL_COMMON]);
556 }
557
558
559 /* Init tree.c. */
560
561 void
init_ttree(void)562 init_ttree (void)
563 {
564 /* Initialize the hash table of types. */
565 type_hash_table = htab_create_ggc (TYPE_HASH_INITIAL_SIZE, type_hash_hash,
566 type_hash_eq, 0);
567
568 debug_expr_for_decl = htab_create_ggc (512, tree_decl_map_hash,
569 tree_decl_map_eq, 0);
570
571 value_expr_for_decl = htab_create_ggc (512, tree_decl_map_hash,
572 tree_decl_map_eq, 0);
573 init_priority_for_decl = htab_create_ggc (512, tree_priority_map_hash,
574 tree_priority_map_eq, 0);
575
576 int_cst_hash_table = htab_create_ggc (1024, int_cst_hash_hash,
577 int_cst_hash_eq, NULL);
578
579 int_cst_node = make_node (INTEGER_CST);
580
581 cl_option_hash_table = htab_create_ggc (64, cl_option_hash_hash,
582 cl_option_hash_eq, NULL);
583
584 cl_optimization_node = make_node (OPTIMIZATION_NODE);
585 cl_target_option_node = make_node (TARGET_OPTION_NODE);
586
587 /* Initialize the tree_contains_struct array. */
588 initialize_tree_contains_struct ();
589 lang_hooks.init_ts ();
590 }
591
592
593 /* The name of the object as the assembler will see it (but before any
594 translations made by ASM_OUTPUT_LABELREF). Often this is the same
595 as DECL_NAME. It is an IDENTIFIER_NODE. */
596 tree
decl_assembler_name(tree decl)597 decl_assembler_name (tree decl)
598 {
599 if (!DECL_ASSEMBLER_NAME_SET_P (decl))
600 lang_hooks.set_decl_assembler_name (decl);
601 return DECL_WITH_VIS_CHECK (decl)->decl_with_vis.assembler_name;
602 }
603
604 /* Compute the number of bytes occupied by a tree with code CODE.
605 This function cannot be used for nodes that have variable sizes,
606 including TREE_VEC, STRING_CST, and CALL_EXPR. */
607 size_t
tree_code_size(enum tree_code code)608 tree_code_size (enum tree_code code)
609 {
610 switch (TREE_CODE_CLASS (code))
611 {
612 case tcc_declaration: /* A decl node */
613 {
614 switch (code)
615 {
616 case FIELD_DECL:
617 return sizeof (struct tree_field_decl);
618 case PARM_DECL:
619 return sizeof (struct tree_parm_decl);
620 case VAR_DECL:
621 return sizeof (struct tree_var_decl);
622 case LABEL_DECL:
623 return sizeof (struct tree_label_decl);
624 case RESULT_DECL:
625 return sizeof (struct tree_result_decl);
626 case CONST_DECL:
627 return sizeof (struct tree_const_decl);
628 case TYPE_DECL:
629 return sizeof (struct tree_type_decl);
630 case FUNCTION_DECL:
631 return sizeof (struct tree_function_decl);
632 case DEBUG_EXPR_DECL:
633 return sizeof (struct tree_decl_with_rtl);
634 default:
635 return sizeof (struct tree_decl_non_common);
636 }
637 }
638
639 case tcc_type: /* a type node */
640 return sizeof (struct tree_type_non_common);
641
642 case tcc_reference: /* a reference */
643 case tcc_expression: /* an expression */
644 case tcc_statement: /* an expression with side effects */
645 case tcc_comparison: /* a comparison expression */
646 case tcc_unary: /* a unary arithmetic expression */
647 case tcc_binary: /* a binary arithmetic expression */
648 return (sizeof (struct tree_exp)
649 + (TREE_CODE_LENGTH (code) - 1) * sizeof (tree));
650
651 case tcc_constant: /* a constant */
652 switch (code)
653 {
654 case INTEGER_CST: return sizeof (struct tree_int_cst);
655 case REAL_CST: return sizeof (struct tree_real_cst);
656 case FIXED_CST: return sizeof (struct tree_fixed_cst);
657 case COMPLEX_CST: return sizeof (struct tree_complex);
658 case VECTOR_CST: return sizeof (struct tree_vector);
659 case STRING_CST: gcc_unreachable ();
660 default:
661 return lang_hooks.tree_size (code);
662 }
663
664 case tcc_exceptional: /* something random, like an identifier. */
665 switch (code)
666 {
667 case IDENTIFIER_NODE: return lang_hooks.identifier_size;
668 case TREE_LIST: return sizeof (struct tree_list);
669
670 case ERROR_MARK:
671 case PLACEHOLDER_EXPR: return sizeof (struct tree_common);
672
673 case TREE_VEC:
674 case OMP_CLAUSE: gcc_unreachable ();
675
676 case SSA_NAME: return sizeof (struct tree_ssa_name);
677
678 case STATEMENT_LIST: return sizeof (struct tree_statement_list);
679 case BLOCK: return sizeof (struct tree_block);
680 case CONSTRUCTOR: return sizeof (struct tree_constructor);
681 case OPTIMIZATION_NODE: return sizeof (struct tree_optimization_option);
682 case TARGET_OPTION_NODE: return sizeof (struct tree_target_option);
683
684 default:
685 return lang_hooks.tree_size (code);
686 }
687
688 default:
689 gcc_unreachable ();
690 }
691 }
692
693 /* Compute the number of bytes occupied by NODE. This routine only
694 looks at TREE_CODE, except for those nodes that have variable sizes. */
695 size_t
tree_size(const_tree node)696 tree_size (const_tree node)
697 {
698 const enum tree_code code = TREE_CODE (node);
699 switch (code)
700 {
701 case TREE_BINFO:
702 return (offsetof (struct tree_binfo, base_binfos)
703 + vec<tree, va_gc>
704 ::embedded_size (BINFO_N_BASE_BINFOS (node)));
705
706 case TREE_VEC:
707 return (sizeof (struct tree_vec)
708 + (TREE_VEC_LENGTH (node) - 1) * sizeof (tree));
709
710 case VECTOR_CST:
711 return (sizeof (struct tree_vector)
712 + (TYPE_VECTOR_SUBPARTS (TREE_TYPE (node)) - 1) * sizeof (tree));
713
714 case STRING_CST:
715 return TREE_STRING_LENGTH (node) + offsetof (struct tree_string, str) + 1;
716
717 case OMP_CLAUSE:
718 return (sizeof (struct tree_omp_clause)
719 + (omp_clause_num_ops[OMP_CLAUSE_CODE (node)] - 1)
720 * sizeof (tree));
721
722 default:
723 if (TREE_CODE_CLASS (code) == tcc_vl_exp)
724 return (sizeof (struct tree_exp)
725 + (VL_EXP_OPERAND_LENGTH (node) - 1) * sizeof (tree));
726 else
727 return tree_code_size (code);
728 }
729 }
730
731 /* Record interesting allocation statistics for a tree node with CODE
732 and LENGTH. */
733
734 static void
record_node_allocation_statistics(enum tree_code code ATTRIBUTE_UNUSED,size_t length ATTRIBUTE_UNUSED)735 record_node_allocation_statistics (enum tree_code code ATTRIBUTE_UNUSED,
736 size_t length ATTRIBUTE_UNUSED)
737 {
738 enum tree_code_class type = TREE_CODE_CLASS (code);
739 tree_node_kind kind;
740
741 if (!GATHER_STATISTICS)
742 return;
743
744 switch (type)
745 {
746 case tcc_declaration: /* A decl node */
747 kind = d_kind;
748 break;
749
750 case tcc_type: /* a type node */
751 kind = t_kind;
752 break;
753
754 case tcc_statement: /* an expression with side effects */
755 kind = s_kind;
756 break;
757
758 case tcc_reference: /* a reference */
759 kind = r_kind;
760 break;
761
762 case tcc_expression: /* an expression */
763 case tcc_comparison: /* a comparison expression */
764 case tcc_unary: /* a unary arithmetic expression */
765 case tcc_binary: /* a binary arithmetic expression */
766 kind = e_kind;
767 break;
768
769 case tcc_constant: /* a constant */
770 kind = c_kind;
771 break;
772
773 case tcc_exceptional: /* something random, like an identifier. */
774 switch (code)
775 {
776 case IDENTIFIER_NODE:
777 kind = id_kind;
778 break;
779
780 case TREE_VEC:
781 kind = vec_kind;
782 break;
783
784 case TREE_BINFO:
785 kind = binfo_kind;
786 break;
787
788 case SSA_NAME:
789 kind = ssa_name_kind;
790 break;
791
792 case BLOCK:
793 kind = b_kind;
794 break;
795
796 case CONSTRUCTOR:
797 kind = constr_kind;
798 break;
799
800 case OMP_CLAUSE:
801 kind = omp_clause_kind;
802 break;
803
804 default:
805 kind = x_kind;
806 break;
807 }
808 break;
809
810 case tcc_vl_exp:
811 kind = e_kind;
812 break;
813
814 default:
815 gcc_unreachable ();
816 }
817
818 tree_code_counts[(int) code]++;
819 tree_node_counts[(int) kind]++;
820 tree_node_sizes[(int) kind] += length;
821 }
822
823 /* Allocate and return a new UID from the DECL_UID namespace. */
824
825 int
allocate_decl_uid(void)826 allocate_decl_uid (void)
827 {
828 return next_decl_uid++;
829 }
830
831 /* Return a newly allocated node of code CODE. For decl and type
832 nodes, some other fields are initialized. The rest of the node is
833 initialized to zero. This function cannot be used for TREE_VEC or
834 OMP_CLAUSE nodes, which is enforced by asserts in tree_code_size.
835
836 Achoo! I got a code in the node. */
837
838 tree
make_node_stat(enum tree_code code MEM_STAT_DECL)839 make_node_stat (enum tree_code code MEM_STAT_DECL)
840 {
841 tree t;
842 enum tree_code_class type = TREE_CODE_CLASS (code);
843 size_t length = tree_code_size (code);
844
845 record_node_allocation_statistics (code, length);
846
847 t = ggc_alloc_cleared_tree_node_stat (length PASS_MEM_STAT);
848 TREE_SET_CODE (t, code);
849
850 switch (type)
851 {
852 case tcc_statement:
853 TREE_SIDE_EFFECTS (t) = 1;
854 break;
855
856 case tcc_declaration:
857 if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
858 {
859 if (code == FUNCTION_DECL)
860 {
861 DECL_ALIGN (t) = FUNCTION_BOUNDARY;
862 DECL_MODE (t) = FUNCTION_MODE;
863 }
864 else
865 DECL_ALIGN (t) = 1;
866 }
867 DECL_SOURCE_LOCATION (t) = input_location;
868 if (TREE_CODE (t) == DEBUG_EXPR_DECL)
869 DECL_UID (t) = --next_debug_decl_uid;
870 else
871 {
872 DECL_UID (t) = allocate_decl_uid ();
873 SET_DECL_PT_UID (t, -1);
874 }
875 if (TREE_CODE (t) == LABEL_DECL)
876 LABEL_DECL_UID (t) = -1;
877
878 break;
879
880 case tcc_type:
881 TYPE_UID (t) = next_type_uid++;
882 TYPE_ALIGN (t) = BITS_PER_UNIT;
883 TYPE_USER_ALIGN (t) = 0;
884 TYPE_MAIN_VARIANT (t) = t;
885 TYPE_CANONICAL (t) = t;
886
887 /* Default to no attributes for type, but let target change that. */
888 TYPE_ATTRIBUTES (t) = NULL_TREE;
889 targetm.set_default_type_attributes (t);
890
891 /* We have not yet computed the alias set for this type. */
892 TYPE_ALIAS_SET (t) = -1;
893 break;
894
895 case tcc_constant:
896 TREE_CONSTANT (t) = 1;
897 break;
898
899 case tcc_expression:
900 switch (code)
901 {
902 case INIT_EXPR:
903 case MODIFY_EXPR:
904 case VA_ARG_EXPR:
905 case PREDECREMENT_EXPR:
906 case PREINCREMENT_EXPR:
907 case POSTDECREMENT_EXPR:
908 case POSTINCREMENT_EXPR:
909 /* All of these have side-effects, no matter what their
910 operands are. */
911 TREE_SIDE_EFFECTS (t) = 1;
912 break;
913
914 default:
915 break;
916 }
917 break;
918
919 default:
920 /* Other classes need no special treatment. */
921 break;
922 }
923
924 return t;
925 }
926
927 /* Return a new node with the same contents as NODE except that its
928 TREE_CHAIN, if it has one, is zero and it has a fresh uid. */
929
930 tree
copy_node_stat(tree node MEM_STAT_DECL)931 copy_node_stat (tree node MEM_STAT_DECL)
932 {
933 tree t;
934 enum tree_code code = TREE_CODE (node);
935 size_t length;
936
937 gcc_assert (code != STATEMENT_LIST);
938
939 length = tree_size (node);
940 record_node_allocation_statistics (code, length);
941 t = ggc_alloc_tree_node_stat (length PASS_MEM_STAT);
942 memcpy (t, node, length);
943
944 if (CODE_CONTAINS_STRUCT (code, TS_COMMON))
945 TREE_CHAIN (t) = 0;
946 TREE_ASM_WRITTEN (t) = 0;
947 TREE_VISITED (t) = 0;
948
949 if (TREE_CODE_CLASS (code) == tcc_declaration)
950 {
951 if (code == DEBUG_EXPR_DECL)
952 DECL_UID (t) = --next_debug_decl_uid;
953 else
954 {
955 DECL_UID (t) = allocate_decl_uid ();
956 if (DECL_PT_UID_SET_P (node))
957 SET_DECL_PT_UID (t, DECL_PT_UID (node));
958 }
959 if ((TREE_CODE (node) == PARM_DECL || TREE_CODE (node) == VAR_DECL)
960 && DECL_HAS_VALUE_EXPR_P (node))
961 {
962 SET_DECL_VALUE_EXPR (t, DECL_VALUE_EXPR (node));
963 DECL_HAS_VALUE_EXPR_P (t) = 1;
964 }
965 /* DECL_DEBUG_EXPR is copied explicitely by callers. */
966 if (TREE_CODE (node) == VAR_DECL)
967 DECL_HAS_DEBUG_EXPR_P (t) = 0;
968 if (TREE_CODE (node) == VAR_DECL && DECL_HAS_INIT_PRIORITY_P (node))
969 {
970 SET_DECL_INIT_PRIORITY (t, DECL_INIT_PRIORITY (node));
971 DECL_HAS_INIT_PRIORITY_P (t) = 1;
972 }
973 if (TREE_CODE (node) == FUNCTION_DECL)
974 DECL_STRUCT_FUNCTION (t) = NULL;
975 }
976 else if (TREE_CODE_CLASS (code) == tcc_type)
977 {
978 TYPE_UID (t) = next_type_uid++;
979 /* The following is so that the debug code for
980 the copy is different from the original type.
981 The two statements usually duplicate each other
982 (because they clear fields of the same union),
983 but the optimizer should catch that. */
984 TYPE_SYMTAB_POINTER (t) = 0;
985 TYPE_SYMTAB_ADDRESS (t) = 0;
986
987 /* Do not copy the values cache. */
988 if (TYPE_CACHED_VALUES_P (t))
989 {
990 TYPE_CACHED_VALUES_P (t) = 0;
991 TYPE_CACHED_VALUES (t) = NULL_TREE;
992 }
993 }
994
995 return t;
996 }
997
998 /* Return a copy of a chain of nodes, chained through the TREE_CHAIN field.
999 For example, this can copy a list made of TREE_LIST nodes. */
1000
1001 tree
copy_list(tree list)1002 copy_list (tree list)
1003 {
1004 tree head;
1005 tree prev, next;
1006
1007 if (list == 0)
1008 return 0;
1009
1010 head = prev = copy_node (list);
1011 next = TREE_CHAIN (list);
1012 while (next)
1013 {
1014 TREE_CHAIN (prev) = copy_node (next);
1015 prev = TREE_CHAIN (prev);
1016 next = TREE_CHAIN (next);
1017 }
1018 return head;
1019 }
1020
1021
1022 /* Create an INT_CST node with a LOW value sign extended to TYPE. */
1023
1024 tree
build_int_cst(tree type,HOST_WIDE_INT low)1025 build_int_cst (tree type, HOST_WIDE_INT low)
1026 {
1027 /* Support legacy code. */
1028 if (!type)
1029 type = integer_type_node;
1030
1031 return double_int_to_tree (type, double_int::from_shwi (low));
1032 }
1033
1034 /* Create an INT_CST node with a LOW value sign extended to TYPE. */
1035
1036 tree
build_int_cst_type(tree type,HOST_WIDE_INT low)1037 build_int_cst_type (tree type, HOST_WIDE_INT low)
1038 {
1039 gcc_assert (type);
1040
1041 return double_int_to_tree (type, double_int::from_shwi (low));
1042 }
1043
1044 /* Constructs tree in type TYPE from with value given by CST. Signedness
1045 of CST is assumed to be the same as the signedness of TYPE. */
1046
1047 tree
double_int_to_tree(tree type,double_int cst)1048 double_int_to_tree (tree type, double_int cst)
1049 {
1050 bool sign_extended_type = !TYPE_UNSIGNED (type);
1051
1052 cst = cst.ext (TYPE_PRECISION (type), !sign_extended_type);
1053
1054 return build_int_cst_wide (type, cst.low, cst.high);
1055 }
1056
1057 /* Returns true if CST fits into range of TYPE. Signedness of CST is assumed
1058 to be the same as the signedness of TYPE. */
1059
1060 bool
double_int_fits_to_tree_p(const_tree type,double_int cst)1061 double_int_fits_to_tree_p (const_tree type, double_int cst)
1062 {
1063 bool sign_extended_type = !TYPE_UNSIGNED (type);
1064
1065 double_int ext
1066 = cst.ext (TYPE_PRECISION (type), !sign_extended_type);
1067
1068 return cst == ext;
1069 }
1070
1071 /* We force the double_int CST to the range of the type TYPE by sign or
1072 zero extending it. OVERFLOWABLE indicates if we are interested in
1073 overflow of the value, when >0 we are only interested in signed
1074 overflow, for <0 we are interested in any overflow. OVERFLOWED
1075 indicates whether overflow has already occurred. CONST_OVERFLOWED
1076 indicates whether constant overflow has already occurred. We force
1077 T's value to be within range of T's type (by setting to 0 or 1 all
1078 the bits outside the type's range). We set TREE_OVERFLOWED if,
1079 OVERFLOWED is nonzero,
1080 or OVERFLOWABLE is >0 and signed overflow occurs
1081 or OVERFLOWABLE is <0 and any overflow occurs
1082 We return a new tree node for the extended double_int. The node
1083 is shared if no overflow flags are set. */
1084
1085
1086 tree
force_fit_type_double(tree type,double_int cst,int overflowable,bool overflowed)1087 force_fit_type_double (tree type, double_int cst, int overflowable,
1088 bool overflowed)
1089 {
1090 bool sign_extended_type = !TYPE_UNSIGNED (type);
1091
1092 /* If we need to set overflow flags, return a new unshared node. */
1093 if (overflowed || !double_int_fits_to_tree_p (type, cst))
1094 {
1095 if (overflowed
1096 || overflowable < 0
1097 || (overflowable > 0 && sign_extended_type))
1098 {
1099 tree t = make_node (INTEGER_CST);
1100 TREE_INT_CST (t)
1101 = cst.ext (TYPE_PRECISION (type), !sign_extended_type);
1102 TREE_TYPE (t) = type;
1103 TREE_OVERFLOW (t) = 1;
1104 return t;
1105 }
1106 }
1107
1108 /* Else build a shared node. */
1109 return double_int_to_tree (type, cst);
1110 }
1111
1112 /* These are the hash table functions for the hash table of INTEGER_CST
1113 nodes of a sizetype. */
1114
1115 /* Return the hash code code X, an INTEGER_CST. */
1116
1117 static hashval_t
int_cst_hash_hash(const void * x)1118 int_cst_hash_hash (const void *x)
1119 {
1120 const_tree const t = (const_tree) x;
1121
1122 return (TREE_INT_CST_HIGH (t) ^ TREE_INT_CST_LOW (t)
1123 ^ htab_hash_pointer (TREE_TYPE (t)));
1124 }
1125
1126 /* Return nonzero if the value represented by *X (an INTEGER_CST tree node)
1127 is the same as that given by *Y, which is the same. */
1128
1129 static int
int_cst_hash_eq(const void * x,const void * y)1130 int_cst_hash_eq (const void *x, const void *y)
1131 {
1132 const_tree const xt = (const_tree) x;
1133 const_tree const yt = (const_tree) y;
1134
1135 return (TREE_TYPE (xt) == TREE_TYPE (yt)
1136 && TREE_INT_CST_HIGH (xt) == TREE_INT_CST_HIGH (yt)
1137 && TREE_INT_CST_LOW (xt) == TREE_INT_CST_LOW (yt));
1138 }
1139
1140 /* Create an INT_CST node of TYPE and value HI:LOW.
1141 The returned node is always shared. For small integers we use a
1142 per-type vector cache, for larger ones we use a single hash table. */
1143
1144 tree
build_int_cst_wide(tree type,unsigned HOST_WIDE_INT low,HOST_WIDE_INT hi)1145 build_int_cst_wide (tree type, unsigned HOST_WIDE_INT low, HOST_WIDE_INT hi)
1146 {
1147 tree t;
1148 int ix = -1;
1149 int limit = 0;
1150
1151 gcc_assert (type);
1152
1153 switch (TREE_CODE (type))
1154 {
1155 case NULLPTR_TYPE:
1156 gcc_assert (hi == 0 && low == 0);
1157 /* Fallthru. */
1158
1159 case POINTER_TYPE:
1160 case REFERENCE_TYPE:
1161 /* Cache NULL pointer. */
1162 if (!hi && !low)
1163 {
1164 limit = 1;
1165 ix = 0;
1166 }
1167 break;
1168
1169 case BOOLEAN_TYPE:
1170 /* Cache false or true. */
1171 limit = 2;
1172 if (!hi && low < 2)
1173 ix = low;
1174 break;
1175
1176 case INTEGER_TYPE:
1177 case OFFSET_TYPE:
1178 if (TYPE_UNSIGNED (type))
1179 {
1180 /* Cache 0..N */
1181 limit = INTEGER_SHARE_LIMIT;
1182 if (!hi && low < (unsigned HOST_WIDE_INT)INTEGER_SHARE_LIMIT)
1183 ix = low;
1184 }
1185 else
1186 {
1187 /* Cache -1..N */
1188 limit = INTEGER_SHARE_LIMIT + 1;
1189 if (!hi && low < (unsigned HOST_WIDE_INT)INTEGER_SHARE_LIMIT)
1190 ix = low + 1;
1191 else if (hi == -1 && low == -(unsigned HOST_WIDE_INT)1)
1192 ix = 0;
1193 }
1194 break;
1195
1196 case ENUMERAL_TYPE:
1197 break;
1198
1199 default:
1200 gcc_unreachable ();
1201 }
1202
1203 if (ix >= 0)
1204 {
1205 /* Look for it in the type's vector of small shared ints. */
1206 if (!TYPE_CACHED_VALUES_P (type))
1207 {
1208 TYPE_CACHED_VALUES_P (type) = 1;
1209 TYPE_CACHED_VALUES (type) = make_tree_vec (limit);
1210 }
1211
1212 t = TREE_VEC_ELT (TYPE_CACHED_VALUES (type), ix);
1213 if (t)
1214 {
1215 /* Make sure no one is clobbering the shared constant. */
1216 gcc_assert (TREE_TYPE (t) == type);
1217 gcc_assert (TREE_INT_CST_LOW (t) == low);
1218 gcc_assert (TREE_INT_CST_HIGH (t) == hi);
1219 }
1220 else
1221 {
1222 /* Create a new shared int. */
1223 t = make_node (INTEGER_CST);
1224
1225 TREE_INT_CST_LOW (t) = low;
1226 TREE_INT_CST_HIGH (t) = hi;
1227 TREE_TYPE (t) = type;
1228
1229 TREE_VEC_ELT (TYPE_CACHED_VALUES (type), ix) = t;
1230 }
1231 }
1232 else
1233 {
1234 /* Use the cache of larger shared ints. */
1235 void **slot;
1236
1237 TREE_INT_CST_LOW (int_cst_node) = low;
1238 TREE_INT_CST_HIGH (int_cst_node) = hi;
1239 TREE_TYPE (int_cst_node) = type;
1240
1241 slot = htab_find_slot (int_cst_hash_table, int_cst_node, INSERT);
1242 t = (tree) *slot;
1243 if (!t)
1244 {
1245 /* Insert this one into the hash table. */
1246 t = int_cst_node;
1247 *slot = t;
1248 /* Make a new node for next time round. */
1249 int_cst_node = make_node (INTEGER_CST);
1250 }
1251 }
1252
1253 return t;
1254 }
1255
1256 void
cache_integer_cst(tree t)1257 cache_integer_cst (tree t)
1258 {
1259 tree type = TREE_TYPE (t);
1260 HOST_WIDE_INT hi = TREE_INT_CST_HIGH (t);
1261 unsigned HOST_WIDE_INT low = TREE_INT_CST_LOW (t);
1262 int ix = -1;
1263 int limit = 0;
1264
1265 gcc_assert (!TREE_OVERFLOW (t));
1266
1267 switch (TREE_CODE (type))
1268 {
1269 case NULLPTR_TYPE:
1270 gcc_assert (hi == 0 && low == 0);
1271 /* Fallthru. */
1272
1273 case POINTER_TYPE:
1274 case REFERENCE_TYPE:
1275 /* Cache NULL pointer. */
1276 if (!hi && !low)
1277 {
1278 limit = 1;
1279 ix = 0;
1280 }
1281 break;
1282
1283 case BOOLEAN_TYPE:
1284 /* Cache false or true. */
1285 limit = 2;
1286 if (!hi && low < 2)
1287 ix = low;
1288 break;
1289
1290 case INTEGER_TYPE:
1291 case OFFSET_TYPE:
1292 if (TYPE_UNSIGNED (type))
1293 {
1294 /* Cache 0..N */
1295 limit = INTEGER_SHARE_LIMIT;
1296 if (!hi && low < (unsigned HOST_WIDE_INT)INTEGER_SHARE_LIMIT)
1297 ix = low;
1298 }
1299 else
1300 {
1301 /* Cache -1..N */
1302 limit = INTEGER_SHARE_LIMIT + 1;
1303 if (!hi && low < (unsigned HOST_WIDE_INT)INTEGER_SHARE_LIMIT)
1304 ix = low + 1;
1305 else if (hi == -1 && low == -(unsigned HOST_WIDE_INT)1)
1306 ix = 0;
1307 }
1308 break;
1309
1310 case ENUMERAL_TYPE:
1311 break;
1312
1313 default:
1314 gcc_unreachable ();
1315 }
1316
1317 if (ix >= 0)
1318 {
1319 /* Look for it in the type's vector of small shared ints. */
1320 if (!TYPE_CACHED_VALUES_P (type))
1321 {
1322 TYPE_CACHED_VALUES_P (type) = 1;
1323 TYPE_CACHED_VALUES (type) = make_tree_vec (limit);
1324 }
1325
1326 gcc_assert (TREE_VEC_ELT (TYPE_CACHED_VALUES (type), ix) == NULL_TREE);
1327 TREE_VEC_ELT (TYPE_CACHED_VALUES (type), ix) = t;
1328 }
1329 else
1330 {
1331 /* Use the cache of larger shared ints. */
1332 void **slot;
1333
1334 slot = htab_find_slot (int_cst_hash_table, t, INSERT);
1335 /* If there is already an entry for the number verify it's the
1336 same. */
1337 if (*slot)
1338 {
1339 gcc_assert (TREE_INT_CST_LOW ((tree)*slot) == low
1340 && TREE_INT_CST_HIGH ((tree)*slot) == hi);
1341 return;
1342 }
1343 /* Otherwise insert this one into the hash table. */
1344 *slot = t;
1345 }
1346 }
1347
1348
1349 /* Builds an integer constant in TYPE such that lowest BITS bits are ones
1350 and the rest are zeros. */
1351
1352 tree
build_low_bits_mask(tree type,unsigned bits)1353 build_low_bits_mask (tree type, unsigned bits)
1354 {
1355 double_int mask;
1356
1357 gcc_assert (bits <= TYPE_PRECISION (type));
1358
1359 if (bits == TYPE_PRECISION (type)
1360 && !TYPE_UNSIGNED (type))
1361 /* Sign extended all-ones mask. */
1362 mask = double_int_minus_one;
1363 else
1364 mask = double_int::mask (bits);
1365
1366 return build_int_cst_wide (type, mask.low, mask.high);
1367 }
1368
1369 /* Checks that X is integer constant that can be expressed in (unsigned)
1370 HOST_WIDE_INT without loss of precision. */
1371
1372 bool
cst_and_fits_in_hwi(const_tree x)1373 cst_and_fits_in_hwi (const_tree x)
1374 {
1375 if (TREE_CODE (x) != INTEGER_CST)
1376 return false;
1377
1378 if (TYPE_PRECISION (TREE_TYPE (x)) > HOST_BITS_PER_WIDE_INT)
1379 return false;
1380
1381 return (TREE_INT_CST_HIGH (x) == 0
1382 || TREE_INT_CST_HIGH (x) == -1);
1383 }
1384
1385 /* Build a newly constructed TREE_VEC node of length LEN. */
1386
1387 tree
make_vector_stat(unsigned len MEM_STAT_DECL)1388 make_vector_stat (unsigned len MEM_STAT_DECL)
1389 {
1390 tree t;
1391 unsigned length = (len - 1) * sizeof (tree) + sizeof (struct tree_vector);
1392
1393 record_node_allocation_statistics (VECTOR_CST, length);
1394
1395 t = ggc_alloc_cleared_tree_node_stat (length PASS_MEM_STAT);
1396
1397 TREE_SET_CODE (t, VECTOR_CST);
1398 TREE_CONSTANT (t) = 1;
1399
1400 return t;
1401 }
1402
1403 /* Return a new VECTOR_CST node whose type is TYPE and whose values
1404 are in a list pointed to by VALS. */
1405
1406 tree
build_vector_stat(tree type,tree * vals MEM_STAT_DECL)1407 build_vector_stat (tree type, tree *vals MEM_STAT_DECL)
1408 {
1409 int over = 0;
1410 unsigned cnt = 0;
1411 tree v = make_vector (TYPE_VECTOR_SUBPARTS (type));
1412 TREE_TYPE (v) = type;
1413
1414 /* Iterate through elements and check for overflow. */
1415 for (cnt = 0; cnt < TYPE_VECTOR_SUBPARTS (type); ++cnt)
1416 {
1417 tree value = vals[cnt];
1418
1419 VECTOR_CST_ELT (v, cnt) = value;
1420
1421 /* Don't crash if we get an address constant. */
1422 if (!CONSTANT_CLASS_P (value))
1423 continue;
1424
1425 over |= TREE_OVERFLOW (value);
1426 }
1427
1428 TREE_OVERFLOW (v) = over;
1429 return v;
1430 }
1431
1432 /* Return a new VECTOR_CST node whose type is TYPE and whose values
1433 are extracted from V, a vector of CONSTRUCTOR_ELT. */
1434
1435 tree
build_vector_from_ctor(tree type,vec<constructor_elt,va_gc> * v)1436 build_vector_from_ctor (tree type, vec<constructor_elt, va_gc> *v)
1437 {
1438 tree *vec = XALLOCAVEC (tree, TYPE_VECTOR_SUBPARTS (type));
1439 unsigned HOST_WIDE_INT idx;
1440 tree value;
1441
1442 FOR_EACH_CONSTRUCTOR_VALUE (v, idx, value)
1443 vec[idx] = value;
1444 for (; idx < TYPE_VECTOR_SUBPARTS (type); ++idx)
1445 vec[idx] = build_zero_cst (TREE_TYPE (type));
1446
1447 return build_vector (type, vec);
1448 }
1449
1450 /* Build a vector of type VECTYPE where all the elements are SCs. */
1451 tree
build_vector_from_val(tree vectype,tree sc)1452 build_vector_from_val (tree vectype, tree sc)
1453 {
1454 int i, nunits = TYPE_VECTOR_SUBPARTS (vectype);
1455
1456 if (sc == error_mark_node)
1457 return sc;
1458
1459 /* Verify that the vector type is suitable for SC. Note that there
1460 is some inconsistency in the type-system with respect to restrict
1461 qualifications of pointers. Vector types always have a main-variant
1462 element type and the qualification is applied to the vector-type.
1463 So TREE_TYPE (vector-type) does not return a properly qualified
1464 vector element-type. */
1465 gcc_checking_assert (types_compatible_p (TYPE_MAIN_VARIANT (TREE_TYPE (sc)),
1466 TREE_TYPE (vectype)));
1467
1468 if (CONSTANT_CLASS_P (sc))
1469 {
1470 tree *v = XALLOCAVEC (tree, nunits);
1471 for (i = 0; i < nunits; ++i)
1472 v[i] = sc;
1473 return build_vector (vectype, v);
1474 }
1475 else
1476 {
1477 vec<constructor_elt, va_gc> *v;
1478 vec_alloc (v, nunits);
1479 for (i = 0; i < nunits; ++i)
1480 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, sc);
1481 return build_constructor (vectype, v);
1482 }
1483 }
1484
1485 /* Return a new CONSTRUCTOR node whose type is TYPE and whose values
1486 are in the vec pointed to by VALS. */
1487 tree
build_constructor(tree type,vec<constructor_elt,va_gc> * vals)1488 build_constructor (tree type, vec<constructor_elt, va_gc> *vals)
1489 {
1490 tree c = make_node (CONSTRUCTOR);
1491 unsigned int i;
1492 constructor_elt *elt;
1493 bool constant_p = true;
1494 bool side_effects_p = false;
1495
1496 TREE_TYPE (c) = type;
1497 CONSTRUCTOR_ELTS (c) = vals;
1498
1499 FOR_EACH_VEC_SAFE_ELT (vals, i, elt)
1500 {
1501 /* Mostly ctors will have elts that don't have side-effects, so
1502 the usual case is to scan all the elements. Hence a single
1503 loop for both const and side effects, rather than one loop
1504 each (with early outs). */
1505 if (!TREE_CONSTANT (elt->value))
1506 constant_p = false;
1507 if (TREE_SIDE_EFFECTS (elt->value))
1508 side_effects_p = true;
1509 }
1510
1511 TREE_SIDE_EFFECTS (c) = side_effects_p;
1512 TREE_CONSTANT (c) = constant_p;
1513
1514 return c;
1515 }
1516
1517 /* Build a CONSTRUCTOR node made of a single initializer, with the specified
1518 INDEX and VALUE. */
1519 tree
build_constructor_single(tree type,tree index,tree value)1520 build_constructor_single (tree type, tree index, tree value)
1521 {
1522 vec<constructor_elt, va_gc> *v;
1523 constructor_elt elt = {index, value};
1524
1525 vec_alloc (v, 1);
1526 v->quick_push (elt);
1527
1528 return build_constructor (type, v);
1529 }
1530
1531
1532 /* Return a new CONSTRUCTOR node whose type is TYPE and whose values
1533 are in a list pointed to by VALS. */
1534 tree
build_constructor_from_list(tree type,tree vals)1535 build_constructor_from_list (tree type, tree vals)
1536 {
1537 tree t;
1538 vec<constructor_elt, va_gc> *v = NULL;
1539
1540 if (vals)
1541 {
1542 vec_alloc (v, list_length (vals));
1543 for (t = vals; t; t = TREE_CHAIN (t))
1544 CONSTRUCTOR_APPEND_ELT (v, TREE_PURPOSE (t), TREE_VALUE (t));
1545 }
1546
1547 return build_constructor (type, v);
1548 }
1549
1550 /* Return a new CONSTRUCTOR node whose type is TYPE. NELTS is the number
1551 of elements, provided as index/value pairs. */
1552
1553 tree
build_constructor_va(tree type,int nelts,...)1554 build_constructor_va (tree type, int nelts, ...)
1555 {
1556 vec<constructor_elt, va_gc> *v = NULL;
1557 va_list p;
1558
1559 va_start (p, nelts);
1560 vec_alloc (v, nelts);
1561 while (nelts--)
1562 {
1563 tree index = va_arg (p, tree);
1564 tree value = va_arg (p, tree);
1565 CONSTRUCTOR_APPEND_ELT (v, index, value);
1566 }
1567 va_end (p);
1568 return build_constructor (type, v);
1569 }
1570
1571 /* Return a new FIXED_CST node whose type is TYPE and value is F. */
1572
1573 tree
build_fixed(tree type,FIXED_VALUE_TYPE f)1574 build_fixed (tree type, FIXED_VALUE_TYPE f)
1575 {
1576 tree v;
1577 FIXED_VALUE_TYPE *fp;
1578
1579 v = make_node (FIXED_CST);
1580 fp = ggc_alloc_fixed_value ();
1581 memcpy (fp, &f, sizeof (FIXED_VALUE_TYPE));
1582
1583 TREE_TYPE (v) = type;
1584 TREE_FIXED_CST_PTR (v) = fp;
1585 return v;
1586 }
1587
1588 /* Return a new REAL_CST node whose type is TYPE and value is D. */
1589
1590 tree
build_real(tree type,REAL_VALUE_TYPE d)1591 build_real (tree type, REAL_VALUE_TYPE d)
1592 {
1593 tree v;
1594 REAL_VALUE_TYPE *dp;
1595 int overflow = 0;
1596
1597 /* ??? Used to check for overflow here via CHECK_FLOAT_TYPE.
1598 Consider doing it via real_convert now. */
1599
1600 v = make_node (REAL_CST);
1601 dp = ggc_alloc_real_value ();
1602 memcpy (dp, &d, sizeof (REAL_VALUE_TYPE));
1603
1604 TREE_TYPE (v) = type;
1605 TREE_REAL_CST_PTR (v) = dp;
1606 TREE_OVERFLOW (v) = overflow;
1607 return v;
1608 }
1609
1610 /* Return a new REAL_CST node whose type is TYPE
1611 and whose value is the integer value of the INTEGER_CST node I. */
1612
1613 REAL_VALUE_TYPE
real_value_from_int_cst(const_tree type,const_tree i)1614 real_value_from_int_cst (const_tree type, const_tree i)
1615 {
1616 REAL_VALUE_TYPE d;
1617
1618 /* Clear all bits of the real value type so that we can later do
1619 bitwise comparisons to see if two values are the same. */
1620 memset (&d, 0, sizeof d);
1621
1622 real_from_integer (&d, type ? TYPE_MODE (type) : VOIDmode,
1623 TREE_INT_CST_LOW (i), TREE_INT_CST_HIGH (i),
1624 TYPE_UNSIGNED (TREE_TYPE (i)));
1625 return d;
1626 }
1627
1628 /* Given a tree representing an integer constant I, return a tree
1629 representing the same value as a floating-point constant of type TYPE. */
1630
1631 tree
build_real_from_int_cst(tree type,const_tree i)1632 build_real_from_int_cst (tree type, const_tree i)
1633 {
1634 tree v;
1635 int overflow = TREE_OVERFLOW (i);
1636
1637 v = build_real (type, real_value_from_int_cst (type, i));
1638
1639 TREE_OVERFLOW (v) |= overflow;
1640 return v;
1641 }
1642
1643 /* Return a newly constructed STRING_CST node whose value is
1644 the LEN characters at STR.
1645 Note that for a C string literal, LEN should include the trailing NUL.
1646 The TREE_TYPE is not initialized. */
1647
1648 tree
build_string(int len,const char * str)1649 build_string (int len, const char *str)
1650 {
1651 tree s;
1652 size_t length;
1653
1654 /* Do not waste bytes provided by padding of struct tree_string. */
1655 length = len + offsetof (struct tree_string, str) + 1;
1656
1657 record_node_allocation_statistics (STRING_CST, length);
1658
1659 s = ggc_alloc_tree_node (length);
1660
1661 memset (s, 0, sizeof (struct tree_typed));
1662 TREE_SET_CODE (s, STRING_CST);
1663 TREE_CONSTANT (s) = 1;
1664 TREE_STRING_LENGTH (s) = len;
1665 memcpy (s->string.str, str, len);
1666 s->string.str[len] = '\0';
1667
1668 return s;
1669 }
1670
1671 /* Return a newly constructed COMPLEX_CST node whose value is
1672 specified by the real and imaginary parts REAL and IMAG.
1673 Both REAL and IMAG should be constant nodes. TYPE, if specified,
1674 will be the type of the COMPLEX_CST; otherwise a new type will be made. */
1675
1676 tree
build_complex(tree type,tree real,tree imag)1677 build_complex (tree type, tree real, tree imag)
1678 {
1679 tree t = make_node (COMPLEX_CST);
1680
1681 TREE_REALPART (t) = real;
1682 TREE_IMAGPART (t) = imag;
1683 TREE_TYPE (t) = type ? type : build_complex_type (TREE_TYPE (real));
1684 TREE_OVERFLOW (t) = TREE_OVERFLOW (real) | TREE_OVERFLOW (imag);
1685 return t;
1686 }
1687
1688 /* Return a constant of arithmetic type TYPE which is the
1689 multiplicative identity of the set TYPE. */
1690
1691 tree
build_one_cst(tree type)1692 build_one_cst (tree type)
1693 {
1694 switch (TREE_CODE (type))
1695 {
1696 case INTEGER_TYPE: case ENUMERAL_TYPE: case BOOLEAN_TYPE:
1697 case POINTER_TYPE: case REFERENCE_TYPE:
1698 case OFFSET_TYPE:
1699 return build_int_cst (type, 1);
1700
1701 case REAL_TYPE:
1702 return build_real (type, dconst1);
1703
1704 case FIXED_POINT_TYPE:
1705 /* We can only generate 1 for accum types. */
1706 gcc_assert (ALL_SCALAR_ACCUM_MODE_P (TYPE_MODE (type)));
1707 return build_fixed (type, FCONST1 (TYPE_MODE (type)));
1708
1709 case VECTOR_TYPE:
1710 {
1711 tree scalar = build_one_cst (TREE_TYPE (type));
1712
1713 return build_vector_from_val (type, scalar);
1714 }
1715
1716 case COMPLEX_TYPE:
1717 return build_complex (type,
1718 build_one_cst (TREE_TYPE (type)),
1719 build_zero_cst (TREE_TYPE (type)));
1720
1721 default:
1722 gcc_unreachable ();
1723 }
1724 }
1725
1726 /* Return an integer of type TYPE containing all 1's in as much precision as
1727 it contains, or a complex or vector whose subparts are such integers. */
1728
1729 tree
build_all_ones_cst(tree type)1730 build_all_ones_cst (tree type)
1731 {
1732 if (TREE_CODE (type) == COMPLEX_TYPE)
1733 {
1734 tree scalar = build_all_ones_cst (TREE_TYPE (type));
1735 return build_complex (type, scalar, scalar);
1736 }
1737 else
1738 return build_minus_one_cst (type);
1739 }
1740
1741 /* Return a constant of arithmetic type TYPE which is the
1742 opposite of the multiplicative identity of the set TYPE. */
1743
1744 tree
build_minus_one_cst(tree type)1745 build_minus_one_cst (tree type)
1746 {
1747 switch (TREE_CODE (type))
1748 {
1749 case INTEGER_TYPE: case ENUMERAL_TYPE: case BOOLEAN_TYPE:
1750 case POINTER_TYPE: case REFERENCE_TYPE:
1751 case OFFSET_TYPE:
1752 return build_int_cst (type, -1);
1753
1754 case REAL_TYPE:
1755 return build_real (type, dconstm1);
1756
1757 case FIXED_POINT_TYPE:
1758 /* We can only generate 1 for accum types. */
1759 gcc_assert (ALL_SCALAR_ACCUM_MODE_P (TYPE_MODE (type)));
1760 return build_fixed (type, fixed_from_double_int (double_int_minus_one,
1761 TYPE_MODE (type)));
1762
1763 case VECTOR_TYPE:
1764 {
1765 tree scalar = build_minus_one_cst (TREE_TYPE (type));
1766
1767 return build_vector_from_val (type, scalar);
1768 }
1769
1770 case COMPLEX_TYPE:
1771 return build_complex (type,
1772 build_minus_one_cst (TREE_TYPE (type)),
1773 build_zero_cst (TREE_TYPE (type)));
1774
1775 default:
1776 gcc_unreachable ();
1777 }
1778 }
1779
1780 /* Build 0 constant of type TYPE. This is used by constructor folding
1781 and thus the constant should be represented in memory by
1782 zero(es). */
1783
1784 tree
build_zero_cst(tree type)1785 build_zero_cst (tree type)
1786 {
1787 switch (TREE_CODE (type))
1788 {
1789 case INTEGER_TYPE: case ENUMERAL_TYPE: case BOOLEAN_TYPE:
1790 case POINTER_TYPE: case REFERENCE_TYPE:
1791 case OFFSET_TYPE: case NULLPTR_TYPE:
1792 return build_int_cst (type, 0);
1793
1794 case REAL_TYPE:
1795 return build_real (type, dconst0);
1796
1797 case FIXED_POINT_TYPE:
1798 return build_fixed (type, FCONST0 (TYPE_MODE (type)));
1799
1800 case VECTOR_TYPE:
1801 {
1802 tree scalar = build_zero_cst (TREE_TYPE (type));
1803
1804 return build_vector_from_val (type, scalar);
1805 }
1806
1807 case COMPLEX_TYPE:
1808 {
1809 tree zero = build_zero_cst (TREE_TYPE (type));
1810
1811 return build_complex (type, zero, zero);
1812 }
1813
1814 default:
1815 if (!AGGREGATE_TYPE_P (type))
1816 return fold_convert (type, integer_zero_node);
1817 return build_constructor (type, NULL);
1818 }
1819 }
1820
1821
1822 /* Build a BINFO with LEN language slots. */
1823
1824 tree
make_tree_binfo_stat(unsigned base_binfos MEM_STAT_DECL)1825 make_tree_binfo_stat (unsigned base_binfos MEM_STAT_DECL)
1826 {
1827 tree t;
1828 size_t length = (offsetof (struct tree_binfo, base_binfos)
1829 + vec<tree, va_gc>::embedded_size (base_binfos));
1830
1831 record_node_allocation_statistics (TREE_BINFO, length);
1832
1833 t = ggc_alloc_tree_node_stat (length PASS_MEM_STAT);
1834
1835 memset (t, 0, offsetof (struct tree_binfo, base_binfos));
1836
1837 TREE_SET_CODE (t, TREE_BINFO);
1838
1839 BINFO_BASE_BINFOS (t)->embedded_init (base_binfos);
1840
1841 return t;
1842 }
1843
1844 /* Create a CASE_LABEL_EXPR tree node and return it. */
1845
1846 tree
build_case_label(tree low_value,tree high_value,tree label_decl)1847 build_case_label (tree low_value, tree high_value, tree label_decl)
1848 {
1849 tree t = make_node (CASE_LABEL_EXPR);
1850
1851 TREE_TYPE (t) = void_type_node;
1852 SET_EXPR_LOCATION (t, DECL_SOURCE_LOCATION (label_decl));
1853
1854 CASE_LOW (t) = low_value;
1855 CASE_HIGH (t) = high_value;
1856 CASE_LABEL (t) = label_decl;
1857 CASE_CHAIN (t) = NULL_TREE;
1858
1859 return t;
1860 }
1861
1862 /* Build a newly constructed TREE_VEC node of length LEN. */
1863
1864 tree
make_tree_vec_stat(int len MEM_STAT_DECL)1865 make_tree_vec_stat (int len MEM_STAT_DECL)
1866 {
1867 tree t;
1868 int length = (len - 1) * sizeof (tree) + sizeof (struct tree_vec);
1869
1870 record_node_allocation_statistics (TREE_VEC, length);
1871
1872 t = ggc_alloc_cleared_tree_node_stat (length PASS_MEM_STAT);
1873
1874 TREE_SET_CODE (t, TREE_VEC);
1875 TREE_VEC_LENGTH (t) = len;
1876
1877 return t;
1878 }
1879
1880 /* Grow a TREE_VEC node to new length LEN. */
1881
1882 tree
grow_tree_vec_stat(tree v,int len MEM_STAT_DECL)1883 grow_tree_vec_stat (tree v, int len MEM_STAT_DECL)
1884 {
1885 gcc_assert (TREE_CODE (v) == TREE_VEC);
1886
1887 int oldlen = TREE_VEC_LENGTH (v);
1888 gcc_assert (len > oldlen);
1889
1890 int oldlength = (oldlen - 1) * sizeof (tree) + sizeof (struct tree_vec);
1891 int length = (len - 1) * sizeof (tree) + sizeof (struct tree_vec);
1892
1893 record_node_allocation_statistics (TREE_VEC, length - oldlength);
1894
1895 v = (tree) ggc_realloc_stat (v, length PASS_MEM_STAT);
1896
1897 TREE_VEC_LENGTH (v) = len;
1898
1899 return v;
1900 }
1901
1902 /* Return 1 if EXPR is the integer constant zero or a complex constant
1903 of zero. */
1904
1905 int
integer_zerop(const_tree expr)1906 integer_zerop (const_tree expr)
1907 {
1908 STRIP_NOPS (expr);
1909
1910 switch (TREE_CODE (expr))
1911 {
1912 case INTEGER_CST:
1913 return (TREE_INT_CST_LOW (expr) == 0
1914 && TREE_INT_CST_HIGH (expr) == 0);
1915 case COMPLEX_CST:
1916 return (integer_zerop (TREE_REALPART (expr))
1917 && integer_zerop (TREE_IMAGPART (expr)));
1918 case VECTOR_CST:
1919 {
1920 unsigned i;
1921 for (i = 0; i < VECTOR_CST_NELTS (expr); ++i)
1922 if (!integer_zerop (VECTOR_CST_ELT (expr, i)))
1923 return false;
1924 return true;
1925 }
1926 default:
1927 return false;
1928 }
1929 }
1930
1931 /* Return 1 if EXPR is the integer constant one or the corresponding
1932 complex constant. */
1933
1934 int
integer_onep(const_tree expr)1935 integer_onep (const_tree expr)
1936 {
1937 STRIP_NOPS (expr);
1938
1939 switch (TREE_CODE (expr))
1940 {
1941 case INTEGER_CST:
1942 return (TREE_INT_CST_LOW (expr) == 1
1943 && TREE_INT_CST_HIGH (expr) == 0);
1944 case COMPLEX_CST:
1945 return (integer_onep (TREE_REALPART (expr))
1946 && integer_zerop (TREE_IMAGPART (expr)));
1947 case VECTOR_CST:
1948 {
1949 unsigned i;
1950 for (i = 0; i < VECTOR_CST_NELTS (expr); ++i)
1951 if (!integer_onep (VECTOR_CST_ELT (expr, i)))
1952 return false;
1953 return true;
1954 }
1955 default:
1956 return false;
1957 }
1958 }
1959
1960 /* Return 1 if EXPR is an integer containing all 1's in as much precision as
1961 it contains, or a complex or vector whose subparts are such integers. */
1962
1963 int
integer_all_onesp(const_tree expr)1964 integer_all_onesp (const_tree expr)
1965 {
1966 int prec;
1967 int uns;
1968
1969 STRIP_NOPS (expr);
1970
1971 if (TREE_CODE (expr) == COMPLEX_CST
1972 && integer_all_onesp (TREE_REALPART (expr))
1973 && integer_all_onesp (TREE_IMAGPART (expr)))
1974 return 1;
1975
1976 else if (TREE_CODE (expr) == VECTOR_CST)
1977 {
1978 unsigned i;
1979 for (i = 0; i < VECTOR_CST_NELTS (expr); ++i)
1980 if (!integer_all_onesp (VECTOR_CST_ELT (expr, i)))
1981 return 0;
1982 return 1;
1983 }
1984
1985 else if (TREE_CODE (expr) != INTEGER_CST)
1986 return 0;
1987
1988 uns = TYPE_UNSIGNED (TREE_TYPE (expr));
1989 if (TREE_INT_CST_LOW (expr) == ~(unsigned HOST_WIDE_INT) 0
1990 && TREE_INT_CST_HIGH (expr) == -1)
1991 return 1;
1992 if (!uns)
1993 return 0;
1994
1995 prec = TYPE_PRECISION (TREE_TYPE (expr));
1996 if (prec >= HOST_BITS_PER_WIDE_INT)
1997 {
1998 HOST_WIDE_INT high_value;
1999 int shift_amount;
2000
2001 shift_amount = prec - HOST_BITS_PER_WIDE_INT;
2002
2003 /* Can not handle precisions greater than twice the host int size. */
2004 gcc_assert (shift_amount <= HOST_BITS_PER_WIDE_INT);
2005 if (shift_amount == HOST_BITS_PER_WIDE_INT)
2006 /* Shifting by the host word size is undefined according to the ANSI
2007 standard, so we must handle this as a special case. */
2008 high_value = -1;
2009 else
2010 high_value = ((HOST_WIDE_INT) 1 << shift_amount) - 1;
2011
2012 return (TREE_INT_CST_LOW (expr) == ~(unsigned HOST_WIDE_INT) 0
2013 && TREE_INT_CST_HIGH (expr) == high_value);
2014 }
2015 else
2016 return TREE_INT_CST_LOW (expr) == ((unsigned HOST_WIDE_INT) 1 << prec) - 1;
2017 }
2018
2019 /* Return 1 if EXPR is the integer constant minus one. */
2020
2021 int
integer_minus_onep(const_tree expr)2022 integer_minus_onep (const_tree expr)
2023 {
2024 STRIP_NOPS (expr);
2025
2026 if (TREE_CODE (expr) == COMPLEX_CST)
2027 return (integer_all_onesp (TREE_REALPART (expr))
2028 && integer_zerop (TREE_IMAGPART (expr)));
2029 else
2030 return integer_all_onesp (expr);
2031 }
2032
2033 /* Return 1 if EXPR is an integer constant that is a power of 2 (i.e., has only
2034 one bit on). */
2035
2036 int
integer_pow2p(const_tree expr)2037 integer_pow2p (const_tree expr)
2038 {
2039 int prec;
2040 unsigned HOST_WIDE_INT high, low;
2041
2042 STRIP_NOPS (expr);
2043
2044 if (TREE_CODE (expr) == COMPLEX_CST
2045 && integer_pow2p (TREE_REALPART (expr))
2046 && integer_zerop (TREE_IMAGPART (expr)))
2047 return 1;
2048
2049 if (TREE_CODE (expr) != INTEGER_CST)
2050 return 0;
2051
2052 prec = TYPE_PRECISION (TREE_TYPE (expr));
2053 high = TREE_INT_CST_HIGH (expr);
2054 low = TREE_INT_CST_LOW (expr);
2055
2056 /* First clear all bits that are beyond the type's precision in case
2057 we've been sign extended. */
2058
2059 if (prec == HOST_BITS_PER_DOUBLE_INT)
2060 ;
2061 else if (prec > HOST_BITS_PER_WIDE_INT)
2062 high &= ~(HOST_WIDE_INT_M1U << (prec - HOST_BITS_PER_WIDE_INT));
2063 else
2064 {
2065 high = 0;
2066 if (prec < HOST_BITS_PER_WIDE_INT)
2067 low &= ~(HOST_WIDE_INT_M1U << prec);
2068 }
2069
2070 if (high == 0 && low == 0)
2071 return 0;
2072
2073 return ((high == 0 && (low & (low - 1)) == 0)
2074 || (low == 0 && (high & (high - 1)) == 0));
2075 }
2076
2077 /* Return 1 if EXPR is an integer constant other than zero or a
2078 complex constant other than zero. */
2079
2080 int
integer_nonzerop(const_tree expr)2081 integer_nonzerop (const_tree expr)
2082 {
2083 STRIP_NOPS (expr);
2084
2085 return ((TREE_CODE (expr) == INTEGER_CST
2086 && (TREE_INT_CST_LOW (expr) != 0
2087 || TREE_INT_CST_HIGH (expr) != 0))
2088 || (TREE_CODE (expr) == COMPLEX_CST
2089 && (integer_nonzerop (TREE_REALPART (expr))
2090 || integer_nonzerop (TREE_IMAGPART (expr)))));
2091 }
2092
2093 /* Return 1 if EXPR is the fixed-point constant zero. */
2094
2095 int
fixed_zerop(const_tree expr)2096 fixed_zerop (const_tree expr)
2097 {
2098 return (TREE_CODE (expr) == FIXED_CST
2099 && TREE_FIXED_CST (expr).data.is_zero ());
2100 }
2101
2102 /* Return the power of two represented by a tree node known to be a
2103 power of two. */
2104
2105 int
tree_log2(const_tree expr)2106 tree_log2 (const_tree expr)
2107 {
2108 int prec;
2109 HOST_WIDE_INT high, low;
2110
2111 STRIP_NOPS (expr);
2112
2113 if (TREE_CODE (expr) == COMPLEX_CST)
2114 return tree_log2 (TREE_REALPART (expr));
2115
2116 prec = TYPE_PRECISION (TREE_TYPE (expr));
2117 high = TREE_INT_CST_HIGH (expr);
2118 low = TREE_INT_CST_LOW (expr);
2119
2120 /* First clear all bits that are beyond the type's precision in case
2121 we've been sign extended. */
2122
2123 if (prec == HOST_BITS_PER_DOUBLE_INT)
2124 ;
2125 else if (prec > HOST_BITS_PER_WIDE_INT)
2126 high &= ~(HOST_WIDE_INT_M1U << (prec - HOST_BITS_PER_WIDE_INT));
2127 else
2128 {
2129 high = 0;
2130 if (prec < HOST_BITS_PER_WIDE_INT)
2131 low &= ~(HOST_WIDE_INT_M1U << prec);
2132 }
2133
2134 return (high != 0 ? HOST_BITS_PER_WIDE_INT + exact_log2 (high)
2135 : exact_log2 (low));
2136 }
2137
2138 /* Similar, but return the largest integer Y such that 2 ** Y is less
2139 than or equal to EXPR. */
2140
2141 int
tree_floor_log2(const_tree expr)2142 tree_floor_log2 (const_tree expr)
2143 {
2144 int prec;
2145 HOST_WIDE_INT high, low;
2146
2147 STRIP_NOPS (expr);
2148
2149 if (TREE_CODE (expr) == COMPLEX_CST)
2150 return tree_log2 (TREE_REALPART (expr));
2151
2152 prec = TYPE_PRECISION (TREE_TYPE (expr));
2153 high = TREE_INT_CST_HIGH (expr);
2154 low = TREE_INT_CST_LOW (expr);
2155
2156 /* First clear all bits that are beyond the type's precision in case
2157 we've been sign extended. Ignore if type's precision hasn't been set
2158 since what we are doing is setting it. */
2159
2160 if (prec == HOST_BITS_PER_DOUBLE_INT || prec == 0)
2161 ;
2162 else if (prec > HOST_BITS_PER_WIDE_INT)
2163 high &= ~(HOST_WIDE_INT_M1U << (prec - HOST_BITS_PER_WIDE_INT));
2164 else
2165 {
2166 high = 0;
2167 if (prec < HOST_BITS_PER_WIDE_INT)
2168 low &= ~(HOST_WIDE_INT_M1U << prec);
2169 }
2170
2171 return (high != 0 ? HOST_BITS_PER_WIDE_INT + floor_log2 (high)
2172 : floor_log2 (low));
2173 }
2174
2175 /* Return number of known trailing zero bits in EXPR, or, if the value of
2176 EXPR is known to be zero, the precision of it's type. */
2177
2178 unsigned int
tree_ctz(const_tree expr)2179 tree_ctz (const_tree expr)
2180 {
2181 if (!INTEGRAL_TYPE_P (TREE_TYPE (expr))
2182 && !POINTER_TYPE_P (TREE_TYPE (expr)))
2183 return 0;
2184
2185 unsigned int ret1, ret2, prec = TYPE_PRECISION (TREE_TYPE (expr));
2186 switch (TREE_CODE (expr))
2187 {
2188 case INTEGER_CST:
2189 ret1 = tree_to_double_int (expr).trailing_zeros ();
2190 return MIN (ret1, prec);
2191 case SSA_NAME:
2192 ret1 = get_nonzero_bits (expr).trailing_zeros ();
2193 return MIN (ret1, prec);
2194 case PLUS_EXPR:
2195 case MINUS_EXPR:
2196 case BIT_IOR_EXPR:
2197 case BIT_XOR_EXPR:
2198 case MIN_EXPR:
2199 case MAX_EXPR:
2200 ret1 = tree_ctz (TREE_OPERAND (expr, 0));
2201 if (ret1 == 0)
2202 return ret1;
2203 ret2 = tree_ctz (TREE_OPERAND (expr, 1));
2204 return MIN (ret1, ret2);
2205 case POINTER_PLUS_EXPR:
2206 ret1 = tree_ctz (TREE_OPERAND (expr, 0));
2207 ret2 = tree_ctz (TREE_OPERAND (expr, 1));
2208 /* Second operand is sizetype, which could be in theory
2209 wider than pointer's precision. Make sure we never
2210 return more than prec. */
2211 ret2 = MIN (ret2, prec);
2212 return MIN (ret1, ret2);
2213 case BIT_AND_EXPR:
2214 ret1 = tree_ctz (TREE_OPERAND (expr, 0));
2215 ret2 = tree_ctz (TREE_OPERAND (expr, 1));
2216 return MAX (ret1, ret2);
2217 case MULT_EXPR:
2218 ret1 = tree_ctz (TREE_OPERAND (expr, 0));
2219 ret2 = tree_ctz (TREE_OPERAND (expr, 1));
2220 return MIN (ret1 + ret2, prec);
2221 case LSHIFT_EXPR:
2222 ret1 = tree_ctz (TREE_OPERAND (expr, 0));
2223 if (tree_fits_uhwi_p (TREE_OPERAND (expr, 1))
2224 && (tree_to_uhwi (TREE_OPERAND (expr, 1)) < prec))
2225 {
2226 ret2 = tree_to_uhwi (TREE_OPERAND (expr, 1));
2227 return MIN (ret1 + ret2, prec);
2228 }
2229 return ret1;
2230 case RSHIFT_EXPR:
2231 if (tree_fits_uhwi_p (TREE_OPERAND (expr, 1))
2232 && (tree_to_uhwi (TREE_OPERAND (expr, 1)) < prec))
2233 {
2234 ret1 = tree_ctz (TREE_OPERAND (expr, 0));
2235 ret2 = tree_to_uhwi (TREE_OPERAND (expr, 1));
2236 if (ret1 > ret2)
2237 return ret1 - ret2;
2238 }
2239 return 0;
2240 case TRUNC_DIV_EXPR:
2241 case CEIL_DIV_EXPR:
2242 case FLOOR_DIV_EXPR:
2243 case ROUND_DIV_EXPR:
2244 case EXACT_DIV_EXPR:
2245 if (TREE_CODE (TREE_OPERAND (expr, 1)) == INTEGER_CST
2246 && tree_int_cst_sgn (TREE_OPERAND (expr, 1)) == 1)
2247 {
2248 int l = tree_log2 (TREE_OPERAND (expr, 1));
2249 if (l >= 0)
2250 {
2251 ret1 = tree_ctz (TREE_OPERAND (expr, 0));
2252 ret2 = l;
2253 if (ret1 > ret2)
2254 return ret1 - ret2;
2255 }
2256 }
2257 return 0;
2258 CASE_CONVERT:
2259 ret1 = tree_ctz (TREE_OPERAND (expr, 0));
2260 if (ret1 && ret1 == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (expr, 0))))
2261 ret1 = prec;
2262 return MIN (ret1, prec);
2263 case SAVE_EXPR:
2264 return tree_ctz (TREE_OPERAND (expr, 0));
2265 case COND_EXPR:
2266 ret1 = tree_ctz (TREE_OPERAND (expr, 1));
2267 if (ret1 == 0)
2268 return 0;
2269 ret2 = tree_ctz (TREE_OPERAND (expr, 2));
2270 return MIN (ret1, ret2);
2271 case COMPOUND_EXPR:
2272 return tree_ctz (TREE_OPERAND (expr, 1));
2273 case ADDR_EXPR:
2274 ret1 = get_pointer_alignment (CONST_CAST_TREE (expr));
2275 if (ret1 > BITS_PER_UNIT)
2276 {
2277 ret1 = ctz_hwi (ret1 / BITS_PER_UNIT);
2278 return MIN (ret1, prec);
2279 }
2280 return 0;
2281 default:
2282 return 0;
2283 }
2284 }
2285
2286 /* Return 1 if EXPR is the real constant zero. Trailing zeroes matter for
2287 decimal float constants, so don't return 1 for them. */
2288
2289 int
real_zerop(const_tree expr)2290 real_zerop (const_tree expr)
2291 {
2292 STRIP_NOPS (expr);
2293
2294 switch (TREE_CODE (expr))
2295 {
2296 case REAL_CST:
2297 return REAL_VALUES_EQUAL (TREE_REAL_CST (expr), dconst0)
2298 && !(DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (expr))));
2299 case COMPLEX_CST:
2300 return real_zerop (TREE_REALPART (expr))
2301 && real_zerop (TREE_IMAGPART (expr));
2302 case VECTOR_CST:
2303 {
2304 unsigned i;
2305 for (i = 0; i < VECTOR_CST_NELTS (expr); ++i)
2306 if (!real_zerop (VECTOR_CST_ELT (expr, i)))
2307 return false;
2308 return true;
2309 }
2310 default:
2311 return false;
2312 }
2313 }
2314
2315 /* Return 1 if EXPR is the real constant one in real or complex form.
2316 Trailing zeroes matter for decimal float constants, so don't return
2317 1 for them. */
2318
2319 int
real_onep(const_tree expr)2320 real_onep (const_tree expr)
2321 {
2322 STRIP_NOPS (expr);
2323
2324 switch (TREE_CODE (expr))
2325 {
2326 case REAL_CST:
2327 return REAL_VALUES_EQUAL (TREE_REAL_CST (expr), dconst1)
2328 && !(DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (expr))));
2329 case COMPLEX_CST:
2330 return real_onep (TREE_REALPART (expr))
2331 && real_zerop (TREE_IMAGPART (expr));
2332 case VECTOR_CST:
2333 {
2334 unsigned i;
2335 for (i = 0; i < VECTOR_CST_NELTS (expr); ++i)
2336 if (!real_onep (VECTOR_CST_ELT (expr, i)))
2337 return false;
2338 return true;
2339 }
2340 default:
2341 return false;
2342 }
2343 }
2344
2345 /* Return 1 if EXPR is the real constant minus one. Trailing zeroes
2346 matter for decimal float constants, so don't return 1 for them. */
2347
2348 int
real_minus_onep(const_tree expr)2349 real_minus_onep (const_tree expr)
2350 {
2351 STRIP_NOPS (expr);
2352
2353 switch (TREE_CODE (expr))
2354 {
2355 case REAL_CST:
2356 return REAL_VALUES_EQUAL (TREE_REAL_CST (expr), dconstm1)
2357 && !(DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (expr))));
2358 case COMPLEX_CST:
2359 return real_minus_onep (TREE_REALPART (expr))
2360 && real_zerop (TREE_IMAGPART (expr));
2361 case VECTOR_CST:
2362 {
2363 unsigned i;
2364 for (i = 0; i < VECTOR_CST_NELTS (expr); ++i)
2365 if (!real_minus_onep (VECTOR_CST_ELT (expr, i)))
2366 return false;
2367 return true;
2368 }
2369 default:
2370 return false;
2371 }
2372 }
2373
2374 /* Nonzero if EXP is a constant or a cast of a constant. */
2375
2376 int
really_constant_p(const_tree exp)2377 really_constant_p (const_tree exp)
2378 {
2379 /* This is not quite the same as STRIP_NOPS. It does more. */
2380 while (CONVERT_EXPR_P (exp)
2381 || TREE_CODE (exp) == NON_LVALUE_EXPR)
2382 exp = TREE_OPERAND (exp, 0);
2383 return TREE_CONSTANT (exp);
2384 }
2385
2386 /* Return first list element whose TREE_VALUE is ELEM.
2387 Return 0 if ELEM is not in LIST. */
2388
2389 tree
value_member(tree elem,tree list)2390 value_member (tree elem, tree list)
2391 {
2392 while (list)
2393 {
2394 if (elem == TREE_VALUE (list))
2395 return list;
2396 list = TREE_CHAIN (list);
2397 }
2398 return NULL_TREE;
2399 }
2400
2401 /* Return first list element whose TREE_PURPOSE is ELEM.
2402 Return 0 if ELEM is not in LIST. */
2403
2404 tree
purpose_member(const_tree elem,tree list)2405 purpose_member (const_tree elem, tree list)
2406 {
2407 while (list)
2408 {
2409 if (elem == TREE_PURPOSE (list))
2410 return list;
2411 list = TREE_CHAIN (list);
2412 }
2413 return NULL_TREE;
2414 }
2415
2416 /* Return true if ELEM is in V. */
2417
2418 bool
vec_member(const_tree elem,vec<tree,va_gc> * v)2419 vec_member (const_tree elem, vec<tree, va_gc> *v)
2420 {
2421 unsigned ix;
2422 tree t;
2423 FOR_EACH_VEC_SAFE_ELT (v, ix, t)
2424 if (elem == t)
2425 return true;
2426 return false;
2427 }
2428
2429 /* Returns element number IDX (zero-origin) of chain CHAIN, or
2430 NULL_TREE. */
2431
2432 tree
chain_index(int idx,tree chain)2433 chain_index (int idx, tree chain)
2434 {
2435 for (; chain && idx > 0; --idx)
2436 chain = TREE_CHAIN (chain);
2437 return chain;
2438 }
2439
2440 /* Return nonzero if ELEM is part of the chain CHAIN. */
2441
2442 int
chain_member(const_tree elem,const_tree chain)2443 chain_member (const_tree elem, const_tree chain)
2444 {
2445 while (chain)
2446 {
2447 if (elem == chain)
2448 return 1;
2449 chain = DECL_CHAIN (chain);
2450 }
2451
2452 return 0;
2453 }
2454
2455 /* Return the length of a chain of nodes chained through TREE_CHAIN.
2456 We expect a null pointer to mark the end of the chain.
2457 This is the Lisp primitive `length'. */
2458
2459 int
list_length(const_tree t)2460 list_length (const_tree t)
2461 {
2462 const_tree p = t;
2463 #ifdef ENABLE_TREE_CHECKING
2464 const_tree q = t;
2465 #endif
2466 int len = 0;
2467
2468 while (p)
2469 {
2470 p = TREE_CHAIN (p);
2471 #ifdef ENABLE_TREE_CHECKING
2472 if (len % 2)
2473 q = TREE_CHAIN (q);
2474 gcc_assert (p != q);
2475 #endif
2476 len++;
2477 }
2478
2479 return len;
2480 }
2481
2482 /* Returns the first FIELD_DECL in the TYPE_FIELDS of the RECORD_TYPE or
2483 UNION_TYPE TYPE, or NULL_TREE if none. */
2484
2485 tree
first_field(const_tree type)2486 first_field (const_tree type)
2487 {
2488 tree t = TYPE_FIELDS (type);
2489 while (t && TREE_CODE (t) != FIELD_DECL)
2490 t = TREE_CHAIN (t);
2491 return t;
2492 }
2493
2494 /* Concatenate two chains of nodes (chained through TREE_CHAIN)
2495 by modifying the last node in chain 1 to point to chain 2.
2496 This is the Lisp primitive `nconc'. */
2497
2498 tree
chainon(tree op1,tree op2)2499 chainon (tree op1, tree op2)
2500 {
2501 tree t1;
2502
2503 if (!op1)
2504 return op2;
2505 if (!op2)
2506 return op1;
2507
2508 for (t1 = op1; TREE_CHAIN (t1); t1 = TREE_CHAIN (t1))
2509 continue;
2510 TREE_CHAIN (t1) = op2;
2511
2512 #ifdef ENABLE_TREE_CHECKING
2513 {
2514 tree t2;
2515 for (t2 = op2; t2; t2 = TREE_CHAIN (t2))
2516 gcc_assert (t2 != t1);
2517 }
2518 #endif
2519
2520 return op1;
2521 }
2522
2523 /* Return the last node in a chain of nodes (chained through TREE_CHAIN). */
2524
2525 tree
tree_last(tree chain)2526 tree_last (tree chain)
2527 {
2528 tree next;
2529 if (chain)
2530 while ((next = TREE_CHAIN (chain)))
2531 chain = next;
2532 return chain;
2533 }
2534
2535 /* Reverse the order of elements in the chain T,
2536 and return the new head of the chain (old last element). */
2537
2538 tree
nreverse(tree t)2539 nreverse (tree t)
2540 {
2541 tree prev = 0, decl, next;
2542 for (decl = t; decl; decl = next)
2543 {
2544 /* We shouldn't be using this function to reverse BLOCK chains; we
2545 have blocks_nreverse for that. */
2546 gcc_checking_assert (TREE_CODE (decl) != BLOCK);
2547 next = TREE_CHAIN (decl);
2548 TREE_CHAIN (decl) = prev;
2549 prev = decl;
2550 }
2551 return prev;
2552 }
2553
2554 /* Return a newly created TREE_LIST node whose
2555 purpose and value fields are PARM and VALUE. */
2556
2557 tree
build_tree_list_stat(tree parm,tree value MEM_STAT_DECL)2558 build_tree_list_stat (tree parm, tree value MEM_STAT_DECL)
2559 {
2560 tree t = make_node_stat (TREE_LIST PASS_MEM_STAT);
2561 TREE_PURPOSE (t) = parm;
2562 TREE_VALUE (t) = value;
2563 return t;
2564 }
2565
2566 /* Build a chain of TREE_LIST nodes from a vector. */
2567
2568 tree
build_tree_list_vec_stat(const vec<tree,va_gc> * vec MEM_STAT_DECL)2569 build_tree_list_vec_stat (const vec<tree, va_gc> *vec MEM_STAT_DECL)
2570 {
2571 tree ret = NULL_TREE;
2572 tree *pp = &ret;
2573 unsigned int i;
2574 tree t;
2575 FOR_EACH_VEC_SAFE_ELT (vec, i, t)
2576 {
2577 *pp = build_tree_list_stat (NULL, t PASS_MEM_STAT);
2578 pp = &TREE_CHAIN (*pp);
2579 }
2580 return ret;
2581 }
2582
2583 /* Return a newly created TREE_LIST node whose
2584 purpose and value fields are PURPOSE and VALUE
2585 and whose TREE_CHAIN is CHAIN. */
2586
2587 tree
tree_cons_stat(tree purpose,tree value,tree chain MEM_STAT_DECL)2588 tree_cons_stat (tree purpose, tree value, tree chain MEM_STAT_DECL)
2589 {
2590 tree node;
2591
2592 node = ggc_alloc_tree_node_stat (sizeof (struct tree_list) PASS_MEM_STAT);
2593 memset (node, 0, sizeof (struct tree_common));
2594
2595 record_node_allocation_statistics (TREE_LIST, sizeof (struct tree_list));
2596
2597 TREE_SET_CODE (node, TREE_LIST);
2598 TREE_CHAIN (node) = chain;
2599 TREE_PURPOSE (node) = purpose;
2600 TREE_VALUE (node) = value;
2601 return node;
2602 }
2603
2604 /* Return the values of the elements of a CONSTRUCTOR as a vector of
2605 trees. */
2606
2607 vec<tree, va_gc> *
ctor_to_vec(tree ctor)2608 ctor_to_vec (tree ctor)
2609 {
2610 vec<tree, va_gc> *vec;
2611 vec_alloc (vec, CONSTRUCTOR_NELTS (ctor));
2612 unsigned int ix;
2613 tree val;
2614
2615 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (ctor), ix, val)
2616 vec->quick_push (val);
2617
2618 return vec;
2619 }
2620
2621 /* Return the size nominally occupied by an object of type TYPE
2622 when it resides in memory. The value is measured in units of bytes,
2623 and its data type is that normally used for type sizes
2624 (which is the first type created by make_signed_type or
2625 make_unsigned_type). */
2626
2627 tree
size_in_bytes(const_tree type)2628 size_in_bytes (const_tree type)
2629 {
2630 tree t;
2631
2632 if (type == error_mark_node)
2633 return integer_zero_node;
2634
2635 type = TYPE_MAIN_VARIANT (type);
2636 t = TYPE_SIZE_UNIT (type);
2637
2638 if (t == 0)
2639 {
2640 lang_hooks.types.incomplete_type_error (NULL_TREE, type);
2641 return size_zero_node;
2642 }
2643
2644 return t;
2645 }
2646
2647 /* Return the size of TYPE (in bytes) as a wide integer
2648 or return -1 if the size can vary or is larger than an integer. */
2649
2650 HOST_WIDE_INT
int_size_in_bytes(const_tree type)2651 int_size_in_bytes (const_tree type)
2652 {
2653 tree t;
2654
2655 if (type == error_mark_node)
2656 return 0;
2657
2658 type = TYPE_MAIN_VARIANT (type);
2659 t = TYPE_SIZE_UNIT (type);
2660 if (t == 0
2661 || TREE_CODE (t) != INTEGER_CST
2662 || TREE_INT_CST_HIGH (t) != 0
2663 /* If the result would appear negative, it's too big to represent. */
2664 || (HOST_WIDE_INT) TREE_INT_CST_LOW (t) < 0)
2665 return -1;
2666
2667 return TREE_INT_CST_LOW (t);
2668 }
2669
2670 /* Return the maximum size of TYPE (in bytes) as a wide integer
2671 or return -1 if the size can vary or is larger than an integer. */
2672
2673 HOST_WIDE_INT
max_int_size_in_bytes(const_tree type)2674 max_int_size_in_bytes (const_tree type)
2675 {
2676 HOST_WIDE_INT size = -1;
2677 tree size_tree;
2678
2679 /* If this is an array type, check for a possible MAX_SIZE attached. */
2680
2681 if (TREE_CODE (type) == ARRAY_TYPE)
2682 {
2683 size_tree = TYPE_ARRAY_MAX_SIZE (type);
2684
2685 if (size_tree && tree_fits_uhwi_p (size_tree))
2686 size = tree_to_uhwi (size_tree);
2687 }
2688
2689 /* If we still haven't been able to get a size, see if the language
2690 can compute a maximum size. */
2691
2692 if (size == -1)
2693 {
2694 size_tree = lang_hooks.types.max_size (type);
2695
2696 if (size_tree && tree_fits_uhwi_p (size_tree))
2697 size = tree_to_uhwi (size_tree);
2698 }
2699
2700 return size;
2701 }
2702
2703 /* Return the bit position of FIELD, in bits from the start of the record.
2704 This is a tree of type bitsizetype. */
2705
2706 tree
bit_position(const_tree field)2707 bit_position (const_tree field)
2708 {
2709 return bit_from_pos (DECL_FIELD_OFFSET (field),
2710 DECL_FIELD_BIT_OFFSET (field));
2711 }
2712
2713 /* Likewise, but return as an integer. It must be representable in
2714 that way (since it could be a signed value, we don't have the
2715 option of returning -1 like int_size_in_byte can. */
2716
2717 HOST_WIDE_INT
int_bit_position(const_tree field)2718 int_bit_position (const_tree field)
2719 {
2720 return tree_to_shwi (bit_position (field));
2721 }
2722
2723 /* Return the byte position of FIELD, in bytes from the start of the record.
2724 This is a tree of type sizetype. */
2725
2726 tree
byte_position(const_tree field)2727 byte_position (const_tree field)
2728 {
2729 return byte_from_pos (DECL_FIELD_OFFSET (field),
2730 DECL_FIELD_BIT_OFFSET (field));
2731 }
2732
2733 /* Likewise, but return as an integer. It must be representable in
2734 that way (since it could be a signed value, we don't have the
2735 option of returning -1 like int_size_in_byte can. */
2736
2737 HOST_WIDE_INT
int_byte_position(const_tree field)2738 int_byte_position (const_tree field)
2739 {
2740 return tree_to_shwi (byte_position (field));
2741 }
2742
2743 /* Return the strictest alignment, in bits, that T is known to have. */
2744
2745 unsigned int
expr_align(const_tree t)2746 expr_align (const_tree t)
2747 {
2748 unsigned int align0, align1;
2749
2750 switch (TREE_CODE (t))
2751 {
2752 CASE_CONVERT: case NON_LVALUE_EXPR:
2753 /* If we have conversions, we know that the alignment of the
2754 object must meet each of the alignments of the types. */
2755 align0 = expr_align (TREE_OPERAND (t, 0));
2756 align1 = TYPE_ALIGN (TREE_TYPE (t));
2757 return MAX (align0, align1);
2758
2759 case SAVE_EXPR: case COMPOUND_EXPR: case MODIFY_EXPR:
2760 case INIT_EXPR: case TARGET_EXPR: case WITH_CLEANUP_EXPR:
2761 case CLEANUP_POINT_EXPR:
2762 /* These don't change the alignment of an object. */
2763 return expr_align (TREE_OPERAND (t, 0));
2764
2765 case COND_EXPR:
2766 /* The best we can do is say that the alignment is the least aligned
2767 of the two arms. */
2768 align0 = expr_align (TREE_OPERAND (t, 1));
2769 align1 = expr_align (TREE_OPERAND (t, 2));
2770 return MIN (align0, align1);
2771
2772 /* FIXME: LABEL_DECL and CONST_DECL never have DECL_ALIGN set
2773 meaningfully, it's always 1. */
2774 case LABEL_DECL: case CONST_DECL:
2775 case VAR_DECL: case PARM_DECL: case RESULT_DECL:
2776 case FUNCTION_DECL:
2777 gcc_assert (DECL_ALIGN (t) != 0);
2778 return DECL_ALIGN (t);
2779
2780 default:
2781 break;
2782 }
2783
2784 /* Otherwise take the alignment from that of the type. */
2785 return TYPE_ALIGN (TREE_TYPE (t));
2786 }
2787
2788 /* Return, as a tree node, the number of elements for TYPE (which is an
2789 ARRAY_TYPE) minus one. This counts only elements of the top array. */
2790
2791 tree
array_type_nelts(const_tree type)2792 array_type_nelts (const_tree type)
2793 {
2794 tree index_type, min, max;
2795
2796 /* If they did it with unspecified bounds, then we should have already
2797 given an error about it before we got here. */
2798 if (! TYPE_DOMAIN (type))
2799 return error_mark_node;
2800
2801 index_type = TYPE_DOMAIN (type);
2802 min = TYPE_MIN_VALUE (index_type);
2803 max = TYPE_MAX_VALUE (index_type);
2804
2805 /* TYPE_MAX_VALUE may not be set if the array has unknown length. */
2806 if (!max)
2807 return error_mark_node;
2808
2809 return (integer_zerop (min)
2810 ? max
2811 : fold_build2 (MINUS_EXPR, TREE_TYPE (max), max, min));
2812 }
2813
2814 /* If arg is static -- a reference to an object in static storage -- then
2815 return the object. This is not the same as the C meaning of `static'.
2816 If arg isn't static, return NULL. */
2817
2818 tree
staticp(tree arg)2819 staticp (tree arg)
2820 {
2821 switch (TREE_CODE (arg))
2822 {
2823 case FUNCTION_DECL:
2824 /* Nested functions are static, even though taking their address will
2825 involve a trampoline as we unnest the nested function and create
2826 the trampoline on the tree level. */
2827 return arg;
2828
2829 case VAR_DECL:
2830 return ((TREE_STATIC (arg) || DECL_EXTERNAL (arg))
2831 && ! DECL_THREAD_LOCAL_P (arg)
2832 && ! DECL_DLLIMPORT_P (arg)
2833 ? arg : NULL);
2834
2835 case CONST_DECL:
2836 return ((TREE_STATIC (arg) || DECL_EXTERNAL (arg))
2837 ? arg : NULL);
2838
2839 case CONSTRUCTOR:
2840 return TREE_STATIC (arg) ? arg : NULL;
2841
2842 case LABEL_DECL:
2843 case STRING_CST:
2844 return arg;
2845
2846 case COMPONENT_REF:
2847 /* If the thing being referenced is not a field, then it is
2848 something language specific. */
2849 gcc_assert (TREE_CODE (TREE_OPERAND (arg, 1)) == FIELD_DECL);
2850
2851 /* If we are referencing a bitfield, we can't evaluate an
2852 ADDR_EXPR at compile time and so it isn't a constant. */
2853 if (DECL_BIT_FIELD (TREE_OPERAND (arg, 1)))
2854 return NULL;
2855
2856 return staticp (TREE_OPERAND (arg, 0));
2857
2858 case BIT_FIELD_REF:
2859 return NULL;
2860
2861 case INDIRECT_REF:
2862 return TREE_CONSTANT (TREE_OPERAND (arg, 0)) ? arg : NULL;
2863
2864 case ARRAY_REF:
2865 case ARRAY_RANGE_REF:
2866 if (TREE_CODE (TYPE_SIZE (TREE_TYPE (arg))) == INTEGER_CST
2867 && TREE_CODE (TREE_OPERAND (arg, 1)) == INTEGER_CST)
2868 return staticp (TREE_OPERAND (arg, 0));
2869 else
2870 return NULL;
2871
2872 case COMPOUND_LITERAL_EXPR:
2873 return TREE_STATIC (COMPOUND_LITERAL_EXPR_DECL (arg)) ? arg : NULL;
2874
2875 default:
2876 return NULL;
2877 }
2878 }
2879
2880
2881
2882
2883 /* Return whether OP is a DECL whose address is function-invariant. */
2884
2885 bool
decl_address_invariant_p(const_tree op)2886 decl_address_invariant_p (const_tree op)
2887 {
2888 /* The conditions below are slightly less strict than the one in
2889 staticp. */
2890
2891 switch (TREE_CODE (op))
2892 {
2893 case PARM_DECL:
2894 case RESULT_DECL:
2895 case LABEL_DECL:
2896 case FUNCTION_DECL:
2897 return true;
2898
2899 case VAR_DECL:
2900 if ((TREE_STATIC (op) || DECL_EXTERNAL (op))
2901 || DECL_THREAD_LOCAL_P (op)
2902 || DECL_CONTEXT (op) == current_function_decl
2903 || decl_function_context (op) == current_function_decl)
2904 return true;
2905 break;
2906
2907 case CONST_DECL:
2908 if ((TREE_STATIC (op) || DECL_EXTERNAL (op))
2909 || decl_function_context (op) == current_function_decl)
2910 return true;
2911 break;
2912
2913 default:
2914 break;
2915 }
2916
2917 return false;
2918 }
2919
2920 /* Return whether OP is a DECL whose address is interprocedural-invariant. */
2921
2922 bool
decl_address_ip_invariant_p(const_tree op)2923 decl_address_ip_invariant_p (const_tree op)
2924 {
2925 /* The conditions below are slightly less strict than the one in
2926 staticp. */
2927
2928 switch (TREE_CODE (op))
2929 {
2930 case LABEL_DECL:
2931 case FUNCTION_DECL:
2932 case STRING_CST:
2933 return true;
2934
2935 case VAR_DECL:
2936 if (((TREE_STATIC (op) || DECL_EXTERNAL (op))
2937 && !DECL_DLLIMPORT_P (op))
2938 || DECL_THREAD_LOCAL_P (op))
2939 return true;
2940 break;
2941
2942 case CONST_DECL:
2943 if ((TREE_STATIC (op) || DECL_EXTERNAL (op)))
2944 return true;
2945 break;
2946
2947 default:
2948 break;
2949 }
2950
2951 return false;
2952 }
2953
2954
2955 /* Return true if T is function-invariant (internal function, does
2956 not handle arithmetic; that's handled in skip_simple_arithmetic and
2957 tree_invariant_p). */
2958
2959 static bool tree_invariant_p (tree t);
2960
2961 static bool
tree_invariant_p_1(tree t)2962 tree_invariant_p_1 (tree t)
2963 {
2964 tree op;
2965
2966 if (TREE_CONSTANT (t)
2967 || (TREE_READONLY (t) && !TREE_SIDE_EFFECTS (t)))
2968 return true;
2969
2970 switch (TREE_CODE (t))
2971 {
2972 case SAVE_EXPR:
2973 return true;
2974
2975 case ADDR_EXPR:
2976 op = TREE_OPERAND (t, 0);
2977 while (handled_component_p (op))
2978 {
2979 switch (TREE_CODE (op))
2980 {
2981 case ARRAY_REF:
2982 case ARRAY_RANGE_REF:
2983 if (!tree_invariant_p (TREE_OPERAND (op, 1))
2984 || TREE_OPERAND (op, 2) != NULL_TREE
2985 || TREE_OPERAND (op, 3) != NULL_TREE)
2986 return false;
2987 break;
2988
2989 case COMPONENT_REF:
2990 if (TREE_OPERAND (op, 2) != NULL_TREE)
2991 return false;
2992 break;
2993
2994 default:;
2995 }
2996 op = TREE_OPERAND (op, 0);
2997 }
2998
2999 return CONSTANT_CLASS_P (op) || decl_address_invariant_p (op);
3000
3001 default:
3002 break;
3003 }
3004
3005 return false;
3006 }
3007
3008 /* Return true if T is function-invariant. */
3009
3010 static bool
tree_invariant_p(tree t)3011 tree_invariant_p (tree t)
3012 {
3013 tree inner = skip_simple_arithmetic (t);
3014 return tree_invariant_p_1 (inner);
3015 }
3016
3017 /* Wrap a SAVE_EXPR around EXPR, if appropriate.
3018 Do this to any expression which may be used in more than one place,
3019 but must be evaluated only once.
3020
3021 Normally, expand_expr would reevaluate the expression each time.
3022 Calling save_expr produces something that is evaluated and recorded
3023 the first time expand_expr is called on it. Subsequent calls to
3024 expand_expr just reuse the recorded value.
3025
3026 The call to expand_expr that generates code that actually computes
3027 the value is the first call *at compile time*. Subsequent calls
3028 *at compile time* generate code to use the saved value.
3029 This produces correct result provided that *at run time* control
3030 always flows through the insns made by the first expand_expr
3031 before reaching the other places where the save_expr was evaluated.
3032 You, the caller of save_expr, must make sure this is so.
3033
3034 Constants, and certain read-only nodes, are returned with no
3035 SAVE_EXPR because that is safe. Expressions containing placeholders
3036 are not touched; see tree.def for an explanation of what these
3037 are used for. */
3038
3039 tree
save_expr(tree expr)3040 save_expr (tree expr)
3041 {
3042 tree t = fold (expr);
3043 tree inner;
3044
3045 /* If the tree evaluates to a constant, then we don't want to hide that
3046 fact (i.e. this allows further folding, and direct checks for constants).
3047 However, a read-only object that has side effects cannot be bypassed.
3048 Since it is no problem to reevaluate literals, we just return the
3049 literal node. */
3050 inner = skip_simple_arithmetic (t);
3051 if (TREE_CODE (inner) == ERROR_MARK)
3052 return inner;
3053
3054 if (tree_invariant_p_1 (inner))
3055 return t;
3056
3057 /* If INNER contains a PLACEHOLDER_EXPR, we must evaluate it each time, since
3058 it means that the size or offset of some field of an object depends on
3059 the value within another field.
3060
3061 Note that it must not be the case that T contains both a PLACEHOLDER_EXPR
3062 and some variable since it would then need to be both evaluated once and
3063 evaluated more than once. Front-ends must assure this case cannot
3064 happen by surrounding any such subexpressions in their own SAVE_EXPR
3065 and forcing evaluation at the proper time. */
3066 if (contains_placeholder_p (inner))
3067 return t;
3068
3069 t = build1 (SAVE_EXPR, TREE_TYPE (expr), t);
3070 SET_EXPR_LOCATION (t, EXPR_LOCATION (expr));
3071
3072 /* This expression might be placed ahead of a jump to ensure that the
3073 value was computed on both sides of the jump. So make sure it isn't
3074 eliminated as dead. */
3075 TREE_SIDE_EFFECTS (t) = 1;
3076 return t;
3077 }
3078
3079 /* Look inside EXPR into any simple arithmetic operations. Return the
3080 outermost non-arithmetic or non-invariant node. */
3081
3082 tree
skip_simple_arithmetic(tree expr)3083 skip_simple_arithmetic (tree expr)
3084 {
3085 /* We don't care about whether this can be used as an lvalue in this
3086 context. */
3087 while (TREE_CODE (expr) == NON_LVALUE_EXPR)
3088 expr = TREE_OPERAND (expr, 0);
3089
3090 /* If we have simple operations applied to a SAVE_EXPR or to a SAVE_EXPR and
3091 a constant, it will be more efficient to not make another SAVE_EXPR since
3092 it will allow better simplification and GCSE will be able to merge the
3093 computations if they actually occur. */
3094 while (true)
3095 {
3096 if (UNARY_CLASS_P (expr))
3097 expr = TREE_OPERAND (expr, 0);
3098 else if (BINARY_CLASS_P (expr))
3099 {
3100 if (tree_invariant_p (TREE_OPERAND (expr, 1)))
3101 expr = TREE_OPERAND (expr, 0);
3102 else if (tree_invariant_p (TREE_OPERAND (expr, 0)))
3103 expr = TREE_OPERAND (expr, 1);
3104 else
3105 break;
3106 }
3107 else
3108 break;
3109 }
3110
3111 return expr;
3112 }
3113
3114 /* Look inside EXPR into simple arithmetic operations involving constants.
3115 Return the outermost non-arithmetic or non-constant node. */
3116
3117 tree
skip_simple_constant_arithmetic(tree expr)3118 skip_simple_constant_arithmetic (tree expr)
3119 {
3120 while (TREE_CODE (expr) == NON_LVALUE_EXPR)
3121 expr = TREE_OPERAND (expr, 0);
3122
3123 while (true)
3124 {
3125 if (UNARY_CLASS_P (expr))
3126 expr = TREE_OPERAND (expr, 0);
3127 else if (BINARY_CLASS_P (expr))
3128 {
3129 if (TREE_CONSTANT (TREE_OPERAND (expr, 1)))
3130 expr = TREE_OPERAND (expr, 0);
3131 else if (TREE_CONSTANT (TREE_OPERAND (expr, 0)))
3132 expr = TREE_OPERAND (expr, 1);
3133 else
3134 break;
3135 }
3136 else
3137 break;
3138 }
3139
3140 return expr;
3141 }
3142
3143 /* Return which tree structure is used by T. */
3144
3145 enum tree_node_structure_enum
tree_node_structure(const_tree t)3146 tree_node_structure (const_tree t)
3147 {
3148 const enum tree_code code = TREE_CODE (t);
3149 return tree_node_structure_for_code (code);
3150 }
3151
3152 /* Set various status flags when building a CALL_EXPR object T. */
3153
3154 static void
process_call_operands(tree t)3155 process_call_operands (tree t)
3156 {
3157 bool side_effects = TREE_SIDE_EFFECTS (t);
3158 bool read_only = false;
3159 int i = call_expr_flags (t);
3160
3161 /* Calls have side-effects, except those to const or pure functions. */
3162 if ((i & ECF_LOOPING_CONST_OR_PURE) || !(i & (ECF_CONST | ECF_PURE)))
3163 side_effects = true;
3164 /* Propagate TREE_READONLY of arguments for const functions. */
3165 if (i & ECF_CONST)
3166 read_only = true;
3167
3168 if (!side_effects || read_only)
3169 for (i = 1; i < TREE_OPERAND_LENGTH (t); i++)
3170 {
3171 tree op = TREE_OPERAND (t, i);
3172 if (op && TREE_SIDE_EFFECTS (op))
3173 side_effects = true;
3174 if (op && !TREE_READONLY (op) && !CONSTANT_CLASS_P (op))
3175 read_only = false;
3176 }
3177
3178 TREE_SIDE_EFFECTS (t) = side_effects;
3179 TREE_READONLY (t) = read_only;
3180 }
3181
3182 /* Return true if EXP contains a PLACEHOLDER_EXPR, i.e. if it represents a
3183 size or offset that depends on a field within a record. */
3184
3185 bool
contains_placeholder_p(const_tree exp)3186 contains_placeholder_p (const_tree exp)
3187 {
3188 enum tree_code code;
3189
3190 if (!exp)
3191 return 0;
3192
3193 code = TREE_CODE (exp);
3194 if (code == PLACEHOLDER_EXPR)
3195 return 1;
3196
3197 switch (TREE_CODE_CLASS (code))
3198 {
3199 case tcc_reference:
3200 /* Don't look at any PLACEHOLDER_EXPRs that might be in index or bit
3201 position computations since they will be converted into a
3202 WITH_RECORD_EXPR involving the reference, which will assume
3203 here will be valid. */
3204 return CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 0));
3205
3206 case tcc_exceptional:
3207 if (code == TREE_LIST)
3208 return (CONTAINS_PLACEHOLDER_P (TREE_VALUE (exp))
3209 || CONTAINS_PLACEHOLDER_P (TREE_CHAIN (exp)));
3210 break;
3211
3212 case tcc_unary:
3213 case tcc_binary:
3214 case tcc_comparison:
3215 case tcc_expression:
3216 switch (code)
3217 {
3218 case COMPOUND_EXPR:
3219 /* Ignoring the first operand isn't quite right, but works best. */
3220 return CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 1));
3221
3222 case COND_EXPR:
3223 return (CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 0))
3224 || CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 1))
3225 || CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 2)));
3226
3227 case SAVE_EXPR:
3228 /* The save_expr function never wraps anything containing
3229 a PLACEHOLDER_EXPR. */
3230 return 0;
3231
3232 default:
3233 break;
3234 }
3235
3236 switch (TREE_CODE_LENGTH (code))
3237 {
3238 case 1:
3239 return CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 0));
3240 case 2:
3241 return (CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 0))
3242 || CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 1)));
3243 default:
3244 return 0;
3245 }
3246
3247 case tcc_vl_exp:
3248 switch (code)
3249 {
3250 case CALL_EXPR:
3251 {
3252 const_tree arg;
3253 const_call_expr_arg_iterator iter;
3254 FOR_EACH_CONST_CALL_EXPR_ARG (arg, iter, exp)
3255 if (CONTAINS_PLACEHOLDER_P (arg))
3256 return 1;
3257 return 0;
3258 }
3259 default:
3260 return 0;
3261 }
3262
3263 default:
3264 return 0;
3265 }
3266 return 0;
3267 }
3268
3269 /* Return true if any part of the structure of TYPE involves a PLACEHOLDER_EXPR
3270 directly. This includes size, bounds, qualifiers (for QUAL_UNION_TYPE) and
3271 field positions. */
3272
3273 static bool
type_contains_placeholder_1(const_tree type)3274 type_contains_placeholder_1 (const_tree type)
3275 {
3276 /* If the size contains a placeholder or the parent type (component type in
3277 the case of arrays) type involves a placeholder, this type does. */
3278 if (CONTAINS_PLACEHOLDER_P (TYPE_SIZE (type))
3279 || CONTAINS_PLACEHOLDER_P (TYPE_SIZE_UNIT (type))
3280 || (!POINTER_TYPE_P (type)
3281 && TREE_TYPE (type)
3282 && type_contains_placeholder_p (TREE_TYPE (type))))
3283 return true;
3284
3285 /* Now do type-specific checks. Note that the last part of the check above
3286 greatly limits what we have to do below. */
3287 switch (TREE_CODE (type))
3288 {
3289 case VOID_TYPE:
3290 case COMPLEX_TYPE:
3291 case ENUMERAL_TYPE:
3292 case BOOLEAN_TYPE:
3293 case POINTER_TYPE:
3294 case OFFSET_TYPE:
3295 case REFERENCE_TYPE:
3296 case METHOD_TYPE:
3297 case FUNCTION_TYPE:
3298 case VECTOR_TYPE:
3299 case NULLPTR_TYPE:
3300 return false;
3301
3302 case INTEGER_TYPE:
3303 case REAL_TYPE:
3304 case FIXED_POINT_TYPE:
3305 /* Here we just check the bounds. */
3306 return (CONTAINS_PLACEHOLDER_P (TYPE_MIN_VALUE (type))
3307 || CONTAINS_PLACEHOLDER_P (TYPE_MAX_VALUE (type)));
3308
3309 case ARRAY_TYPE:
3310 /* We have already checked the component type above, so just check the
3311 domain type. */
3312 return type_contains_placeholder_p (TYPE_DOMAIN (type));
3313
3314 case RECORD_TYPE:
3315 case UNION_TYPE:
3316 case QUAL_UNION_TYPE:
3317 {
3318 tree field;
3319
3320 for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
3321 if (TREE_CODE (field) == FIELD_DECL
3322 && (CONTAINS_PLACEHOLDER_P (DECL_FIELD_OFFSET (field))
3323 || (TREE_CODE (type) == QUAL_UNION_TYPE
3324 && CONTAINS_PLACEHOLDER_P (DECL_QUALIFIER (field)))
3325 || type_contains_placeholder_p (TREE_TYPE (field))))
3326 return true;
3327
3328 return false;
3329 }
3330
3331 default:
3332 gcc_unreachable ();
3333 }
3334 }
3335
3336 /* Wrapper around above function used to cache its result. */
3337
3338 bool
type_contains_placeholder_p(tree type)3339 type_contains_placeholder_p (tree type)
3340 {
3341 bool result;
3342
3343 /* If the contains_placeholder_bits field has been initialized,
3344 then we know the answer. */
3345 if (TYPE_CONTAINS_PLACEHOLDER_INTERNAL (type) > 0)
3346 return TYPE_CONTAINS_PLACEHOLDER_INTERNAL (type) - 1;
3347
3348 /* Indicate that we've seen this type node, and the answer is false.
3349 This is what we want to return if we run into recursion via fields. */
3350 TYPE_CONTAINS_PLACEHOLDER_INTERNAL (type) = 1;
3351
3352 /* Compute the real value. */
3353 result = type_contains_placeholder_1 (type);
3354
3355 /* Store the real value. */
3356 TYPE_CONTAINS_PLACEHOLDER_INTERNAL (type) = result + 1;
3357
3358 return result;
3359 }
3360
3361 /* Push tree EXP onto vector QUEUE if it is not already present. */
3362
3363 static void
push_without_duplicates(tree exp,vec<tree> * queue)3364 push_without_duplicates (tree exp, vec<tree> *queue)
3365 {
3366 unsigned int i;
3367 tree iter;
3368
3369 FOR_EACH_VEC_ELT (*queue, i, iter)
3370 if (simple_cst_equal (iter, exp) == 1)
3371 break;
3372
3373 if (!iter)
3374 queue->safe_push (exp);
3375 }
3376
3377 /* Given a tree EXP, find all occurrences of references to fields
3378 in a PLACEHOLDER_EXPR and place them in vector REFS without
3379 duplicates. Also record VAR_DECLs and CONST_DECLs. Note that
3380 we assume here that EXP contains only arithmetic expressions
3381 or CALL_EXPRs with PLACEHOLDER_EXPRs occurring only in their
3382 argument list. */
3383
3384 void
find_placeholder_in_expr(tree exp,vec<tree> * refs)3385 find_placeholder_in_expr (tree exp, vec<tree> *refs)
3386 {
3387 enum tree_code code = TREE_CODE (exp);
3388 tree inner;
3389 int i;
3390
3391 /* We handle TREE_LIST and COMPONENT_REF separately. */
3392 if (code == TREE_LIST)
3393 {
3394 FIND_PLACEHOLDER_IN_EXPR (TREE_CHAIN (exp), refs);
3395 FIND_PLACEHOLDER_IN_EXPR (TREE_VALUE (exp), refs);
3396 }
3397 else if (code == COMPONENT_REF)
3398 {
3399 for (inner = TREE_OPERAND (exp, 0);
3400 REFERENCE_CLASS_P (inner);
3401 inner = TREE_OPERAND (inner, 0))
3402 ;
3403
3404 if (TREE_CODE (inner) == PLACEHOLDER_EXPR)
3405 push_without_duplicates (exp, refs);
3406 else
3407 FIND_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 0), refs);
3408 }
3409 else
3410 switch (TREE_CODE_CLASS (code))
3411 {
3412 case tcc_constant:
3413 break;
3414
3415 case tcc_declaration:
3416 /* Variables allocated to static storage can stay. */
3417 if (!TREE_STATIC (exp))
3418 push_without_duplicates (exp, refs);
3419 break;
3420
3421 case tcc_expression:
3422 /* This is the pattern built in ada/make_aligning_type. */
3423 if (code == ADDR_EXPR
3424 && TREE_CODE (TREE_OPERAND (exp, 0)) == PLACEHOLDER_EXPR)
3425 {
3426 push_without_duplicates (exp, refs);
3427 break;
3428 }
3429
3430 /* Fall through... */
3431
3432 case tcc_exceptional:
3433 case tcc_unary:
3434 case tcc_binary:
3435 case tcc_comparison:
3436 case tcc_reference:
3437 for (i = 0; i < TREE_CODE_LENGTH (code); i++)
3438 FIND_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, i), refs);
3439 break;
3440
3441 case tcc_vl_exp:
3442 for (i = 1; i < TREE_OPERAND_LENGTH (exp); i++)
3443 FIND_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, i), refs);
3444 break;
3445
3446 default:
3447 gcc_unreachable ();
3448 }
3449 }
3450
3451 /* Given a tree EXP, a FIELD_DECL F, and a replacement value R,
3452 return a tree with all occurrences of references to F in a
3453 PLACEHOLDER_EXPR replaced by R. Also handle VAR_DECLs and
3454 CONST_DECLs. Note that we assume here that EXP contains only
3455 arithmetic expressions or CALL_EXPRs with PLACEHOLDER_EXPRs
3456 occurring only in their argument list. */
3457
3458 tree
substitute_in_expr(tree exp,tree f,tree r)3459 substitute_in_expr (tree exp, tree f, tree r)
3460 {
3461 enum tree_code code = TREE_CODE (exp);
3462 tree op0, op1, op2, op3;
3463 tree new_tree;
3464
3465 /* We handle TREE_LIST and COMPONENT_REF separately. */
3466 if (code == TREE_LIST)
3467 {
3468 op0 = SUBSTITUTE_IN_EXPR (TREE_CHAIN (exp), f, r);
3469 op1 = SUBSTITUTE_IN_EXPR (TREE_VALUE (exp), f, r);
3470 if (op0 == TREE_CHAIN (exp) && op1 == TREE_VALUE (exp))
3471 return exp;
3472
3473 return tree_cons (TREE_PURPOSE (exp), op1, op0);
3474 }
3475 else if (code == COMPONENT_REF)
3476 {
3477 tree inner;
3478
3479 /* If this expression is getting a value from a PLACEHOLDER_EXPR
3480 and it is the right field, replace it with R. */
3481 for (inner = TREE_OPERAND (exp, 0);
3482 REFERENCE_CLASS_P (inner);
3483 inner = TREE_OPERAND (inner, 0))
3484 ;
3485
3486 /* The field. */
3487 op1 = TREE_OPERAND (exp, 1);
3488
3489 if (TREE_CODE (inner) == PLACEHOLDER_EXPR && op1 == f)
3490 return r;
3491
3492 /* If this expression hasn't been completed let, leave it alone. */
3493 if (TREE_CODE (inner) == PLACEHOLDER_EXPR && !TREE_TYPE (inner))
3494 return exp;
3495
3496 op0 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 0), f, r);
3497 if (op0 == TREE_OPERAND (exp, 0))
3498 return exp;
3499
3500 new_tree
3501 = fold_build3 (COMPONENT_REF, TREE_TYPE (exp), op0, op1, NULL_TREE);
3502 }
3503 else
3504 switch (TREE_CODE_CLASS (code))
3505 {
3506 case tcc_constant:
3507 return exp;
3508
3509 case tcc_declaration:
3510 if (exp == f)
3511 return r;
3512 else
3513 return exp;
3514
3515 case tcc_expression:
3516 if (exp == f)
3517 return r;
3518
3519 /* Fall through... */
3520
3521 case tcc_exceptional:
3522 case tcc_unary:
3523 case tcc_binary:
3524 case tcc_comparison:
3525 case tcc_reference:
3526 switch (TREE_CODE_LENGTH (code))
3527 {
3528 case 0:
3529 return exp;
3530
3531 case 1:
3532 op0 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 0), f, r);
3533 if (op0 == TREE_OPERAND (exp, 0))
3534 return exp;
3535
3536 new_tree = fold_build1 (code, TREE_TYPE (exp), op0);
3537 break;
3538
3539 case 2:
3540 op0 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 0), f, r);
3541 op1 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 1), f, r);
3542
3543 if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1))
3544 return exp;
3545
3546 new_tree = fold_build2 (code, TREE_TYPE (exp), op0, op1);
3547 break;
3548
3549 case 3:
3550 op0 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 0), f, r);
3551 op1 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 1), f, r);
3552 op2 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 2), f, r);
3553
3554 if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1)
3555 && op2 == TREE_OPERAND (exp, 2))
3556 return exp;
3557
3558 new_tree = fold_build3 (code, TREE_TYPE (exp), op0, op1, op2);
3559 break;
3560
3561 case 4:
3562 op0 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 0), f, r);
3563 op1 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 1), f, r);
3564 op2 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 2), f, r);
3565 op3 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 3), f, r);
3566
3567 if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1)
3568 && op2 == TREE_OPERAND (exp, 2)
3569 && op3 == TREE_OPERAND (exp, 3))
3570 return exp;
3571
3572 new_tree
3573 = fold (build4 (code, TREE_TYPE (exp), op0, op1, op2, op3));
3574 break;
3575
3576 default:
3577 gcc_unreachable ();
3578 }
3579 break;
3580
3581 case tcc_vl_exp:
3582 {
3583 int i;
3584
3585 new_tree = NULL_TREE;
3586
3587 /* If we are trying to replace F with a constant, inline back
3588 functions which do nothing else than computing a value from
3589 the arguments they are passed. This makes it possible to
3590 fold partially or entirely the replacement expression. */
3591 if (CONSTANT_CLASS_P (r) && code == CALL_EXPR)
3592 {
3593 tree t = maybe_inline_call_in_expr (exp);
3594 if (t)
3595 return SUBSTITUTE_IN_EXPR (t, f, r);
3596 }
3597
3598 for (i = 1; i < TREE_OPERAND_LENGTH (exp); i++)
3599 {
3600 tree op = TREE_OPERAND (exp, i);
3601 tree new_op = SUBSTITUTE_IN_EXPR (op, f, r);
3602 if (new_op != op)
3603 {
3604 if (!new_tree)
3605 new_tree = copy_node (exp);
3606 TREE_OPERAND (new_tree, i) = new_op;
3607 }
3608 }
3609
3610 if (new_tree)
3611 {
3612 new_tree = fold (new_tree);
3613 if (TREE_CODE (new_tree) == CALL_EXPR)
3614 process_call_operands (new_tree);
3615 }
3616 else
3617 return exp;
3618 }
3619 break;
3620
3621 default:
3622 gcc_unreachable ();
3623 }
3624
3625 TREE_READONLY (new_tree) |= TREE_READONLY (exp);
3626
3627 if (code == INDIRECT_REF || code == ARRAY_REF || code == ARRAY_RANGE_REF)
3628 TREE_THIS_NOTRAP (new_tree) |= TREE_THIS_NOTRAP (exp);
3629
3630 return new_tree;
3631 }
3632
3633 /* Similar, but look for a PLACEHOLDER_EXPR in EXP and find a replacement
3634 for it within OBJ, a tree that is an object or a chain of references. */
3635
3636 tree
substitute_placeholder_in_expr(tree exp,tree obj)3637 substitute_placeholder_in_expr (tree exp, tree obj)
3638 {
3639 enum tree_code code = TREE_CODE (exp);
3640 tree op0, op1, op2, op3;
3641 tree new_tree;
3642
3643 /* If this is a PLACEHOLDER_EXPR, see if we find a corresponding type
3644 in the chain of OBJ. */
3645 if (code == PLACEHOLDER_EXPR)
3646 {
3647 tree need_type = TYPE_MAIN_VARIANT (TREE_TYPE (exp));
3648 tree elt;
3649
3650 for (elt = obj; elt != 0;
3651 elt = ((TREE_CODE (elt) == COMPOUND_EXPR
3652 || TREE_CODE (elt) == COND_EXPR)
3653 ? TREE_OPERAND (elt, 1)
3654 : (REFERENCE_CLASS_P (elt)
3655 || UNARY_CLASS_P (elt)
3656 || BINARY_CLASS_P (elt)
3657 || VL_EXP_CLASS_P (elt)
3658 || EXPRESSION_CLASS_P (elt))
3659 ? TREE_OPERAND (elt, 0) : 0))
3660 if (TYPE_MAIN_VARIANT (TREE_TYPE (elt)) == need_type)
3661 return elt;
3662
3663 for (elt = obj; elt != 0;
3664 elt = ((TREE_CODE (elt) == COMPOUND_EXPR
3665 || TREE_CODE (elt) == COND_EXPR)
3666 ? TREE_OPERAND (elt, 1)
3667 : (REFERENCE_CLASS_P (elt)
3668 || UNARY_CLASS_P (elt)
3669 || BINARY_CLASS_P (elt)
3670 || VL_EXP_CLASS_P (elt)
3671 || EXPRESSION_CLASS_P (elt))
3672 ? TREE_OPERAND (elt, 0) : 0))
3673 if (POINTER_TYPE_P (TREE_TYPE (elt))
3674 && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (elt)))
3675 == need_type))
3676 return fold_build1 (INDIRECT_REF, need_type, elt);
3677
3678 /* If we didn't find it, return the original PLACEHOLDER_EXPR. If it
3679 survives until RTL generation, there will be an error. */
3680 return exp;
3681 }
3682
3683 /* TREE_LIST is special because we need to look at TREE_VALUE
3684 and TREE_CHAIN, not TREE_OPERANDS. */
3685 else if (code == TREE_LIST)
3686 {
3687 op0 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_CHAIN (exp), obj);
3688 op1 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_VALUE (exp), obj);
3689 if (op0 == TREE_CHAIN (exp) && op1 == TREE_VALUE (exp))
3690 return exp;
3691
3692 return tree_cons (TREE_PURPOSE (exp), op1, op0);
3693 }
3694 else
3695 switch (TREE_CODE_CLASS (code))
3696 {
3697 case tcc_constant:
3698 case tcc_declaration:
3699 return exp;
3700
3701 case tcc_exceptional:
3702 case tcc_unary:
3703 case tcc_binary:
3704 case tcc_comparison:
3705 case tcc_expression:
3706 case tcc_reference:
3707 case tcc_statement:
3708 switch (TREE_CODE_LENGTH (code))
3709 {
3710 case 0:
3711 return exp;
3712
3713 case 1:
3714 op0 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 0), obj);
3715 if (op0 == TREE_OPERAND (exp, 0))
3716 return exp;
3717
3718 new_tree = fold_build1 (code, TREE_TYPE (exp), op0);
3719 break;
3720
3721 case 2:
3722 op0 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 0), obj);
3723 op1 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 1), obj);
3724
3725 if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1))
3726 return exp;
3727
3728 new_tree = fold_build2 (code, TREE_TYPE (exp), op0, op1);
3729 break;
3730
3731 case 3:
3732 op0 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 0), obj);
3733 op1 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 1), obj);
3734 op2 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 2), obj);
3735
3736 if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1)
3737 && op2 == TREE_OPERAND (exp, 2))
3738 return exp;
3739
3740 new_tree = fold_build3 (code, TREE_TYPE (exp), op0, op1, op2);
3741 break;
3742
3743 case 4:
3744 op0 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 0), obj);
3745 op1 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 1), obj);
3746 op2 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 2), obj);
3747 op3 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 3), obj);
3748
3749 if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1)
3750 && op2 == TREE_OPERAND (exp, 2)
3751 && op3 == TREE_OPERAND (exp, 3))
3752 return exp;
3753
3754 new_tree
3755 = fold (build4 (code, TREE_TYPE (exp), op0, op1, op2, op3));
3756 break;
3757
3758 default:
3759 gcc_unreachable ();
3760 }
3761 break;
3762
3763 case tcc_vl_exp:
3764 {
3765 int i;
3766
3767 new_tree = NULL_TREE;
3768
3769 for (i = 1; i < TREE_OPERAND_LENGTH (exp); i++)
3770 {
3771 tree op = TREE_OPERAND (exp, i);
3772 tree new_op = SUBSTITUTE_PLACEHOLDER_IN_EXPR (op, obj);
3773 if (new_op != op)
3774 {
3775 if (!new_tree)
3776 new_tree = copy_node (exp);
3777 TREE_OPERAND (new_tree, i) = new_op;
3778 }
3779 }
3780
3781 if (new_tree)
3782 {
3783 new_tree = fold (new_tree);
3784 if (TREE_CODE (new_tree) == CALL_EXPR)
3785 process_call_operands (new_tree);
3786 }
3787 else
3788 return exp;
3789 }
3790 break;
3791
3792 default:
3793 gcc_unreachable ();
3794 }
3795
3796 TREE_READONLY (new_tree) |= TREE_READONLY (exp);
3797
3798 if (code == INDIRECT_REF || code == ARRAY_REF || code == ARRAY_RANGE_REF)
3799 TREE_THIS_NOTRAP (new_tree) |= TREE_THIS_NOTRAP (exp);
3800
3801 return new_tree;
3802 }
3803
3804
3805 /* Subroutine of stabilize_reference; this is called for subtrees of
3806 references. Any expression with side-effects must be put in a SAVE_EXPR
3807 to ensure that it is only evaluated once.
3808
3809 We don't put SAVE_EXPR nodes around everything, because assigning very
3810 simple expressions to temporaries causes us to miss good opportunities
3811 for optimizations. Among other things, the opportunity to fold in the
3812 addition of a constant into an addressing mode often gets lost, e.g.
3813 "y[i+1] += x;". In general, we take the approach that we should not make
3814 an assignment unless we are forced into it - i.e., that any non-side effect
3815 operator should be allowed, and that cse should take care of coalescing
3816 multiple utterances of the same expression should that prove fruitful. */
3817
3818 static tree
stabilize_reference_1(tree e)3819 stabilize_reference_1 (tree e)
3820 {
3821 tree result;
3822 enum tree_code code = TREE_CODE (e);
3823
3824 /* We cannot ignore const expressions because it might be a reference
3825 to a const array but whose index contains side-effects. But we can
3826 ignore things that are actual constant or that already have been
3827 handled by this function. */
3828
3829 if (tree_invariant_p (e))
3830 return e;
3831
3832 switch (TREE_CODE_CLASS (code))
3833 {
3834 case tcc_exceptional:
3835 case tcc_type:
3836 case tcc_declaration:
3837 case tcc_comparison:
3838 case tcc_statement:
3839 case tcc_expression:
3840 case tcc_reference:
3841 case tcc_vl_exp:
3842 /* If the expression has side-effects, then encase it in a SAVE_EXPR
3843 so that it will only be evaluated once. */
3844 /* The reference (r) and comparison (<) classes could be handled as
3845 below, but it is generally faster to only evaluate them once. */
3846 if (TREE_SIDE_EFFECTS (e))
3847 return save_expr (e);
3848 return e;
3849
3850 case tcc_constant:
3851 /* Constants need no processing. In fact, we should never reach
3852 here. */
3853 return e;
3854
3855 case tcc_binary:
3856 /* Division is slow and tends to be compiled with jumps,
3857 especially the division by powers of 2 that is often
3858 found inside of an array reference. So do it just once. */
3859 if (code == TRUNC_DIV_EXPR || code == TRUNC_MOD_EXPR
3860 || code == FLOOR_DIV_EXPR || code == FLOOR_MOD_EXPR
3861 || code == CEIL_DIV_EXPR || code == CEIL_MOD_EXPR
3862 || code == ROUND_DIV_EXPR || code == ROUND_MOD_EXPR)
3863 return save_expr (e);
3864 /* Recursively stabilize each operand. */
3865 result = build_nt (code, stabilize_reference_1 (TREE_OPERAND (e, 0)),
3866 stabilize_reference_1 (TREE_OPERAND (e, 1)));
3867 break;
3868
3869 case tcc_unary:
3870 /* Recursively stabilize each operand. */
3871 result = build_nt (code, stabilize_reference_1 (TREE_OPERAND (e, 0)));
3872 break;
3873
3874 default:
3875 gcc_unreachable ();
3876 }
3877
3878 TREE_TYPE (result) = TREE_TYPE (e);
3879 TREE_READONLY (result) = TREE_READONLY (e);
3880 TREE_SIDE_EFFECTS (result) = TREE_SIDE_EFFECTS (e);
3881 TREE_THIS_VOLATILE (result) = TREE_THIS_VOLATILE (e);
3882
3883 return result;
3884 }
3885
3886 /* Stabilize a reference so that we can use it any number of times
3887 without causing its operands to be evaluated more than once.
3888 Returns the stabilized reference. This works by means of save_expr,
3889 so see the caveats in the comments about save_expr.
3890
3891 Also allows conversion expressions whose operands are references.
3892 Any other kind of expression is returned unchanged. */
3893
3894 tree
stabilize_reference(tree ref)3895 stabilize_reference (tree ref)
3896 {
3897 tree result;
3898 enum tree_code code = TREE_CODE (ref);
3899
3900 switch (code)
3901 {
3902 case VAR_DECL:
3903 case PARM_DECL:
3904 case RESULT_DECL:
3905 /* No action is needed in this case. */
3906 return ref;
3907
3908 CASE_CONVERT:
3909 case FLOAT_EXPR:
3910 case FIX_TRUNC_EXPR:
3911 result = build_nt (code, stabilize_reference (TREE_OPERAND (ref, 0)));
3912 break;
3913
3914 case INDIRECT_REF:
3915 result = build_nt (INDIRECT_REF,
3916 stabilize_reference_1 (TREE_OPERAND (ref, 0)));
3917 break;
3918
3919 case COMPONENT_REF:
3920 result = build_nt (COMPONENT_REF,
3921 stabilize_reference (TREE_OPERAND (ref, 0)),
3922 TREE_OPERAND (ref, 1), NULL_TREE);
3923 break;
3924
3925 case BIT_FIELD_REF:
3926 result = build_nt (BIT_FIELD_REF,
3927 stabilize_reference (TREE_OPERAND (ref, 0)),
3928 TREE_OPERAND (ref, 1), TREE_OPERAND (ref, 2));
3929 break;
3930
3931 case ARRAY_REF:
3932 result = build_nt (ARRAY_REF,
3933 stabilize_reference (TREE_OPERAND (ref, 0)),
3934 stabilize_reference_1 (TREE_OPERAND (ref, 1)),
3935 TREE_OPERAND (ref, 2), TREE_OPERAND (ref, 3));
3936 break;
3937
3938 case ARRAY_RANGE_REF:
3939 result = build_nt (ARRAY_RANGE_REF,
3940 stabilize_reference (TREE_OPERAND (ref, 0)),
3941 stabilize_reference_1 (TREE_OPERAND (ref, 1)),
3942 TREE_OPERAND (ref, 2), TREE_OPERAND (ref, 3));
3943 break;
3944
3945 case COMPOUND_EXPR:
3946 /* We cannot wrap the first expression in a SAVE_EXPR, as then
3947 it wouldn't be ignored. This matters when dealing with
3948 volatiles. */
3949 return stabilize_reference_1 (ref);
3950
3951 /* If arg isn't a kind of lvalue we recognize, make no change.
3952 Caller should recognize the error for an invalid lvalue. */
3953 default:
3954 return ref;
3955
3956 case ERROR_MARK:
3957 return error_mark_node;
3958 }
3959
3960 TREE_TYPE (result) = TREE_TYPE (ref);
3961 TREE_READONLY (result) = TREE_READONLY (ref);
3962 TREE_SIDE_EFFECTS (result) = TREE_SIDE_EFFECTS (ref);
3963 TREE_THIS_VOLATILE (result) = TREE_THIS_VOLATILE (ref);
3964
3965 return result;
3966 }
3967
3968 /* Low-level constructors for expressions. */
3969
3970 /* A helper function for build1 and constant folders. Set TREE_CONSTANT,
3971 and TREE_SIDE_EFFECTS for an ADDR_EXPR. */
3972
3973 void
recompute_tree_invariant_for_addr_expr(tree t)3974 recompute_tree_invariant_for_addr_expr (tree t)
3975 {
3976 tree node;
3977 bool tc = true, se = false;
3978
3979 /* We started out assuming this address is both invariant and constant, but
3980 does not have side effects. Now go down any handled components and see if
3981 any of them involve offsets that are either non-constant or non-invariant.
3982 Also check for side-effects.
3983
3984 ??? Note that this code makes no attempt to deal with the case where
3985 taking the address of something causes a copy due to misalignment. */
3986
3987 #define UPDATE_FLAGS(NODE) \
3988 do { tree _node = (NODE); \
3989 if (_node && !TREE_CONSTANT (_node)) tc = false; \
3990 if (_node && TREE_SIDE_EFFECTS (_node)) se = true; } while (0)
3991
3992 for (node = TREE_OPERAND (t, 0); handled_component_p (node);
3993 node = TREE_OPERAND (node, 0))
3994 {
3995 /* If the first operand doesn't have an ARRAY_TYPE, this is a bogus
3996 array reference (probably made temporarily by the G++ front end),
3997 so ignore all the operands. */
3998 if ((TREE_CODE (node) == ARRAY_REF
3999 || TREE_CODE (node) == ARRAY_RANGE_REF)
4000 && TREE_CODE (TREE_TYPE (TREE_OPERAND (node, 0))) == ARRAY_TYPE)
4001 {
4002 UPDATE_FLAGS (TREE_OPERAND (node, 1));
4003 if (TREE_OPERAND (node, 2))
4004 UPDATE_FLAGS (TREE_OPERAND (node, 2));
4005 if (TREE_OPERAND (node, 3))
4006 UPDATE_FLAGS (TREE_OPERAND (node, 3));
4007 }
4008 /* Likewise, just because this is a COMPONENT_REF doesn't mean we have a
4009 FIELD_DECL, apparently. The G++ front end can put something else
4010 there, at least temporarily. */
4011 else if (TREE_CODE (node) == COMPONENT_REF
4012 && TREE_CODE (TREE_OPERAND (node, 1)) == FIELD_DECL)
4013 {
4014 if (TREE_OPERAND (node, 2))
4015 UPDATE_FLAGS (TREE_OPERAND (node, 2));
4016 }
4017 }
4018
4019 node = lang_hooks.expr_to_decl (node, &tc, &se);
4020
4021 /* Now see what's inside. If it's an INDIRECT_REF, copy our properties from
4022 the address, since &(*a)->b is a form of addition. If it's a constant, the
4023 address is constant too. If it's a decl, its address is constant if the
4024 decl is static. Everything else is not constant and, furthermore,
4025 taking the address of a volatile variable is not volatile. */
4026 if (TREE_CODE (node) == INDIRECT_REF
4027 || TREE_CODE (node) == MEM_REF)
4028 UPDATE_FLAGS (TREE_OPERAND (node, 0));
4029 else if (CONSTANT_CLASS_P (node))
4030 ;
4031 else if (DECL_P (node))
4032 tc &= (staticp (node) != NULL_TREE);
4033 else
4034 {
4035 tc = false;
4036 se |= TREE_SIDE_EFFECTS (node);
4037 }
4038
4039
4040 TREE_CONSTANT (t) = tc;
4041 TREE_SIDE_EFFECTS (t) = se;
4042 #undef UPDATE_FLAGS
4043 }
4044
4045 /* Build an expression of code CODE, data type TYPE, and operands as
4046 specified. Expressions and reference nodes can be created this way.
4047 Constants, decls, types and misc nodes cannot be.
4048
4049 We define 5 non-variadic functions, from 0 to 4 arguments. This is
4050 enough for all extant tree codes. */
4051
4052 tree
build0_stat(enum tree_code code,tree tt MEM_STAT_DECL)4053 build0_stat (enum tree_code code, tree tt MEM_STAT_DECL)
4054 {
4055 tree t;
4056
4057 gcc_assert (TREE_CODE_LENGTH (code) == 0);
4058
4059 t = make_node_stat (code PASS_MEM_STAT);
4060 TREE_TYPE (t) = tt;
4061
4062 return t;
4063 }
4064
4065 tree
build1_stat(enum tree_code code,tree type,tree node MEM_STAT_DECL)4066 build1_stat (enum tree_code code, tree type, tree node MEM_STAT_DECL)
4067 {
4068 int length = sizeof (struct tree_exp);
4069 tree t;
4070
4071 record_node_allocation_statistics (code, length);
4072
4073 gcc_assert (TREE_CODE_LENGTH (code) == 1);
4074
4075 t = ggc_alloc_tree_node_stat (length PASS_MEM_STAT);
4076
4077 memset (t, 0, sizeof (struct tree_common));
4078
4079 TREE_SET_CODE (t, code);
4080
4081 TREE_TYPE (t) = type;
4082 SET_EXPR_LOCATION (t, UNKNOWN_LOCATION);
4083 TREE_OPERAND (t, 0) = node;
4084 if (node && !TYPE_P (node))
4085 {
4086 TREE_SIDE_EFFECTS (t) = TREE_SIDE_EFFECTS (node);
4087 TREE_READONLY (t) = TREE_READONLY (node);
4088 }
4089
4090 if (TREE_CODE_CLASS (code) == tcc_statement)
4091 TREE_SIDE_EFFECTS (t) = 1;
4092 else switch (code)
4093 {
4094 case VA_ARG_EXPR:
4095 /* All of these have side-effects, no matter what their
4096 operands are. */
4097 TREE_SIDE_EFFECTS (t) = 1;
4098 TREE_READONLY (t) = 0;
4099 break;
4100
4101 case INDIRECT_REF:
4102 /* Whether a dereference is readonly has nothing to do with whether
4103 its operand is readonly. */
4104 TREE_READONLY (t) = 0;
4105 break;
4106
4107 case ADDR_EXPR:
4108 if (node)
4109 recompute_tree_invariant_for_addr_expr (t);
4110 break;
4111
4112 default:
4113 if ((TREE_CODE_CLASS (code) == tcc_unary || code == VIEW_CONVERT_EXPR)
4114 && node && !TYPE_P (node)
4115 && TREE_CONSTANT (node))
4116 TREE_CONSTANT (t) = 1;
4117 if (TREE_CODE_CLASS (code) == tcc_reference
4118 && node && TREE_THIS_VOLATILE (node))
4119 TREE_THIS_VOLATILE (t) = 1;
4120 break;
4121 }
4122
4123 return t;
4124 }
4125
4126 #define PROCESS_ARG(N) \
4127 do { \
4128 TREE_OPERAND (t, N) = arg##N; \
4129 if (arg##N &&!TYPE_P (arg##N)) \
4130 { \
4131 if (TREE_SIDE_EFFECTS (arg##N)) \
4132 side_effects = 1; \
4133 if (!TREE_READONLY (arg##N) \
4134 && !CONSTANT_CLASS_P (arg##N)) \
4135 (void) (read_only = 0); \
4136 if (!TREE_CONSTANT (arg##N)) \
4137 (void) (constant = 0); \
4138 } \
4139 } while (0)
4140
4141 tree
build2_stat(enum tree_code code,tree tt,tree arg0,tree arg1 MEM_STAT_DECL)4142 build2_stat (enum tree_code code, tree tt, tree arg0, tree arg1 MEM_STAT_DECL)
4143 {
4144 bool constant, read_only, side_effects;
4145 tree t;
4146
4147 gcc_assert (TREE_CODE_LENGTH (code) == 2);
4148
4149 if ((code == MINUS_EXPR || code == PLUS_EXPR || code == MULT_EXPR)
4150 && arg0 && arg1 && tt && POINTER_TYPE_P (tt)
4151 /* When sizetype precision doesn't match that of pointers
4152 we need to be able to build explicit extensions or truncations
4153 of the offset argument. */
4154 && TYPE_PRECISION (sizetype) == TYPE_PRECISION (tt))
4155 gcc_assert (TREE_CODE (arg0) == INTEGER_CST
4156 && TREE_CODE (arg1) == INTEGER_CST);
4157
4158 if (code == POINTER_PLUS_EXPR && arg0 && arg1 && tt)
4159 gcc_assert (POINTER_TYPE_P (tt) && POINTER_TYPE_P (TREE_TYPE (arg0))
4160 && ptrofftype_p (TREE_TYPE (arg1)));
4161
4162 t = make_node_stat (code PASS_MEM_STAT);
4163 TREE_TYPE (t) = tt;
4164
4165 /* Below, we automatically set TREE_SIDE_EFFECTS and TREE_READONLY for the
4166 result based on those same flags for the arguments. But if the
4167 arguments aren't really even `tree' expressions, we shouldn't be trying
4168 to do this. */
4169
4170 /* Expressions without side effects may be constant if their
4171 arguments are as well. */
4172 constant = (TREE_CODE_CLASS (code) == tcc_comparison
4173 || TREE_CODE_CLASS (code) == tcc_binary);
4174 read_only = 1;
4175 side_effects = TREE_SIDE_EFFECTS (t);
4176
4177 PROCESS_ARG (0);
4178 PROCESS_ARG (1);
4179
4180 TREE_READONLY (t) = read_only;
4181 TREE_CONSTANT (t) = constant;
4182 TREE_SIDE_EFFECTS (t) = side_effects;
4183 TREE_THIS_VOLATILE (t)
4184 = (TREE_CODE_CLASS (code) == tcc_reference
4185 && arg0 && TREE_THIS_VOLATILE (arg0));
4186
4187 return t;
4188 }
4189
4190
4191 tree
build3_stat(enum tree_code code,tree tt,tree arg0,tree arg1,tree arg2 MEM_STAT_DECL)4192 build3_stat (enum tree_code code, tree tt, tree arg0, tree arg1,
4193 tree arg2 MEM_STAT_DECL)
4194 {
4195 bool constant, read_only, side_effects;
4196 tree t;
4197
4198 gcc_assert (TREE_CODE_LENGTH (code) == 3);
4199 gcc_assert (TREE_CODE_CLASS (code) != tcc_vl_exp);
4200
4201 t = make_node_stat (code PASS_MEM_STAT);
4202 TREE_TYPE (t) = tt;
4203
4204 read_only = 1;
4205
4206 /* As a special exception, if COND_EXPR has NULL branches, we
4207 assume that it is a gimple statement and always consider
4208 it to have side effects. */
4209 if (code == COND_EXPR
4210 && tt == void_type_node
4211 && arg1 == NULL_TREE
4212 && arg2 == NULL_TREE)
4213 side_effects = true;
4214 else
4215 side_effects = TREE_SIDE_EFFECTS (t);
4216
4217 PROCESS_ARG (0);
4218 PROCESS_ARG (1);
4219 PROCESS_ARG (2);
4220
4221 if (code == COND_EXPR)
4222 TREE_READONLY (t) = read_only;
4223
4224 TREE_SIDE_EFFECTS (t) = side_effects;
4225 TREE_THIS_VOLATILE (t)
4226 = (TREE_CODE_CLASS (code) == tcc_reference
4227 && arg0 && TREE_THIS_VOLATILE (arg0));
4228
4229 return t;
4230 }
4231
4232 tree
build4_stat(enum tree_code code,tree tt,tree arg0,tree arg1,tree arg2,tree arg3 MEM_STAT_DECL)4233 build4_stat (enum tree_code code, tree tt, tree arg0, tree arg1,
4234 tree arg2, tree arg3 MEM_STAT_DECL)
4235 {
4236 bool constant, read_only, side_effects;
4237 tree t;
4238
4239 gcc_assert (TREE_CODE_LENGTH (code) == 4);
4240
4241 t = make_node_stat (code PASS_MEM_STAT);
4242 TREE_TYPE (t) = tt;
4243
4244 side_effects = TREE_SIDE_EFFECTS (t);
4245
4246 PROCESS_ARG (0);
4247 PROCESS_ARG (1);
4248 PROCESS_ARG (2);
4249 PROCESS_ARG (3);
4250
4251 TREE_SIDE_EFFECTS (t) = side_effects;
4252 TREE_THIS_VOLATILE (t)
4253 = (TREE_CODE_CLASS (code) == tcc_reference
4254 && arg0 && TREE_THIS_VOLATILE (arg0));
4255
4256 return t;
4257 }
4258
4259 tree
build5_stat(enum tree_code code,tree tt,tree arg0,tree arg1,tree arg2,tree arg3,tree arg4 MEM_STAT_DECL)4260 build5_stat (enum tree_code code, tree tt, tree arg0, tree arg1,
4261 tree arg2, tree arg3, tree arg4 MEM_STAT_DECL)
4262 {
4263 bool constant, read_only, side_effects;
4264 tree t;
4265
4266 gcc_assert (TREE_CODE_LENGTH (code) == 5);
4267
4268 t = make_node_stat (code PASS_MEM_STAT);
4269 TREE_TYPE (t) = tt;
4270
4271 side_effects = TREE_SIDE_EFFECTS (t);
4272
4273 PROCESS_ARG (0);
4274 PROCESS_ARG (1);
4275 PROCESS_ARG (2);
4276 PROCESS_ARG (3);
4277 PROCESS_ARG (4);
4278
4279 TREE_SIDE_EFFECTS (t) = side_effects;
4280 TREE_THIS_VOLATILE (t)
4281 = (TREE_CODE_CLASS (code) == tcc_reference
4282 && arg0 && TREE_THIS_VOLATILE (arg0));
4283
4284 return t;
4285 }
4286
4287 /* Build a simple MEM_REF tree with the sematics of a plain INDIRECT_REF
4288 on the pointer PTR. */
4289
4290 tree
build_simple_mem_ref_loc(location_t loc,tree ptr)4291 build_simple_mem_ref_loc (location_t loc, tree ptr)
4292 {
4293 HOST_WIDE_INT offset = 0;
4294 tree ptype = TREE_TYPE (ptr);
4295 tree tem;
4296 /* For convenience allow addresses that collapse to a simple base
4297 and offset. */
4298 if (TREE_CODE (ptr) == ADDR_EXPR
4299 && (handled_component_p (TREE_OPERAND (ptr, 0))
4300 || TREE_CODE (TREE_OPERAND (ptr, 0)) == MEM_REF))
4301 {
4302 ptr = get_addr_base_and_unit_offset (TREE_OPERAND (ptr, 0), &offset);
4303 gcc_assert (ptr);
4304 ptr = build_fold_addr_expr (ptr);
4305 gcc_assert (is_gimple_reg (ptr) || is_gimple_min_invariant (ptr));
4306 }
4307 tem = build2 (MEM_REF, TREE_TYPE (ptype),
4308 ptr, build_int_cst (ptype, offset));
4309 SET_EXPR_LOCATION (tem, loc);
4310 return tem;
4311 }
4312
4313 /* Return the constant offset of a MEM_REF or TARGET_MEM_REF tree T. */
4314
4315 double_int
mem_ref_offset(const_tree t)4316 mem_ref_offset (const_tree t)
4317 {
4318 tree toff = TREE_OPERAND (t, 1);
4319 return tree_to_double_int (toff).sext (TYPE_PRECISION (TREE_TYPE (toff)));
4320 }
4321
4322 /* Return an invariant ADDR_EXPR of type TYPE taking the address of BASE
4323 offsetted by OFFSET units. */
4324
4325 tree
build_invariant_address(tree type,tree base,HOST_WIDE_INT offset)4326 build_invariant_address (tree type, tree base, HOST_WIDE_INT offset)
4327 {
4328 tree ref = fold_build2 (MEM_REF, TREE_TYPE (type),
4329 build_fold_addr_expr (base),
4330 build_int_cst (ptr_type_node, offset));
4331 tree addr = build1 (ADDR_EXPR, type, ref);
4332 recompute_tree_invariant_for_addr_expr (addr);
4333 return addr;
4334 }
4335
4336 /* Similar except don't specify the TREE_TYPE
4337 and leave the TREE_SIDE_EFFECTS as 0.
4338 It is permissible for arguments to be null,
4339 or even garbage if their values do not matter. */
4340
4341 tree
build_nt(enum tree_code code,...)4342 build_nt (enum tree_code code, ...)
4343 {
4344 tree t;
4345 int length;
4346 int i;
4347 va_list p;
4348
4349 gcc_assert (TREE_CODE_CLASS (code) != tcc_vl_exp);
4350
4351 va_start (p, code);
4352
4353 t = make_node (code);
4354 length = TREE_CODE_LENGTH (code);
4355
4356 for (i = 0; i < length; i++)
4357 TREE_OPERAND (t, i) = va_arg (p, tree);
4358
4359 va_end (p);
4360 return t;
4361 }
4362
4363 /* Similar to build_nt, but for creating a CALL_EXPR object with a
4364 tree vec. */
4365
4366 tree
build_nt_call_vec(tree fn,vec<tree,va_gc> * args)4367 build_nt_call_vec (tree fn, vec<tree, va_gc> *args)
4368 {
4369 tree ret, t;
4370 unsigned int ix;
4371
4372 ret = build_vl_exp (CALL_EXPR, vec_safe_length (args) + 3);
4373 CALL_EXPR_FN (ret) = fn;
4374 CALL_EXPR_STATIC_CHAIN (ret) = NULL_TREE;
4375 FOR_EACH_VEC_SAFE_ELT (args, ix, t)
4376 CALL_EXPR_ARG (ret, ix) = t;
4377 return ret;
4378 }
4379
4380 /* Create a DECL_... node of code CODE, name NAME and data type TYPE.
4381 We do NOT enter this node in any sort of symbol table.
4382
4383 LOC is the location of the decl.
4384
4385 layout_decl is used to set up the decl's storage layout.
4386 Other slots are initialized to 0 or null pointers. */
4387
4388 tree
build_decl_stat(location_t loc,enum tree_code code,tree name,tree type MEM_STAT_DECL)4389 build_decl_stat (location_t loc, enum tree_code code, tree name,
4390 tree type MEM_STAT_DECL)
4391 {
4392 tree t;
4393
4394 t = make_node_stat (code PASS_MEM_STAT);
4395 DECL_SOURCE_LOCATION (t) = loc;
4396
4397 /* if (type == error_mark_node)
4398 type = integer_type_node; */
4399 /* That is not done, deliberately, so that having error_mark_node
4400 as the type can suppress useless errors in the use of this variable. */
4401
4402 DECL_NAME (t) = name;
4403 TREE_TYPE (t) = type;
4404
4405 if (code == VAR_DECL || code == PARM_DECL || code == RESULT_DECL)
4406 layout_decl (t, 0);
4407
4408 return t;
4409 }
4410
4411 /* Builds and returns function declaration with NAME and TYPE. */
4412
4413 tree
build_fn_decl(const char * name,tree type)4414 build_fn_decl (const char *name, tree type)
4415 {
4416 tree id = get_identifier (name);
4417 tree decl = build_decl (input_location, FUNCTION_DECL, id, type);
4418
4419 DECL_EXTERNAL (decl) = 1;
4420 TREE_PUBLIC (decl) = 1;
4421 DECL_ARTIFICIAL (decl) = 1;
4422 TREE_NOTHROW (decl) = 1;
4423
4424 return decl;
4425 }
4426
4427 vec<tree, va_gc> *all_translation_units;
4428
4429 /* Builds a new translation-unit decl with name NAME, queues it in the
4430 global list of translation-unit decls and returns it. */
4431
4432 tree
build_translation_unit_decl(tree name)4433 build_translation_unit_decl (tree name)
4434 {
4435 tree tu = build_decl (UNKNOWN_LOCATION, TRANSLATION_UNIT_DECL,
4436 name, NULL_TREE);
4437 TRANSLATION_UNIT_LANGUAGE (tu) = lang_hooks.name;
4438 vec_safe_push (all_translation_units, tu);
4439 return tu;
4440 }
4441
4442
4443 /* BLOCK nodes are used to represent the structure of binding contours
4444 and declarations, once those contours have been exited and their contents
4445 compiled. This information is used for outputting debugging info. */
4446
4447 tree
build_block(tree vars,tree subblocks,tree supercontext,tree chain)4448 build_block (tree vars, tree subblocks, tree supercontext, tree chain)
4449 {
4450 tree block = make_node (BLOCK);
4451
4452 BLOCK_VARS (block) = vars;
4453 BLOCK_SUBBLOCKS (block) = subblocks;
4454 BLOCK_SUPERCONTEXT (block) = supercontext;
4455 BLOCK_CHAIN (block) = chain;
4456 return block;
4457 }
4458
4459
4460 /* Like SET_EXPR_LOCATION, but make sure the tree can have a location.
4461
4462 LOC is the location to use in tree T. */
4463
4464 void
protected_set_expr_location(tree t,location_t loc)4465 protected_set_expr_location (tree t, location_t loc)
4466 {
4467 if (t && CAN_HAVE_LOCATION_P (t))
4468 SET_EXPR_LOCATION (t, loc);
4469 }
4470
4471 /* Return a declaration like DDECL except that its DECL_ATTRIBUTES
4472 is ATTRIBUTE. */
4473
4474 tree
build_decl_attribute_variant(tree ddecl,tree attribute)4475 build_decl_attribute_variant (tree ddecl, tree attribute)
4476 {
4477 DECL_ATTRIBUTES (ddecl) = attribute;
4478 return ddecl;
4479 }
4480
4481 /* Borrowed from hashtab.c iterative_hash implementation. */
4482 #define mix(a,b,c) \
4483 { \
4484 a -= b; a -= c; a ^= (c>>13); \
4485 b -= c; b -= a; b ^= (a<< 8); \
4486 c -= a; c -= b; c ^= ((b&0xffffffff)>>13); \
4487 a -= b; a -= c; a ^= ((c&0xffffffff)>>12); \
4488 b -= c; b -= a; b = (b ^ (a<<16)) & 0xffffffff; \
4489 c -= a; c -= b; c = (c ^ (b>> 5)) & 0xffffffff; \
4490 a -= b; a -= c; a = (a ^ (c>> 3)) & 0xffffffff; \
4491 b -= c; b -= a; b = (b ^ (a<<10)) & 0xffffffff; \
4492 c -= a; c -= b; c = (c ^ (b>>15)) & 0xffffffff; \
4493 }
4494
4495
4496 /* Produce good hash value combining VAL and VAL2. */
4497 hashval_t
iterative_hash_hashval_t(hashval_t val,hashval_t val2)4498 iterative_hash_hashval_t (hashval_t val, hashval_t val2)
4499 {
4500 /* the golden ratio; an arbitrary value. */
4501 hashval_t a = 0x9e3779b9;
4502
4503 mix (a, val, val2);
4504 return val2;
4505 }
4506
4507 /* Produce good hash value combining VAL and VAL2. */
4508 hashval_t
iterative_hash_host_wide_int(HOST_WIDE_INT val,hashval_t val2)4509 iterative_hash_host_wide_int (HOST_WIDE_INT val, hashval_t val2)
4510 {
4511 if (sizeof (HOST_WIDE_INT) == sizeof (hashval_t))
4512 return iterative_hash_hashval_t (val, val2);
4513 else
4514 {
4515 hashval_t a = (hashval_t) val;
4516 /* Avoid warnings about shifting of more than the width of the type on
4517 hosts that won't execute this path. */
4518 int zero = 0;
4519 hashval_t b = (hashval_t) (val >> (sizeof (hashval_t) * 8 + zero));
4520 mix (a, b, val2);
4521 if (sizeof (HOST_WIDE_INT) > 2 * sizeof (hashval_t))
4522 {
4523 hashval_t a = (hashval_t) (val >> (sizeof (hashval_t) * 16 + zero));
4524 hashval_t b = (hashval_t) (val >> (sizeof (hashval_t) * 24 + zero));
4525 mix (a, b, val2);
4526 }
4527 return val2;
4528 }
4529 }
4530
4531 /* Return a type like TTYPE except that its TYPE_ATTRIBUTE
4532 is ATTRIBUTE and its qualifiers are QUALS.
4533
4534 Record such modified types already made so we don't make duplicates. */
4535
4536 tree
build_type_attribute_qual_variant(tree ttype,tree attribute,int quals)4537 build_type_attribute_qual_variant (tree ttype, tree attribute, int quals)
4538 {
4539 if (! attribute_list_equal (TYPE_ATTRIBUTES (ttype), attribute))
4540 {
4541 hashval_t hashcode = 0;
4542 tree ntype;
4543 enum tree_code code = TREE_CODE (ttype);
4544
4545 /* Building a distinct copy of a tagged type is inappropriate; it
4546 causes breakage in code that expects there to be a one-to-one
4547 relationship between a struct and its fields.
4548 build_duplicate_type is another solution (as used in
4549 handle_transparent_union_attribute), but that doesn't play well
4550 with the stronger C++ type identity model. */
4551 if (TREE_CODE (ttype) == RECORD_TYPE
4552 || TREE_CODE (ttype) == UNION_TYPE
4553 || TREE_CODE (ttype) == QUAL_UNION_TYPE
4554 || TREE_CODE (ttype) == ENUMERAL_TYPE)
4555 {
4556 warning (OPT_Wattributes,
4557 "ignoring attributes applied to %qT after definition",
4558 TYPE_MAIN_VARIANT (ttype));
4559 return build_qualified_type (ttype, quals);
4560 }
4561
4562 ttype = build_qualified_type (ttype, TYPE_UNQUALIFIED);
4563 ntype = build_distinct_type_copy (ttype);
4564
4565 TYPE_ATTRIBUTES (ntype) = attribute;
4566
4567 hashcode = iterative_hash_object (code, hashcode);
4568 if (TREE_TYPE (ntype))
4569 hashcode = iterative_hash_object (TYPE_HASH (TREE_TYPE (ntype)),
4570 hashcode);
4571 hashcode = attribute_hash_list (attribute, hashcode);
4572
4573 switch (TREE_CODE (ntype))
4574 {
4575 case FUNCTION_TYPE:
4576 hashcode = type_hash_list (TYPE_ARG_TYPES (ntype), hashcode);
4577 break;
4578 case ARRAY_TYPE:
4579 if (TYPE_DOMAIN (ntype))
4580 hashcode = iterative_hash_object (TYPE_HASH (TYPE_DOMAIN (ntype)),
4581 hashcode);
4582 break;
4583 case INTEGER_TYPE:
4584 hashcode = iterative_hash_object
4585 (TREE_INT_CST_LOW (TYPE_MAX_VALUE (ntype)), hashcode);
4586 hashcode = iterative_hash_object
4587 (TREE_INT_CST_HIGH (TYPE_MAX_VALUE (ntype)), hashcode);
4588 break;
4589 case REAL_TYPE:
4590 case FIXED_POINT_TYPE:
4591 {
4592 unsigned int precision = TYPE_PRECISION (ntype);
4593 hashcode = iterative_hash_object (precision, hashcode);
4594 }
4595 break;
4596 default:
4597 break;
4598 }
4599
4600 ntype = type_hash_canon (hashcode, ntype);
4601
4602 /* If the target-dependent attributes make NTYPE different from
4603 its canonical type, we will need to use structural equality
4604 checks for this type. */
4605 if (TYPE_STRUCTURAL_EQUALITY_P (ttype)
4606 || !comp_type_attributes (ntype, ttype))
4607 SET_TYPE_STRUCTURAL_EQUALITY (ntype);
4608 else if (TYPE_CANONICAL (ntype) == ntype)
4609 TYPE_CANONICAL (ntype) = TYPE_CANONICAL (ttype);
4610
4611 ttype = build_qualified_type (ntype, quals);
4612 }
4613 else if (TYPE_QUALS (ttype) != quals)
4614 ttype = build_qualified_type (ttype, quals);
4615
4616 return ttype;
4617 }
4618
4619 /* Check if "omp declare simd" attribute arguments, CLAUSES1 and CLAUSES2, are
4620 the same. */
4621
4622 static bool
omp_declare_simd_clauses_equal(tree clauses1,tree clauses2)4623 omp_declare_simd_clauses_equal (tree clauses1, tree clauses2)
4624 {
4625 tree cl1, cl2;
4626 for (cl1 = clauses1, cl2 = clauses2;
4627 cl1 && cl2;
4628 cl1 = OMP_CLAUSE_CHAIN (cl1), cl2 = OMP_CLAUSE_CHAIN (cl2))
4629 {
4630 if (OMP_CLAUSE_CODE (cl1) != OMP_CLAUSE_CODE (cl2))
4631 return false;
4632 if (OMP_CLAUSE_CODE (cl1) != OMP_CLAUSE_SIMDLEN)
4633 {
4634 if (simple_cst_equal (OMP_CLAUSE_DECL (cl1),
4635 OMP_CLAUSE_DECL (cl2)) != 1)
4636 return false;
4637 }
4638 switch (OMP_CLAUSE_CODE (cl1))
4639 {
4640 case OMP_CLAUSE_ALIGNED:
4641 if (simple_cst_equal (OMP_CLAUSE_ALIGNED_ALIGNMENT (cl1),
4642 OMP_CLAUSE_ALIGNED_ALIGNMENT (cl2)) != 1)
4643 return false;
4644 break;
4645 case OMP_CLAUSE_LINEAR:
4646 if (simple_cst_equal (OMP_CLAUSE_LINEAR_STEP (cl1),
4647 OMP_CLAUSE_LINEAR_STEP (cl2)) != 1)
4648 return false;
4649 break;
4650 case OMP_CLAUSE_SIMDLEN:
4651 if (simple_cst_equal (OMP_CLAUSE_SIMDLEN_EXPR (cl1),
4652 OMP_CLAUSE_SIMDLEN_EXPR (cl2)) != 1)
4653 return false;
4654 default:
4655 break;
4656 }
4657 }
4658 return true;
4659 }
4660
4661 /* Compare two constructor-element-type constants. Return 1 if the lists
4662 are known to be equal; otherwise return 0. */
4663
4664 static bool
simple_cst_list_equal(const_tree l1,const_tree l2)4665 simple_cst_list_equal (const_tree l1, const_tree l2)
4666 {
4667 while (l1 != NULL_TREE && l2 != NULL_TREE)
4668 {
4669 if (simple_cst_equal (TREE_VALUE (l1), TREE_VALUE (l2)) != 1)
4670 return false;
4671
4672 l1 = TREE_CHAIN (l1);
4673 l2 = TREE_CHAIN (l2);
4674 }
4675
4676 return l1 == l2;
4677 }
4678
4679 /* Compare two attributes for their value identity. Return true if the
4680 attribute values are known to be equal; otherwise return false.
4681 */
4682
4683 static bool
attribute_value_equal(const_tree attr1,const_tree attr2)4684 attribute_value_equal (const_tree attr1, const_tree attr2)
4685 {
4686 if (TREE_VALUE (attr1) == TREE_VALUE (attr2))
4687 return true;
4688
4689 if (TREE_VALUE (attr1) != NULL_TREE
4690 && TREE_CODE (TREE_VALUE (attr1)) == TREE_LIST
4691 && TREE_VALUE (attr2) != NULL
4692 && TREE_CODE (TREE_VALUE (attr2)) == TREE_LIST)
4693 return (simple_cst_list_equal (TREE_VALUE (attr1),
4694 TREE_VALUE (attr2)) == 1);
4695
4696 if ((flag_openmp || flag_openmp_simd)
4697 && TREE_VALUE (attr1) && TREE_VALUE (attr2)
4698 && TREE_CODE (TREE_VALUE (attr1)) == OMP_CLAUSE
4699 && TREE_CODE (TREE_VALUE (attr2)) == OMP_CLAUSE)
4700 return omp_declare_simd_clauses_equal (TREE_VALUE (attr1),
4701 TREE_VALUE (attr2));
4702
4703 return (simple_cst_equal (TREE_VALUE (attr1), TREE_VALUE (attr2)) == 1);
4704 }
4705
4706 /* Return 0 if the attributes for two types are incompatible, 1 if they
4707 are compatible, and 2 if they are nearly compatible (which causes a
4708 warning to be generated). */
4709 int
comp_type_attributes(const_tree type1,const_tree type2)4710 comp_type_attributes (const_tree type1, const_tree type2)
4711 {
4712 const_tree a1 = TYPE_ATTRIBUTES (type1);
4713 const_tree a2 = TYPE_ATTRIBUTES (type2);
4714 const_tree a;
4715
4716 if (a1 == a2)
4717 return 1;
4718 for (a = a1; a != NULL_TREE; a = TREE_CHAIN (a))
4719 {
4720 const struct attribute_spec *as;
4721 const_tree attr;
4722
4723 as = lookup_attribute_spec (get_attribute_name (a));
4724 if (!as || as->affects_type_identity == false)
4725 continue;
4726
4727 attr = lookup_attribute (as->name, CONST_CAST_TREE (a2));
4728 if (!attr || !attribute_value_equal (a, attr))
4729 break;
4730 }
4731 if (!a)
4732 {
4733 for (a = a2; a != NULL_TREE; a = TREE_CHAIN (a))
4734 {
4735 const struct attribute_spec *as;
4736
4737 as = lookup_attribute_spec (get_attribute_name (a));
4738 if (!as || as->affects_type_identity == false)
4739 continue;
4740
4741 if (!lookup_attribute (as->name, CONST_CAST_TREE (a1)))
4742 break;
4743 /* We don't need to compare trees again, as we did this
4744 already in first loop. */
4745 }
4746 /* All types - affecting identity - are equal, so
4747 there is no need to call target hook for comparison. */
4748 if (!a)
4749 return 1;
4750 }
4751 /* As some type combinations - like default calling-convention - might
4752 be compatible, we have to call the target hook to get the final result. */
4753 return targetm.comp_type_attributes (type1, type2);
4754 }
4755
4756 /* Return a type like TTYPE except that its TYPE_ATTRIBUTE
4757 is ATTRIBUTE.
4758
4759 Record such modified types already made so we don't make duplicates. */
4760
4761 tree
build_type_attribute_variant(tree ttype,tree attribute)4762 build_type_attribute_variant (tree ttype, tree attribute)
4763 {
4764 return build_type_attribute_qual_variant (ttype, attribute,
4765 TYPE_QUALS (ttype));
4766 }
4767
4768
4769 /* Reset the expression *EXPR_P, a size or position.
4770
4771 ??? We could reset all non-constant sizes or positions. But it's cheap
4772 enough to not do so and refrain from adding workarounds to dwarf2out.c.
4773
4774 We need to reset self-referential sizes or positions because they cannot
4775 be gimplified and thus can contain a CALL_EXPR after the gimplification
4776 is finished, which will run afoul of LTO streaming. And they need to be
4777 reset to something essentially dummy but not constant, so as to preserve
4778 the properties of the object they are attached to. */
4779
4780 static inline void
free_lang_data_in_one_sizepos(tree * expr_p)4781 free_lang_data_in_one_sizepos (tree *expr_p)
4782 {
4783 tree expr = *expr_p;
4784 if (CONTAINS_PLACEHOLDER_P (expr))
4785 *expr_p = build0 (PLACEHOLDER_EXPR, TREE_TYPE (expr));
4786 }
4787
4788
4789 /* Reset all the fields in a binfo node BINFO. We only keep
4790 BINFO_VTABLE, which is used by gimple_fold_obj_type_ref. */
4791
4792 static void
free_lang_data_in_binfo(tree binfo)4793 free_lang_data_in_binfo (tree binfo)
4794 {
4795 unsigned i;
4796 tree t;
4797
4798 gcc_assert (TREE_CODE (binfo) == TREE_BINFO);
4799
4800 BINFO_VIRTUALS (binfo) = NULL_TREE;
4801 BINFO_BASE_ACCESSES (binfo) = NULL;
4802 BINFO_INHERITANCE_CHAIN (binfo) = NULL_TREE;
4803 BINFO_SUBVTT_INDEX (binfo) = NULL_TREE;
4804
4805 FOR_EACH_VEC_ELT (*BINFO_BASE_BINFOS (binfo), i, t)
4806 free_lang_data_in_binfo (t);
4807 }
4808
4809
4810 /* Reset all language specific information still present in TYPE. */
4811
4812 static void
free_lang_data_in_type(tree type)4813 free_lang_data_in_type (tree type)
4814 {
4815 gcc_assert (TYPE_P (type));
4816
4817 /* Give the FE a chance to remove its own data first. */
4818 lang_hooks.free_lang_data (type);
4819
4820 TREE_LANG_FLAG_0 (type) = 0;
4821 TREE_LANG_FLAG_1 (type) = 0;
4822 TREE_LANG_FLAG_2 (type) = 0;
4823 TREE_LANG_FLAG_3 (type) = 0;
4824 TREE_LANG_FLAG_4 (type) = 0;
4825 TREE_LANG_FLAG_5 (type) = 0;
4826 TREE_LANG_FLAG_6 (type) = 0;
4827
4828 if (TREE_CODE (type) == FUNCTION_TYPE)
4829 {
4830 /* Remove the const and volatile qualifiers from arguments. The
4831 C++ front end removes them, but the C front end does not,
4832 leading to false ODR violation errors when merging two
4833 instances of the same function signature compiled by
4834 different front ends. */
4835 tree p;
4836
4837 for (p = TYPE_ARG_TYPES (type); p; p = TREE_CHAIN (p))
4838 {
4839 tree arg_type = TREE_VALUE (p);
4840
4841 if (TYPE_READONLY (arg_type) || TYPE_VOLATILE (arg_type))
4842 {
4843 int quals = TYPE_QUALS (arg_type)
4844 & ~TYPE_QUAL_CONST
4845 & ~TYPE_QUAL_VOLATILE;
4846 TREE_VALUE (p) = build_qualified_type (arg_type, quals);
4847 free_lang_data_in_type (TREE_VALUE (p));
4848 }
4849 }
4850 }
4851
4852 /* Remove members that are not actually FIELD_DECLs from the field
4853 list of an aggregate. These occur in C++. */
4854 if (RECORD_OR_UNION_TYPE_P (type))
4855 {
4856 tree prev, member;
4857
4858 /* Note that TYPE_FIELDS can be shared across distinct
4859 TREE_TYPEs. Therefore, if the first field of TYPE_FIELDS is
4860 to be removed, we cannot set its TREE_CHAIN to NULL.
4861 Otherwise, we would not be able to find all the other fields
4862 in the other instances of this TREE_TYPE.
4863
4864 This was causing an ICE in testsuite/g++.dg/lto/20080915.C. */
4865 prev = NULL_TREE;
4866 member = TYPE_FIELDS (type);
4867 while (member)
4868 {
4869 if (TREE_CODE (member) == FIELD_DECL
4870 || TREE_CODE (member) == TYPE_DECL)
4871 {
4872 if (prev)
4873 TREE_CHAIN (prev) = member;
4874 else
4875 TYPE_FIELDS (type) = member;
4876 prev = member;
4877 }
4878
4879 member = TREE_CHAIN (member);
4880 }
4881
4882 if (prev)
4883 TREE_CHAIN (prev) = NULL_TREE;
4884 else
4885 TYPE_FIELDS (type) = NULL_TREE;
4886
4887 TYPE_METHODS (type) = NULL_TREE;
4888 if (TYPE_BINFO (type))
4889 free_lang_data_in_binfo (TYPE_BINFO (type));
4890 }
4891 else
4892 {
4893 /* For non-aggregate types, clear out the language slot (which
4894 overloads TYPE_BINFO). */
4895 TYPE_LANG_SLOT_1 (type) = NULL_TREE;
4896
4897 if (INTEGRAL_TYPE_P (type)
4898 || SCALAR_FLOAT_TYPE_P (type)
4899 || FIXED_POINT_TYPE_P (type))
4900 {
4901 free_lang_data_in_one_sizepos (&TYPE_MIN_VALUE (type));
4902 free_lang_data_in_one_sizepos (&TYPE_MAX_VALUE (type));
4903 }
4904 }
4905
4906 free_lang_data_in_one_sizepos (&TYPE_SIZE (type));
4907 free_lang_data_in_one_sizepos (&TYPE_SIZE_UNIT (type));
4908
4909 if (TYPE_CONTEXT (type)
4910 && TREE_CODE (TYPE_CONTEXT (type)) == BLOCK)
4911 {
4912 tree ctx = TYPE_CONTEXT (type);
4913 do
4914 {
4915 ctx = BLOCK_SUPERCONTEXT (ctx);
4916 }
4917 while (ctx && TREE_CODE (ctx) == BLOCK);
4918 TYPE_CONTEXT (type) = ctx;
4919 }
4920 }
4921
4922
4923 /* Return true if DECL may need an assembler name to be set. */
4924
4925 static inline bool
need_assembler_name_p(tree decl)4926 need_assembler_name_p (tree decl)
4927 {
4928 /* Only FUNCTION_DECLs and VAR_DECLs are considered. */
4929 if (TREE_CODE (decl) != FUNCTION_DECL
4930 && TREE_CODE (decl) != VAR_DECL)
4931 return false;
4932
4933 /* If DECL already has its assembler name set, it does not need a
4934 new one. */
4935 if (!HAS_DECL_ASSEMBLER_NAME_P (decl)
4936 || DECL_ASSEMBLER_NAME_SET_P (decl))
4937 return false;
4938
4939 /* Abstract decls do not need an assembler name. */
4940 if (DECL_ABSTRACT (decl))
4941 return false;
4942
4943 /* For VAR_DECLs, only static, public and external symbols need an
4944 assembler name. */
4945 if (TREE_CODE (decl) == VAR_DECL
4946 && !TREE_STATIC (decl)
4947 && !TREE_PUBLIC (decl)
4948 && !DECL_EXTERNAL (decl))
4949 return false;
4950
4951 if (TREE_CODE (decl) == FUNCTION_DECL)
4952 {
4953 /* Do not set assembler name on builtins. Allow RTL expansion to
4954 decide whether to expand inline or via a regular call. */
4955 if (DECL_BUILT_IN (decl)
4956 && DECL_BUILT_IN_CLASS (decl) != BUILT_IN_FRONTEND)
4957 return false;
4958
4959 /* Functions represented in the callgraph need an assembler name. */
4960 if (cgraph_get_node (decl) != NULL)
4961 return true;
4962
4963 /* Unused and not public functions don't need an assembler name. */
4964 if (!TREE_USED (decl) && !TREE_PUBLIC (decl))
4965 return false;
4966 }
4967
4968 return true;
4969 }
4970
4971
4972 /* Reset all language specific information still present in symbol
4973 DECL. */
4974
4975 static void
free_lang_data_in_decl(tree decl)4976 free_lang_data_in_decl (tree decl)
4977 {
4978 gcc_assert (DECL_P (decl));
4979
4980 /* Give the FE a chance to remove its own data first. */
4981 lang_hooks.free_lang_data (decl);
4982
4983 TREE_LANG_FLAG_0 (decl) = 0;
4984 TREE_LANG_FLAG_1 (decl) = 0;
4985 TREE_LANG_FLAG_2 (decl) = 0;
4986 TREE_LANG_FLAG_3 (decl) = 0;
4987 TREE_LANG_FLAG_4 (decl) = 0;
4988 TREE_LANG_FLAG_5 (decl) = 0;
4989 TREE_LANG_FLAG_6 (decl) = 0;
4990
4991 free_lang_data_in_one_sizepos (&DECL_SIZE (decl));
4992 free_lang_data_in_one_sizepos (&DECL_SIZE_UNIT (decl));
4993 if (TREE_CODE (decl) == FIELD_DECL)
4994 {
4995 free_lang_data_in_one_sizepos (&DECL_FIELD_OFFSET (decl));
4996 if (TREE_CODE (DECL_CONTEXT (decl)) == QUAL_UNION_TYPE)
4997 DECL_QUALIFIER (decl) = NULL_TREE;
4998 }
4999
5000 if (TREE_CODE (decl) == FUNCTION_DECL)
5001 {
5002 struct cgraph_node *node;
5003 if (!(node = cgraph_get_node (decl))
5004 || (!node->definition && !node->clones))
5005 {
5006 if (node)
5007 cgraph_release_function_body (node);
5008 else
5009 {
5010 release_function_body (decl);
5011 DECL_ARGUMENTS (decl) = NULL;
5012 DECL_RESULT (decl) = NULL;
5013 DECL_INITIAL (decl) = error_mark_node;
5014 }
5015 }
5016 if (gimple_has_body_p (decl))
5017 {
5018 tree t;
5019
5020 /* If DECL has a gimple body, then the context for its
5021 arguments must be DECL. Otherwise, it doesn't really
5022 matter, as we will not be emitting any code for DECL. In
5023 general, there may be other instances of DECL created by
5024 the front end and since PARM_DECLs are generally shared,
5025 their DECL_CONTEXT changes as the replicas of DECL are
5026 created. The only time where DECL_CONTEXT is important
5027 is for the FUNCTION_DECLs that have a gimple body (since
5028 the PARM_DECL will be used in the function's body). */
5029 for (t = DECL_ARGUMENTS (decl); t; t = TREE_CHAIN (t))
5030 DECL_CONTEXT (t) = decl;
5031 }
5032
5033 /* DECL_SAVED_TREE holds the GENERIC representation for DECL.
5034 At this point, it is not needed anymore. */
5035 DECL_SAVED_TREE (decl) = NULL_TREE;
5036
5037 /* Clear the abstract origin if it refers to a method. Otherwise
5038 dwarf2out.c will ICE as we clear TYPE_METHODS and thus the
5039 origin will not be output correctly. */
5040 if (DECL_ABSTRACT_ORIGIN (decl)
5041 && DECL_CONTEXT (DECL_ABSTRACT_ORIGIN (decl))
5042 && RECORD_OR_UNION_TYPE_P
5043 (DECL_CONTEXT (DECL_ABSTRACT_ORIGIN (decl))))
5044 DECL_ABSTRACT_ORIGIN (decl) = NULL_TREE;
5045
5046 /* Sometimes the C++ frontend doesn't manage to transform a temporary
5047 DECL_VINDEX referring to itself into a vtable slot number as it
5048 should. Happens with functions that are copied and then forgotten
5049 about. Just clear it, it won't matter anymore. */
5050 if (DECL_VINDEX (decl) && !tree_fits_shwi_p (DECL_VINDEX (decl)))
5051 DECL_VINDEX (decl) = NULL_TREE;
5052 }
5053 else if (TREE_CODE (decl) == VAR_DECL)
5054 {
5055 if ((DECL_EXTERNAL (decl)
5056 && (!TREE_STATIC (decl) || !TREE_READONLY (decl)))
5057 || (decl_function_context (decl) && !TREE_STATIC (decl)))
5058 DECL_INITIAL (decl) = NULL_TREE;
5059 }
5060 else if (TREE_CODE (decl) == TYPE_DECL
5061 || TREE_CODE (decl) == FIELD_DECL)
5062 DECL_INITIAL (decl) = NULL_TREE;
5063 else if (TREE_CODE (decl) == TRANSLATION_UNIT_DECL
5064 && DECL_INITIAL (decl)
5065 && TREE_CODE (DECL_INITIAL (decl)) == BLOCK)
5066 {
5067 /* Strip builtins from the translation-unit BLOCK. We still have targets
5068 without builtin_decl_explicit support and also builtins are shared
5069 nodes and thus we can't use TREE_CHAIN in multiple lists. */
5070 tree *nextp = &BLOCK_VARS (DECL_INITIAL (decl));
5071 while (*nextp)
5072 {
5073 tree var = *nextp;
5074 if (TREE_CODE (var) == FUNCTION_DECL
5075 && DECL_BUILT_IN (var))
5076 *nextp = TREE_CHAIN (var);
5077 else
5078 nextp = &TREE_CHAIN (var);
5079 }
5080 }
5081 }
5082
5083
5084 /* Data used when collecting DECLs and TYPEs for language data removal. */
5085
5086 struct free_lang_data_d
5087 {
5088 /* Worklist to avoid excessive recursion. */
5089 vec<tree> worklist;
5090
5091 /* Set of traversed objects. Used to avoid duplicate visits. */
5092 struct pointer_set_t *pset;
5093
5094 /* Array of symbols to process with free_lang_data_in_decl. */
5095 vec<tree> decls;
5096
5097 /* Array of types to process with free_lang_data_in_type. */
5098 vec<tree> types;
5099 };
5100
5101
5102 /* Save all language fields needed to generate proper debug information
5103 for DECL. This saves most fields cleared out by free_lang_data_in_decl. */
5104
5105 static void
save_debug_info_for_decl(tree t)5106 save_debug_info_for_decl (tree t)
5107 {
5108 /*struct saved_debug_info_d *sdi;*/
5109
5110 gcc_assert (debug_info_level > DINFO_LEVEL_TERSE && t && DECL_P (t));
5111
5112 /* FIXME. Partial implementation for saving debug info removed. */
5113 }
5114
5115
5116 /* Save all language fields needed to generate proper debug information
5117 for TYPE. This saves most fields cleared out by free_lang_data_in_type. */
5118
5119 static void
save_debug_info_for_type(tree t)5120 save_debug_info_for_type (tree t)
5121 {
5122 /*struct saved_debug_info_d *sdi;*/
5123
5124 gcc_assert (debug_info_level > DINFO_LEVEL_TERSE && t && TYPE_P (t));
5125
5126 /* FIXME. Partial implementation for saving debug info removed. */
5127 }
5128
5129
5130 /* Add type or decl T to one of the list of tree nodes that need their
5131 language data removed. The lists are held inside FLD. */
5132
5133 static void
add_tree_to_fld_list(tree t,struct free_lang_data_d * fld)5134 add_tree_to_fld_list (tree t, struct free_lang_data_d *fld)
5135 {
5136 if (DECL_P (t))
5137 {
5138 fld->decls.safe_push (t);
5139 if (debug_info_level > DINFO_LEVEL_TERSE)
5140 save_debug_info_for_decl (t);
5141 }
5142 else if (TYPE_P (t))
5143 {
5144 fld->types.safe_push (t);
5145 if (debug_info_level > DINFO_LEVEL_TERSE)
5146 save_debug_info_for_type (t);
5147 }
5148 else
5149 gcc_unreachable ();
5150 }
5151
5152 /* Push tree node T into FLD->WORKLIST. */
5153
5154 static inline void
fld_worklist_push(tree t,struct free_lang_data_d * fld)5155 fld_worklist_push (tree t, struct free_lang_data_d *fld)
5156 {
5157 if (t && !is_lang_specific (t) && !pointer_set_contains (fld->pset, t))
5158 fld->worklist.safe_push ((t));
5159 }
5160
5161
5162 /* Operand callback helper for free_lang_data_in_node. *TP is the
5163 subtree operand being considered. */
5164
5165 static tree
find_decls_types_r(tree * tp,int * ws,void * data)5166 find_decls_types_r (tree *tp, int *ws, void *data)
5167 {
5168 tree t = *tp;
5169 struct free_lang_data_d *fld = (struct free_lang_data_d *) data;
5170
5171 if (TREE_CODE (t) == TREE_LIST)
5172 return NULL_TREE;
5173
5174 /* Language specific nodes will be removed, so there is no need
5175 to gather anything under them. */
5176 if (is_lang_specific (t))
5177 {
5178 *ws = 0;
5179 return NULL_TREE;
5180 }
5181
5182 if (DECL_P (t))
5183 {
5184 /* Note that walk_tree does not traverse every possible field in
5185 decls, so we have to do our own traversals here. */
5186 add_tree_to_fld_list (t, fld);
5187
5188 fld_worklist_push (DECL_NAME (t), fld);
5189 fld_worklist_push (DECL_CONTEXT (t), fld);
5190 fld_worklist_push (DECL_SIZE (t), fld);
5191 fld_worklist_push (DECL_SIZE_UNIT (t), fld);
5192
5193 /* We are going to remove everything under DECL_INITIAL for
5194 TYPE_DECLs. No point walking them. */
5195 if (TREE_CODE (t) != TYPE_DECL)
5196 fld_worklist_push (DECL_INITIAL (t), fld);
5197
5198 fld_worklist_push (DECL_ATTRIBUTES (t), fld);
5199 fld_worklist_push (DECL_ABSTRACT_ORIGIN (t), fld);
5200
5201 if (TREE_CODE (t) == FUNCTION_DECL)
5202 {
5203 fld_worklist_push (DECL_ARGUMENTS (t), fld);
5204 fld_worklist_push (DECL_RESULT (t), fld);
5205 }
5206 else if (TREE_CODE (t) == TYPE_DECL)
5207 {
5208 fld_worklist_push (DECL_ARGUMENT_FLD (t), fld);
5209 fld_worklist_push (DECL_VINDEX (t), fld);
5210 fld_worklist_push (DECL_ORIGINAL_TYPE (t), fld);
5211 }
5212 else if (TREE_CODE (t) == FIELD_DECL)
5213 {
5214 fld_worklist_push (DECL_FIELD_OFFSET (t), fld);
5215 fld_worklist_push (DECL_BIT_FIELD_TYPE (t), fld);
5216 fld_worklist_push (DECL_FIELD_BIT_OFFSET (t), fld);
5217 fld_worklist_push (DECL_FCONTEXT (t), fld);
5218 }
5219 else if (TREE_CODE (t) == VAR_DECL)
5220 {
5221 fld_worklist_push (DECL_SECTION_NAME (t), fld);
5222 fld_worklist_push (DECL_COMDAT_GROUP (t), fld);
5223 }
5224
5225 if ((TREE_CODE (t) == VAR_DECL || TREE_CODE (t) == PARM_DECL)
5226 && DECL_HAS_VALUE_EXPR_P (t))
5227 fld_worklist_push (DECL_VALUE_EXPR (t), fld);
5228
5229 if (TREE_CODE (t) != FIELD_DECL
5230 && TREE_CODE (t) != TYPE_DECL)
5231 fld_worklist_push (TREE_CHAIN (t), fld);
5232 *ws = 0;
5233 }
5234 else if (TYPE_P (t))
5235 {
5236 /* Note that walk_tree does not traverse every possible field in
5237 types, so we have to do our own traversals here. */
5238 add_tree_to_fld_list (t, fld);
5239
5240 if (!RECORD_OR_UNION_TYPE_P (t))
5241 fld_worklist_push (TYPE_CACHED_VALUES (t), fld);
5242 fld_worklist_push (TYPE_SIZE (t), fld);
5243 fld_worklist_push (TYPE_SIZE_UNIT (t), fld);
5244 fld_worklist_push (TYPE_ATTRIBUTES (t), fld);
5245 fld_worklist_push (TYPE_POINTER_TO (t), fld);
5246 fld_worklist_push (TYPE_REFERENCE_TO (t), fld);
5247 fld_worklist_push (TYPE_NAME (t), fld);
5248 /* Do not walk TYPE_NEXT_PTR_TO or TYPE_NEXT_REF_TO. We do not stream
5249 them and thus do not and want not to reach unused pointer types
5250 this way. */
5251 if (!POINTER_TYPE_P (t))
5252 fld_worklist_push (TYPE_MINVAL (t), fld);
5253 if (!RECORD_OR_UNION_TYPE_P (t))
5254 fld_worklist_push (TYPE_MAXVAL (t), fld);
5255 fld_worklist_push (TYPE_MAIN_VARIANT (t), fld);
5256 /* Do not walk TYPE_NEXT_VARIANT. We do not stream it and thus
5257 do not and want not to reach unused variants this way. */
5258 if (TYPE_CONTEXT (t))
5259 {
5260 tree ctx = TYPE_CONTEXT (t);
5261 /* We adjust BLOCK TYPE_CONTEXTs to the innermost non-BLOCK one.
5262 So push that instead. */
5263 while (ctx && TREE_CODE (ctx) == BLOCK)
5264 ctx = BLOCK_SUPERCONTEXT (ctx);
5265 fld_worklist_push (ctx, fld);
5266 }
5267 /* Do not walk TYPE_CANONICAL. We do not stream it and thus do not
5268 and want not to reach unused types this way. */
5269
5270 if (RECORD_OR_UNION_TYPE_P (t) && TYPE_BINFO (t))
5271 {
5272 unsigned i;
5273 tree tem;
5274 FOR_EACH_VEC_ELT (*BINFO_BASE_BINFOS (TYPE_BINFO (t)), i, tem)
5275 fld_worklist_push (TREE_TYPE (tem), fld);
5276 tem = BINFO_VIRTUALS (TYPE_BINFO (t));
5277 if (tem
5278 /* The Java FE overloads BINFO_VIRTUALS for its own purpose. */
5279 && TREE_CODE (tem) == TREE_LIST)
5280 do
5281 {
5282 fld_worklist_push (TREE_VALUE (tem), fld);
5283 tem = TREE_CHAIN (tem);
5284 }
5285 while (tem);
5286 }
5287 if (RECORD_OR_UNION_TYPE_P (t))
5288 {
5289 tree tem;
5290 /* Push all TYPE_FIELDS - there can be interleaving interesting
5291 and non-interesting things. */
5292 tem = TYPE_FIELDS (t);
5293 while (tem)
5294 {
5295 if (TREE_CODE (tem) == FIELD_DECL
5296 || TREE_CODE (tem) == TYPE_DECL)
5297 fld_worklist_push (tem, fld);
5298 tem = TREE_CHAIN (tem);
5299 }
5300 }
5301
5302 fld_worklist_push (TYPE_STUB_DECL (t), fld);
5303 *ws = 0;
5304 }
5305 else if (TREE_CODE (t) == BLOCK)
5306 {
5307 tree tem;
5308 for (tem = BLOCK_VARS (t); tem; tem = TREE_CHAIN (tem))
5309 fld_worklist_push (tem, fld);
5310 for (tem = BLOCK_SUBBLOCKS (t); tem; tem = BLOCK_CHAIN (tem))
5311 fld_worklist_push (tem, fld);
5312 fld_worklist_push (BLOCK_ABSTRACT_ORIGIN (t), fld);
5313 }
5314
5315 if (TREE_CODE (t) != IDENTIFIER_NODE
5316 && CODE_CONTAINS_STRUCT (TREE_CODE (t), TS_TYPED))
5317 fld_worklist_push (TREE_TYPE (t), fld);
5318
5319 return NULL_TREE;
5320 }
5321
5322
5323 /* Find decls and types in T. */
5324
5325 static void
find_decls_types(tree t,struct free_lang_data_d * fld)5326 find_decls_types (tree t, struct free_lang_data_d *fld)
5327 {
5328 while (1)
5329 {
5330 if (!pointer_set_contains (fld->pset, t))
5331 walk_tree (&t, find_decls_types_r, fld, fld->pset);
5332 if (fld->worklist.is_empty ())
5333 break;
5334 t = fld->worklist.pop ();
5335 }
5336 }
5337
5338 /* Translate all the types in LIST with the corresponding runtime
5339 types. */
5340
5341 static tree
get_eh_types_for_runtime(tree list)5342 get_eh_types_for_runtime (tree list)
5343 {
5344 tree head, prev;
5345
5346 if (list == NULL_TREE)
5347 return NULL_TREE;
5348
5349 head = build_tree_list (0, lookup_type_for_runtime (TREE_VALUE (list)));
5350 prev = head;
5351 list = TREE_CHAIN (list);
5352 while (list)
5353 {
5354 tree n = build_tree_list (0, lookup_type_for_runtime (TREE_VALUE (list)));
5355 TREE_CHAIN (prev) = n;
5356 prev = TREE_CHAIN (prev);
5357 list = TREE_CHAIN (list);
5358 }
5359
5360 return head;
5361 }
5362
5363
5364 /* Find decls and types referenced in EH region R and store them in
5365 FLD->DECLS and FLD->TYPES. */
5366
5367 static void
find_decls_types_in_eh_region(eh_region r,struct free_lang_data_d * fld)5368 find_decls_types_in_eh_region (eh_region r, struct free_lang_data_d *fld)
5369 {
5370 switch (r->type)
5371 {
5372 case ERT_CLEANUP:
5373 break;
5374
5375 case ERT_TRY:
5376 {
5377 eh_catch c;
5378
5379 /* The types referenced in each catch must first be changed to the
5380 EH types used at runtime. This removes references to FE types
5381 in the region. */
5382 for (c = r->u.eh_try.first_catch; c ; c = c->next_catch)
5383 {
5384 c->type_list = get_eh_types_for_runtime (c->type_list);
5385 walk_tree (&c->type_list, find_decls_types_r, fld, fld->pset);
5386 }
5387 }
5388 break;
5389
5390 case ERT_ALLOWED_EXCEPTIONS:
5391 r->u.allowed.type_list
5392 = get_eh_types_for_runtime (r->u.allowed.type_list);
5393 walk_tree (&r->u.allowed.type_list, find_decls_types_r, fld, fld->pset);
5394 break;
5395
5396 case ERT_MUST_NOT_THROW:
5397 walk_tree (&r->u.must_not_throw.failure_decl,
5398 find_decls_types_r, fld, fld->pset);
5399 break;
5400 }
5401 }
5402
5403
5404 /* Find decls and types referenced in cgraph node N and store them in
5405 FLD->DECLS and FLD->TYPES. Unlike pass_referenced_vars, this will
5406 look for *every* kind of DECL and TYPE node reachable from N,
5407 including those embedded inside types and decls (i.e,, TYPE_DECLs,
5408 NAMESPACE_DECLs, etc). */
5409
5410 static void
find_decls_types_in_node(struct cgraph_node * n,struct free_lang_data_d * fld)5411 find_decls_types_in_node (struct cgraph_node *n, struct free_lang_data_d *fld)
5412 {
5413 basic_block bb;
5414 struct function *fn;
5415 unsigned ix;
5416 tree t;
5417
5418 find_decls_types (n->decl, fld);
5419
5420 if (!gimple_has_body_p (n->decl))
5421 return;
5422
5423 gcc_assert (current_function_decl == NULL_TREE && cfun == NULL);
5424
5425 fn = DECL_STRUCT_FUNCTION (n->decl);
5426
5427 /* Traverse locals. */
5428 FOR_EACH_LOCAL_DECL (fn, ix, t)
5429 find_decls_types (t, fld);
5430
5431 /* Traverse EH regions in FN. */
5432 {
5433 eh_region r;
5434 FOR_ALL_EH_REGION_FN (r, fn)
5435 find_decls_types_in_eh_region (r, fld);
5436 }
5437
5438 /* Traverse every statement in FN. */
5439 FOR_EACH_BB_FN (bb, fn)
5440 {
5441 gimple_stmt_iterator si;
5442 unsigned i;
5443
5444 for (si = gsi_start_phis (bb); !gsi_end_p (si); gsi_next (&si))
5445 {
5446 gimple phi = gsi_stmt (si);
5447
5448 for (i = 0; i < gimple_phi_num_args (phi); i++)
5449 {
5450 tree *arg_p = gimple_phi_arg_def_ptr (phi, i);
5451 find_decls_types (*arg_p, fld);
5452 }
5453 }
5454
5455 for (si = gsi_start_bb (bb); !gsi_end_p (si); gsi_next (&si))
5456 {
5457 gimple stmt = gsi_stmt (si);
5458
5459 if (is_gimple_call (stmt))
5460 find_decls_types (gimple_call_fntype (stmt), fld);
5461
5462 for (i = 0; i < gimple_num_ops (stmt); i++)
5463 {
5464 tree arg = gimple_op (stmt, i);
5465 find_decls_types (arg, fld);
5466 }
5467 }
5468 }
5469 }
5470
5471
5472 /* Find decls and types referenced in varpool node N and store them in
5473 FLD->DECLS and FLD->TYPES. Unlike pass_referenced_vars, this will
5474 look for *every* kind of DECL and TYPE node reachable from N,
5475 including those embedded inside types and decls (i.e,, TYPE_DECLs,
5476 NAMESPACE_DECLs, etc). */
5477
5478 static void
find_decls_types_in_var(varpool_node * v,struct free_lang_data_d * fld)5479 find_decls_types_in_var (varpool_node *v, struct free_lang_data_d *fld)
5480 {
5481 find_decls_types (v->decl, fld);
5482 }
5483
5484 /* If T needs an assembler name, have one created for it. */
5485
5486 void
assign_assembler_name_if_neeeded(tree t)5487 assign_assembler_name_if_neeeded (tree t)
5488 {
5489 if (need_assembler_name_p (t))
5490 {
5491 /* When setting DECL_ASSEMBLER_NAME, the C++ mangler may emit
5492 diagnostics that use input_location to show locus
5493 information. The problem here is that, at this point,
5494 input_location is generally anchored to the end of the file
5495 (since the parser is long gone), so we don't have a good
5496 position to pin it to.
5497
5498 To alleviate this problem, this uses the location of T's
5499 declaration. Examples of this are
5500 testsuite/g++.dg/template/cond2.C and
5501 testsuite/g++.dg/template/pr35240.C. */
5502 location_t saved_location = input_location;
5503 input_location = DECL_SOURCE_LOCATION (t);
5504
5505 decl_assembler_name (t);
5506
5507 input_location = saved_location;
5508 }
5509 }
5510
5511
5512 /* Free language specific information for every operand and expression
5513 in every node of the call graph. This process operates in three stages:
5514
5515 1- Every callgraph node and varpool node is traversed looking for
5516 decls and types embedded in them. This is a more exhaustive
5517 search than that done by find_referenced_vars, because it will
5518 also collect individual fields, decls embedded in types, etc.
5519
5520 2- All the decls found are sent to free_lang_data_in_decl.
5521
5522 3- All the types found are sent to free_lang_data_in_type.
5523
5524 The ordering between decls and types is important because
5525 free_lang_data_in_decl sets assembler names, which includes
5526 mangling. So types cannot be freed up until assembler names have
5527 been set up. */
5528
5529 static void
free_lang_data_in_cgraph(void)5530 free_lang_data_in_cgraph (void)
5531 {
5532 struct cgraph_node *n;
5533 varpool_node *v;
5534 struct free_lang_data_d fld;
5535 tree t;
5536 unsigned i;
5537 alias_pair *p;
5538
5539 /* Initialize sets and arrays to store referenced decls and types. */
5540 fld.pset = pointer_set_create ();
5541 fld.worklist.create (0);
5542 fld.decls.create (100);
5543 fld.types.create (100);
5544
5545 /* Find decls and types in the body of every function in the callgraph. */
5546 FOR_EACH_FUNCTION (n)
5547 find_decls_types_in_node (n, &fld);
5548
5549 FOR_EACH_VEC_SAFE_ELT (alias_pairs, i, p)
5550 find_decls_types (p->decl, &fld);
5551
5552 /* Find decls and types in every varpool symbol. */
5553 FOR_EACH_VARIABLE (v)
5554 find_decls_types_in_var (v, &fld);
5555
5556 /* Set the assembler name on every decl found. We need to do this
5557 now because free_lang_data_in_decl will invalidate data needed
5558 for mangling. This breaks mangling on interdependent decls. */
5559 FOR_EACH_VEC_ELT (fld.decls, i, t)
5560 assign_assembler_name_if_neeeded (t);
5561
5562 /* Traverse every decl found freeing its language data. */
5563 FOR_EACH_VEC_ELT (fld.decls, i, t)
5564 free_lang_data_in_decl (t);
5565
5566 /* Traverse every type found freeing its language data. */
5567 FOR_EACH_VEC_ELT (fld.types, i, t)
5568 free_lang_data_in_type (t);
5569
5570 pointer_set_destroy (fld.pset);
5571 fld.worklist.release ();
5572 fld.decls.release ();
5573 fld.types.release ();
5574 }
5575
5576
5577 /* Free resources that are used by FE but are not needed once they are done. */
5578
5579 static unsigned
free_lang_data(void)5580 free_lang_data (void)
5581 {
5582 unsigned i;
5583
5584 /* If we are the LTO frontend we have freed lang-specific data already. */
5585 if (in_lto_p
5586 || !flag_generate_lto)
5587 return 0;
5588
5589 /* Allocate and assign alias sets to the standard integer types
5590 while the slots are still in the way the frontends generated them. */
5591 for (i = 0; i < itk_none; ++i)
5592 if (integer_types[i])
5593 TYPE_ALIAS_SET (integer_types[i]) = get_alias_set (integer_types[i]);
5594
5595 /* Traverse the IL resetting language specific information for
5596 operands, expressions, etc. */
5597 free_lang_data_in_cgraph ();
5598
5599 /* Create gimple variants for common types. */
5600 ptrdiff_type_node = integer_type_node;
5601 fileptr_type_node = ptr_type_node;
5602
5603 /* Reset some langhooks. Do not reset types_compatible_p, it may
5604 still be used indirectly via the get_alias_set langhook. */
5605 lang_hooks.dwarf_name = lhd_dwarf_name;
5606 lang_hooks.decl_printable_name = gimple_decl_printable_name;
5607 /* We do not want the default decl_assembler_name implementation,
5608 rather if we have fixed everything we want a wrapper around it
5609 asserting that all non-local symbols already got their assembler
5610 name and only produce assembler names for local symbols. Or rather
5611 make sure we never call decl_assembler_name on local symbols and
5612 devise a separate, middle-end private scheme for it. */
5613
5614 /* Reset diagnostic machinery. */
5615 tree_diagnostics_defaults (global_dc);
5616
5617 return 0;
5618 }
5619
5620
5621 namespace {
5622
5623 const pass_data pass_data_ipa_free_lang_data =
5624 {
5625 SIMPLE_IPA_PASS, /* type */
5626 "*free_lang_data", /* name */
5627 OPTGROUP_NONE, /* optinfo_flags */
5628 false, /* has_gate */
5629 true, /* has_execute */
5630 TV_IPA_FREE_LANG_DATA, /* tv_id */
5631 0, /* properties_required */
5632 0, /* properties_provided */
5633 0, /* properties_destroyed */
5634 0, /* todo_flags_start */
5635 0, /* todo_flags_finish */
5636 };
5637
5638 class pass_ipa_free_lang_data : public simple_ipa_opt_pass
5639 {
5640 public:
pass_ipa_free_lang_data(gcc::context * ctxt)5641 pass_ipa_free_lang_data (gcc::context *ctxt)
5642 : simple_ipa_opt_pass (pass_data_ipa_free_lang_data, ctxt)
5643 {}
5644
5645 /* opt_pass methods: */
execute()5646 unsigned int execute () { return free_lang_data (); }
5647
5648 }; // class pass_ipa_free_lang_data
5649
5650 } // anon namespace
5651
5652 simple_ipa_opt_pass *
make_pass_ipa_free_lang_data(gcc::context * ctxt)5653 make_pass_ipa_free_lang_data (gcc::context *ctxt)
5654 {
5655 return new pass_ipa_free_lang_data (ctxt);
5656 }
5657
5658 /* The backbone of is_attribute_p(). ATTR_LEN is the string length of
5659 ATTR_NAME. Also used internally by remove_attribute(). */
5660 bool
private_is_attribute_p(const char * attr_name,size_t attr_len,const_tree ident)5661 private_is_attribute_p (const char *attr_name, size_t attr_len, const_tree ident)
5662 {
5663 size_t ident_len = IDENTIFIER_LENGTH (ident);
5664
5665 if (ident_len == attr_len)
5666 {
5667 if (strcmp (attr_name, IDENTIFIER_POINTER (ident)) == 0)
5668 return true;
5669 }
5670 else if (ident_len == attr_len + 4)
5671 {
5672 /* There is the possibility that ATTR is 'text' and IDENT is
5673 '__text__'. */
5674 const char *p = IDENTIFIER_POINTER (ident);
5675 if (p[0] == '_' && p[1] == '_'
5676 && p[ident_len - 2] == '_' && p[ident_len - 1] == '_'
5677 && strncmp (attr_name, p + 2, attr_len) == 0)
5678 return true;
5679 }
5680
5681 return false;
5682 }
5683
5684 /* The backbone of lookup_attribute(). ATTR_LEN is the string length
5685 of ATTR_NAME, and LIST is not NULL_TREE. */
5686 tree
private_lookup_attribute(const char * attr_name,size_t attr_len,tree list)5687 private_lookup_attribute (const char *attr_name, size_t attr_len, tree list)
5688 {
5689 while (list)
5690 {
5691 size_t ident_len = IDENTIFIER_LENGTH (get_attribute_name (list));
5692
5693 if (ident_len == attr_len)
5694 {
5695 if (!strcmp (attr_name,
5696 IDENTIFIER_POINTER (get_attribute_name (list))))
5697 break;
5698 }
5699 /* TODO: If we made sure that attributes were stored in the
5700 canonical form without '__...__' (ie, as in 'text' as opposed
5701 to '__text__') then we could avoid the following case. */
5702 else if (ident_len == attr_len + 4)
5703 {
5704 const char *p = IDENTIFIER_POINTER (get_attribute_name (list));
5705 if (p[0] == '_' && p[1] == '_'
5706 && p[ident_len - 2] == '_' && p[ident_len - 1] == '_'
5707 && strncmp (attr_name, p + 2, attr_len) == 0)
5708 break;
5709 }
5710 list = TREE_CHAIN (list);
5711 }
5712
5713 return list;
5714 }
5715
5716 /* A variant of lookup_attribute() that can be used with an identifier
5717 as the first argument, and where the identifier can be either
5718 'text' or '__text__'.
5719
5720 Given an attribute ATTR_IDENTIFIER, and a list of attributes LIST,
5721 return a pointer to the attribute's list element if the attribute
5722 is part of the list, or NULL_TREE if not found. If the attribute
5723 appears more than once, this only returns the first occurrence; the
5724 TREE_CHAIN of the return value should be passed back in if further
5725 occurrences are wanted. ATTR_IDENTIFIER must be an identifier but
5726 can be in the form 'text' or '__text__'. */
5727 static tree
lookup_ident_attribute(tree attr_identifier,tree list)5728 lookup_ident_attribute (tree attr_identifier, tree list)
5729 {
5730 gcc_checking_assert (TREE_CODE (attr_identifier) == IDENTIFIER_NODE);
5731
5732 while (list)
5733 {
5734 gcc_checking_assert (TREE_CODE (get_attribute_name (list))
5735 == IDENTIFIER_NODE);
5736
5737 /* Identifiers can be compared directly for equality. */
5738 if (attr_identifier == get_attribute_name (list))
5739 break;
5740
5741 /* If they are not equal, they may still be one in the form
5742 'text' while the other one is in the form '__text__'. TODO:
5743 If we were storing attributes in normalized 'text' form, then
5744 this could all go away and we could take full advantage of
5745 the fact that we're comparing identifiers. :-) */
5746 {
5747 size_t attr_len = IDENTIFIER_LENGTH (attr_identifier);
5748 size_t ident_len = IDENTIFIER_LENGTH (get_attribute_name (list));
5749
5750 if (ident_len == attr_len + 4)
5751 {
5752 const char *p = IDENTIFIER_POINTER (get_attribute_name (list));
5753 const char *q = IDENTIFIER_POINTER (attr_identifier);
5754 if (p[0] == '_' && p[1] == '_'
5755 && p[ident_len - 2] == '_' && p[ident_len - 1] == '_'
5756 && strncmp (q, p + 2, attr_len) == 0)
5757 break;
5758 }
5759 else if (ident_len + 4 == attr_len)
5760 {
5761 const char *p = IDENTIFIER_POINTER (get_attribute_name (list));
5762 const char *q = IDENTIFIER_POINTER (attr_identifier);
5763 if (q[0] == '_' && q[1] == '_'
5764 && q[attr_len - 2] == '_' && q[attr_len - 1] == '_'
5765 && strncmp (q + 2, p, ident_len) == 0)
5766 break;
5767 }
5768 }
5769 list = TREE_CHAIN (list);
5770 }
5771
5772 return list;
5773 }
5774
5775 /* Remove any instances of attribute ATTR_NAME in LIST and return the
5776 modified list. */
5777
5778 tree
remove_attribute(const char * attr_name,tree list)5779 remove_attribute (const char *attr_name, tree list)
5780 {
5781 tree *p;
5782 size_t attr_len = strlen (attr_name);
5783
5784 gcc_checking_assert (attr_name[0] != '_');
5785
5786 for (p = &list; *p; )
5787 {
5788 tree l = *p;
5789 /* TODO: If we were storing attributes in normalized form, here
5790 we could use a simple strcmp(). */
5791 if (private_is_attribute_p (attr_name, attr_len, get_attribute_name (l)))
5792 *p = TREE_CHAIN (l);
5793 else
5794 p = &TREE_CHAIN (l);
5795 }
5796
5797 return list;
5798 }
5799
5800 /* Return an attribute list that is the union of a1 and a2. */
5801
5802 tree
merge_attributes(tree a1,tree a2)5803 merge_attributes (tree a1, tree a2)
5804 {
5805 tree attributes;
5806
5807 /* Either one unset? Take the set one. */
5808
5809 if ((attributes = a1) == 0)
5810 attributes = a2;
5811
5812 /* One that completely contains the other? Take it. */
5813
5814 else if (a2 != 0 && ! attribute_list_contained (a1, a2))
5815 {
5816 if (attribute_list_contained (a2, a1))
5817 attributes = a2;
5818 else
5819 {
5820 /* Pick the longest list, and hang on the other list. */
5821
5822 if (list_length (a1) < list_length (a2))
5823 attributes = a2, a2 = a1;
5824
5825 for (; a2 != 0; a2 = TREE_CHAIN (a2))
5826 {
5827 tree a;
5828 for (a = lookup_ident_attribute (get_attribute_name (a2),
5829 attributes);
5830 a != NULL_TREE && !attribute_value_equal (a, a2);
5831 a = lookup_ident_attribute (get_attribute_name (a2),
5832 TREE_CHAIN (a)))
5833 ;
5834 if (a == NULL_TREE)
5835 {
5836 a1 = copy_node (a2);
5837 TREE_CHAIN (a1) = attributes;
5838 attributes = a1;
5839 }
5840 }
5841 }
5842 }
5843 return attributes;
5844 }
5845
5846 /* Given types T1 and T2, merge their attributes and return
5847 the result. */
5848
5849 tree
merge_type_attributes(tree t1,tree t2)5850 merge_type_attributes (tree t1, tree t2)
5851 {
5852 return merge_attributes (TYPE_ATTRIBUTES (t1),
5853 TYPE_ATTRIBUTES (t2));
5854 }
5855
5856 /* Given decls OLDDECL and NEWDECL, merge their attributes and return
5857 the result. */
5858
5859 tree
merge_decl_attributes(tree olddecl,tree newdecl)5860 merge_decl_attributes (tree olddecl, tree newdecl)
5861 {
5862 return merge_attributes (DECL_ATTRIBUTES (olddecl),
5863 DECL_ATTRIBUTES (newdecl));
5864 }
5865
5866 #if TARGET_DLLIMPORT_DECL_ATTRIBUTES
5867
5868 /* Specialization of merge_decl_attributes for various Windows targets.
5869
5870 This handles the following situation:
5871
5872 __declspec (dllimport) int foo;
5873 int foo;
5874
5875 The second instance of `foo' nullifies the dllimport. */
5876
5877 tree
merge_dllimport_decl_attributes(tree old,tree new_tree)5878 merge_dllimport_decl_attributes (tree old, tree new_tree)
5879 {
5880 tree a;
5881 int delete_dllimport_p = 1;
5882
5883 /* What we need to do here is remove from `old' dllimport if it doesn't
5884 appear in `new'. dllimport behaves like extern: if a declaration is
5885 marked dllimport and a definition appears later, then the object
5886 is not dllimport'd. We also remove a `new' dllimport if the old list
5887 contains dllexport: dllexport always overrides dllimport, regardless
5888 of the order of declaration. */
5889 if (!VAR_OR_FUNCTION_DECL_P (new_tree))
5890 delete_dllimport_p = 0;
5891 else if (DECL_DLLIMPORT_P (new_tree)
5892 && lookup_attribute ("dllexport", DECL_ATTRIBUTES (old)))
5893 {
5894 DECL_DLLIMPORT_P (new_tree) = 0;
5895 warning (OPT_Wattributes, "%q+D already declared with dllexport attribute: "
5896 "dllimport ignored", new_tree);
5897 }
5898 else if (DECL_DLLIMPORT_P (old) && !DECL_DLLIMPORT_P (new_tree))
5899 {
5900 /* Warn about overriding a symbol that has already been used, e.g.:
5901 extern int __attribute__ ((dllimport)) foo;
5902 int* bar () {return &foo;}
5903 int foo;
5904 */
5905 if (TREE_USED (old))
5906 {
5907 warning (0, "%q+D redeclared without dllimport attribute "
5908 "after being referenced with dll linkage", new_tree);
5909 /* If we have used a variable's address with dllimport linkage,
5910 keep the old DECL_DLLIMPORT_P flag: the ADDR_EXPR using the
5911 decl may already have had TREE_CONSTANT computed.
5912 We still remove the attribute so that assembler code refers
5913 to '&foo rather than '_imp__foo'. */
5914 if (TREE_CODE (old) == VAR_DECL && TREE_ADDRESSABLE (old))
5915 DECL_DLLIMPORT_P (new_tree) = 1;
5916 }
5917
5918 /* Let an inline definition silently override the external reference,
5919 but otherwise warn about attribute inconsistency. */
5920 else if (TREE_CODE (new_tree) == VAR_DECL
5921 || !DECL_DECLARED_INLINE_P (new_tree))
5922 warning (OPT_Wattributes, "%q+D redeclared without dllimport attribute: "
5923 "previous dllimport ignored", new_tree);
5924 }
5925 else
5926 delete_dllimport_p = 0;
5927
5928 a = merge_attributes (DECL_ATTRIBUTES (old), DECL_ATTRIBUTES (new_tree));
5929
5930 if (delete_dllimport_p)
5931 a = remove_attribute ("dllimport", a);
5932
5933 return a;
5934 }
5935
5936 /* Handle a "dllimport" or "dllexport" attribute; arguments as in
5937 struct attribute_spec.handler. */
5938
5939 tree
handle_dll_attribute(tree * pnode,tree name,tree args,int flags,bool * no_add_attrs)5940 handle_dll_attribute (tree * pnode, tree name, tree args, int flags,
5941 bool *no_add_attrs)
5942 {
5943 tree node = *pnode;
5944 bool is_dllimport;
5945
5946 /* These attributes may apply to structure and union types being created,
5947 but otherwise should pass to the declaration involved. */
5948 if (!DECL_P (node))
5949 {
5950 if (flags & ((int) ATTR_FLAG_DECL_NEXT | (int) ATTR_FLAG_FUNCTION_NEXT
5951 | (int) ATTR_FLAG_ARRAY_NEXT))
5952 {
5953 *no_add_attrs = true;
5954 return tree_cons (name, args, NULL_TREE);
5955 }
5956 if (TREE_CODE (node) == RECORD_TYPE
5957 || TREE_CODE (node) == UNION_TYPE)
5958 {
5959 node = TYPE_NAME (node);
5960 if (!node)
5961 return NULL_TREE;
5962 }
5963 else
5964 {
5965 warning (OPT_Wattributes, "%qE attribute ignored",
5966 name);
5967 *no_add_attrs = true;
5968 return NULL_TREE;
5969 }
5970 }
5971
5972 if (TREE_CODE (node) != FUNCTION_DECL
5973 && TREE_CODE (node) != VAR_DECL
5974 && TREE_CODE (node) != TYPE_DECL)
5975 {
5976 *no_add_attrs = true;
5977 warning (OPT_Wattributes, "%qE attribute ignored",
5978 name);
5979 return NULL_TREE;
5980 }
5981
5982 if (TREE_CODE (node) == TYPE_DECL
5983 && TREE_CODE (TREE_TYPE (node)) != RECORD_TYPE
5984 && TREE_CODE (TREE_TYPE (node)) != UNION_TYPE)
5985 {
5986 *no_add_attrs = true;
5987 warning (OPT_Wattributes, "%qE attribute ignored",
5988 name);
5989 return NULL_TREE;
5990 }
5991
5992 is_dllimport = is_attribute_p ("dllimport", name);
5993
5994 /* Report error on dllimport ambiguities seen now before they cause
5995 any damage. */
5996 if (is_dllimport)
5997 {
5998 /* Honor any target-specific overrides. */
5999 if (!targetm.valid_dllimport_attribute_p (node))
6000 *no_add_attrs = true;
6001
6002 else if (TREE_CODE (node) == FUNCTION_DECL
6003 && DECL_DECLARED_INLINE_P (node))
6004 {
6005 warning (OPT_Wattributes, "inline function %q+D declared as "
6006 " dllimport: attribute ignored", node);
6007 *no_add_attrs = true;
6008 }
6009 /* Like MS, treat definition of dllimported variables and
6010 non-inlined functions on declaration as syntax errors. */
6011 else if (TREE_CODE (node) == FUNCTION_DECL && DECL_INITIAL (node))
6012 {
6013 error ("function %q+D definition is marked dllimport", node);
6014 *no_add_attrs = true;
6015 }
6016
6017 else if (TREE_CODE (node) == VAR_DECL)
6018 {
6019 if (DECL_INITIAL (node))
6020 {
6021 error ("variable %q+D definition is marked dllimport",
6022 node);
6023 *no_add_attrs = true;
6024 }
6025
6026 /* `extern' needn't be specified with dllimport.
6027 Specify `extern' now and hope for the best. Sigh. */
6028 DECL_EXTERNAL (node) = 1;
6029 /* Also, implicitly give dllimport'd variables declared within
6030 a function global scope, unless declared static. */
6031 if (current_function_decl != NULL_TREE && !TREE_STATIC (node))
6032 TREE_PUBLIC (node) = 1;
6033 }
6034
6035 if (*no_add_attrs == false)
6036 DECL_DLLIMPORT_P (node) = 1;
6037 }
6038 else if (TREE_CODE (node) == FUNCTION_DECL
6039 && DECL_DECLARED_INLINE_P (node)
6040 && flag_keep_inline_dllexport)
6041 /* An exported function, even if inline, must be emitted. */
6042 DECL_EXTERNAL (node) = 0;
6043
6044 /* Report error if symbol is not accessible at global scope. */
6045 if (!TREE_PUBLIC (node)
6046 && (TREE_CODE (node) == VAR_DECL
6047 || TREE_CODE (node) == FUNCTION_DECL))
6048 {
6049 error ("external linkage required for symbol %q+D because of "
6050 "%qE attribute", node, name);
6051 *no_add_attrs = true;
6052 }
6053
6054 /* A dllexport'd entity must have default visibility so that other
6055 program units (shared libraries or the main executable) can see
6056 it. A dllimport'd entity must have default visibility so that
6057 the linker knows that undefined references within this program
6058 unit can be resolved by the dynamic linker. */
6059 if (!*no_add_attrs)
6060 {
6061 if (DECL_VISIBILITY_SPECIFIED (node)
6062 && DECL_VISIBILITY (node) != VISIBILITY_DEFAULT)
6063 error ("%qE implies default visibility, but %qD has already "
6064 "been declared with a different visibility",
6065 name, node);
6066 DECL_VISIBILITY (node) = VISIBILITY_DEFAULT;
6067 DECL_VISIBILITY_SPECIFIED (node) = 1;
6068 }
6069
6070 return NULL_TREE;
6071 }
6072
6073 #endif /* TARGET_DLLIMPORT_DECL_ATTRIBUTES */
6074
6075 /* Set the type qualifiers for TYPE to TYPE_QUALS, which is a bitmask
6076 of the various TYPE_QUAL values. */
6077
6078 static void
set_type_quals(tree type,int type_quals)6079 set_type_quals (tree type, int type_quals)
6080 {
6081 TYPE_READONLY (type) = (type_quals & TYPE_QUAL_CONST) != 0;
6082 TYPE_VOLATILE (type) = (type_quals & TYPE_QUAL_VOLATILE) != 0;
6083 TYPE_RESTRICT (type) = (type_quals & TYPE_QUAL_RESTRICT) != 0;
6084 TYPE_ATOMIC (type) = (type_quals & TYPE_QUAL_ATOMIC) != 0;
6085 TYPE_ADDR_SPACE (type) = DECODE_QUAL_ADDR_SPACE (type_quals);
6086 }
6087
6088 /* Returns true iff CAND is equivalent to BASE with TYPE_QUALS. */
6089
6090 bool
check_qualified_type(const_tree cand,const_tree base,int type_quals)6091 check_qualified_type (const_tree cand, const_tree base, int type_quals)
6092 {
6093 return (TYPE_QUALS (cand) == type_quals
6094 && TYPE_NAME (cand) == TYPE_NAME (base)
6095 /* Apparently this is needed for Objective-C. */
6096 && TYPE_CONTEXT (cand) == TYPE_CONTEXT (base)
6097 /* Check alignment. */
6098 && TYPE_ALIGN (cand) == TYPE_ALIGN (base)
6099 && attribute_list_equal (TYPE_ATTRIBUTES (cand),
6100 TYPE_ATTRIBUTES (base)));
6101 }
6102
6103 /* Returns true iff CAND is equivalent to BASE with ALIGN. */
6104
6105 static bool
check_aligned_type(const_tree cand,const_tree base,unsigned int align)6106 check_aligned_type (const_tree cand, const_tree base, unsigned int align)
6107 {
6108 return (TYPE_QUALS (cand) == TYPE_QUALS (base)
6109 && TYPE_NAME (cand) == TYPE_NAME (base)
6110 /* Apparently this is needed for Objective-C. */
6111 && TYPE_CONTEXT (cand) == TYPE_CONTEXT (base)
6112 /* Check alignment. */
6113 && TYPE_ALIGN (cand) == align
6114 && attribute_list_equal (TYPE_ATTRIBUTES (cand),
6115 TYPE_ATTRIBUTES (base)));
6116 }
6117
6118 /* This function checks to see if TYPE matches the size one of the built-in
6119 atomic types, and returns that core atomic type. */
6120
6121 static tree
find_atomic_core_type(tree type)6122 find_atomic_core_type (tree type)
6123 {
6124 tree base_atomic_type;
6125
6126 /* Only handle complete types. */
6127 if (TYPE_SIZE (type) == NULL_TREE)
6128 return NULL_TREE;
6129
6130 HOST_WIDE_INT type_size = tree_to_uhwi (TYPE_SIZE (type));
6131 switch (type_size)
6132 {
6133 case 8:
6134 base_atomic_type = atomicQI_type_node;
6135 break;
6136
6137 case 16:
6138 base_atomic_type = atomicHI_type_node;
6139 break;
6140
6141 case 32:
6142 base_atomic_type = atomicSI_type_node;
6143 break;
6144
6145 case 64:
6146 base_atomic_type = atomicDI_type_node;
6147 break;
6148
6149 case 128:
6150 base_atomic_type = atomicTI_type_node;
6151 break;
6152
6153 default:
6154 base_atomic_type = NULL_TREE;
6155 }
6156
6157 return base_atomic_type;
6158 }
6159
6160 /* Return a version of the TYPE, qualified as indicated by the
6161 TYPE_QUALS, if one exists. If no qualified version exists yet,
6162 return NULL_TREE. */
6163
6164 tree
get_qualified_type(tree type,int type_quals)6165 get_qualified_type (tree type, int type_quals)
6166 {
6167 tree t;
6168
6169 if (TYPE_QUALS (type) == type_quals)
6170 return type;
6171
6172 /* Search the chain of variants to see if there is already one there just
6173 like the one we need to have. If so, use that existing one. We must
6174 preserve the TYPE_NAME, since there is code that depends on this. */
6175 for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
6176 if (check_qualified_type (t, type, type_quals))
6177 return t;
6178
6179 return NULL_TREE;
6180 }
6181
6182 /* Like get_qualified_type, but creates the type if it does not
6183 exist. This function never returns NULL_TREE. */
6184
6185 tree
build_qualified_type(tree type,int type_quals)6186 build_qualified_type (tree type, int type_quals)
6187 {
6188 tree t;
6189
6190 /* See if we already have the appropriate qualified variant. */
6191 t = get_qualified_type (type, type_quals);
6192
6193 /* If not, build it. */
6194 if (!t)
6195 {
6196 t = build_variant_type_copy (type);
6197 set_type_quals (t, type_quals);
6198
6199 if (((type_quals & TYPE_QUAL_ATOMIC) == TYPE_QUAL_ATOMIC))
6200 {
6201 /* See if this object can map to a basic atomic type. */
6202 tree atomic_type = find_atomic_core_type (type);
6203 if (atomic_type)
6204 {
6205 /* Ensure the alignment of this type is compatible with
6206 the required alignment of the atomic type. */
6207 if (TYPE_ALIGN (atomic_type) > TYPE_ALIGN (t))
6208 TYPE_ALIGN (t) = TYPE_ALIGN (atomic_type);
6209 }
6210 }
6211
6212 if (TYPE_STRUCTURAL_EQUALITY_P (type))
6213 /* Propagate structural equality. */
6214 SET_TYPE_STRUCTURAL_EQUALITY (t);
6215 else if (TYPE_CANONICAL (type) != type)
6216 /* Build the underlying canonical type, since it is different
6217 from TYPE. */
6218 TYPE_CANONICAL (t) = build_qualified_type (TYPE_CANONICAL (type),
6219 type_quals);
6220 else
6221 /* T is its own canonical type. */
6222 TYPE_CANONICAL (t) = t;
6223
6224 }
6225
6226 return t;
6227 }
6228
6229 /* Create a variant of type T with alignment ALIGN. */
6230
6231 tree
build_aligned_type(tree type,unsigned int align)6232 build_aligned_type (tree type, unsigned int align)
6233 {
6234 tree t;
6235
6236 if (TYPE_PACKED (type)
6237 || TYPE_ALIGN (type) == align)
6238 return type;
6239
6240 for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
6241 if (check_aligned_type (t, type, align))
6242 return t;
6243
6244 t = build_variant_type_copy (type);
6245 TYPE_ALIGN (t) = align;
6246
6247 return t;
6248 }
6249
6250 /* Create a new distinct copy of TYPE. The new type is made its own
6251 MAIN_VARIANT. If TYPE requires structural equality checks, the
6252 resulting type requires structural equality checks; otherwise, its
6253 TYPE_CANONICAL points to itself. */
6254
6255 tree
build_distinct_type_copy(tree type)6256 build_distinct_type_copy (tree type)
6257 {
6258 tree t = copy_node (type);
6259
6260 TYPE_POINTER_TO (t) = 0;
6261 TYPE_REFERENCE_TO (t) = 0;
6262
6263 /* Set the canonical type either to a new equivalence class, or
6264 propagate the need for structural equality checks. */
6265 if (TYPE_STRUCTURAL_EQUALITY_P (type))
6266 SET_TYPE_STRUCTURAL_EQUALITY (t);
6267 else
6268 TYPE_CANONICAL (t) = t;
6269
6270 /* Make it its own variant. */
6271 TYPE_MAIN_VARIANT (t) = t;
6272 TYPE_NEXT_VARIANT (t) = 0;
6273
6274 /* Note that it is now possible for TYPE_MIN_VALUE to be a value
6275 whose TREE_TYPE is not t. This can also happen in the Ada
6276 frontend when using subtypes. */
6277
6278 return t;
6279 }
6280
6281 /* Create a new variant of TYPE, equivalent but distinct. This is so
6282 the caller can modify it. TYPE_CANONICAL for the return type will
6283 be equivalent to TYPE_CANONICAL of TYPE, indicating that the types
6284 are considered equal by the language itself (or that both types
6285 require structural equality checks). */
6286
6287 tree
build_variant_type_copy(tree type)6288 build_variant_type_copy (tree type)
6289 {
6290 tree t, m = TYPE_MAIN_VARIANT (type);
6291
6292 t = build_distinct_type_copy (type);
6293
6294 /* Since we're building a variant, assume that it is a non-semantic
6295 variant. This also propagates TYPE_STRUCTURAL_EQUALITY_P. */
6296 TYPE_CANONICAL (t) = TYPE_CANONICAL (type);
6297
6298 /* Add the new type to the chain of variants of TYPE. */
6299 TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (m);
6300 TYPE_NEXT_VARIANT (m) = t;
6301 TYPE_MAIN_VARIANT (t) = m;
6302
6303 return t;
6304 }
6305
6306 /* Return true if the from tree in both tree maps are equal. */
6307
6308 int
tree_map_base_eq(const void * va,const void * vb)6309 tree_map_base_eq (const void *va, const void *vb)
6310 {
6311 const struct tree_map_base *const a = (const struct tree_map_base *) va,
6312 *const b = (const struct tree_map_base *) vb;
6313 return (a->from == b->from);
6314 }
6315
6316 /* Hash a from tree in a tree_base_map. */
6317
6318 unsigned int
tree_map_base_hash(const void * item)6319 tree_map_base_hash (const void *item)
6320 {
6321 return htab_hash_pointer (((const struct tree_map_base *)item)->from);
6322 }
6323
6324 /* Return true if this tree map structure is marked for garbage collection
6325 purposes. We simply return true if the from tree is marked, so that this
6326 structure goes away when the from tree goes away. */
6327
6328 int
tree_map_base_marked_p(const void * p)6329 tree_map_base_marked_p (const void *p)
6330 {
6331 return ggc_marked_p (((const struct tree_map_base *) p)->from);
6332 }
6333
6334 /* Hash a from tree in a tree_map. */
6335
6336 unsigned int
tree_map_hash(const void * item)6337 tree_map_hash (const void *item)
6338 {
6339 return (((const struct tree_map *) item)->hash);
6340 }
6341
6342 /* Hash a from tree in a tree_decl_map. */
6343
6344 unsigned int
tree_decl_map_hash(const void * item)6345 tree_decl_map_hash (const void *item)
6346 {
6347 return DECL_UID (((const struct tree_decl_map *) item)->base.from);
6348 }
6349
6350 /* Return the initialization priority for DECL. */
6351
6352 priority_type
decl_init_priority_lookup(tree decl)6353 decl_init_priority_lookup (tree decl)
6354 {
6355 struct tree_priority_map *h;
6356 struct tree_map_base in;
6357
6358 gcc_assert (VAR_OR_FUNCTION_DECL_P (decl));
6359 in.from = decl;
6360 h = (struct tree_priority_map *) htab_find (init_priority_for_decl, &in);
6361 return h ? h->init : DEFAULT_INIT_PRIORITY;
6362 }
6363
6364 /* Return the finalization priority for DECL. */
6365
6366 priority_type
decl_fini_priority_lookup(tree decl)6367 decl_fini_priority_lookup (tree decl)
6368 {
6369 struct tree_priority_map *h;
6370 struct tree_map_base in;
6371
6372 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL);
6373 in.from = decl;
6374 h = (struct tree_priority_map *) htab_find (init_priority_for_decl, &in);
6375 return h ? h->fini : DEFAULT_INIT_PRIORITY;
6376 }
6377
6378 /* Return the initialization and finalization priority information for
6379 DECL. If there is no previous priority information, a freshly
6380 allocated structure is returned. */
6381
6382 static struct tree_priority_map *
decl_priority_info(tree decl)6383 decl_priority_info (tree decl)
6384 {
6385 struct tree_priority_map in;
6386 struct tree_priority_map *h;
6387 void **loc;
6388
6389 in.base.from = decl;
6390 loc = htab_find_slot (init_priority_for_decl, &in, INSERT);
6391 h = (struct tree_priority_map *) *loc;
6392 if (!h)
6393 {
6394 h = ggc_alloc_cleared_tree_priority_map ();
6395 *loc = h;
6396 h->base.from = decl;
6397 h->init = DEFAULT_INIT_PRIORITY;
6398 h->fini = DEFAULT_INIT_PRIORITY;
6399 }
6400
6401 return h;
6402 }
6403
6404 /* Set the initialization priority for DECL to PRIORITY. */
6405
6406 void
decl_init_priority_insert(tree decl,priority_type priority)6407 decl_init_priority_insert (tree decl, priority_type priority)
6408 {
6409 struct tree_priority_map *h;
6410
6411 gcc_assert (VAR_OR_FUNCTION_DECL_P (decl));
6412 if (priority == DEFAULT_INIT_PRIORITY)
6413 return;
6414 h = decl_priority_info (decl);
6415 h->init = priority;
6416 }
6417
6418 /* Set the finalization priority for DECL to PRIORITY. */
6419
6420 void
decl_fini_priority_insert(tree decl,priority_type priority)6421 decl_fini_priority_insert (tree decl, priority_type priority)
6422 {
6423 struct tree_priority_map *h;
6424
6425 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL);
6426 if (priority == DEFAULT_INIT_PRIORITY)
6427 return;
6428 h = decl_priority_info (decl);
6429 h->fini = priority;
6430 }
6431
6432 /* Print out the statistics for the DECL_DEBUG_EXPR hash table. */
6433
6434 static void
print_debug_expr_statistics(void)6435 print_debug_expr_statistics (void)
6436 {
6437 fprintf (stderr, "DECL_DEBUG_EXPR hash: size %ld, %ld elements, %f collisions\n",
6438 (long) htab_size (debug_expr_for_decl),
6439 (long) htab_elements (debug_expr_for_decl),
6440 htab_collisions (debug_expr_for_decl));
6441 }
6442
6443 /* Print out the statistics for the DECL_VALUE_EXPR hash table. */
6444
6445 static void
print_value_expr_statistics(void)6446 print_value_expr_statistics (void)
6447 {
6448 fprintf (stderr, "DECL_VALUE_EXPR hash: size %ld, %ld elements, %f collisions\n",
6449 (long) htab_size (value_expr_for_decl),
6450 (long) htab_elements (value_expr_for_decl),
6451 htab_collisions (value_expr_for_decl));
6452 }
6453
6454 /* Lookup a debug expression for FROM, and return it if we find one. */
6455
6456 tree
decl_debug_expr_lookup(tree from)6457 decl_debug_expr_lookup (tree from)
6458 {
6459 struct tree_decl_map *h, in;
6460 in.base.from = from;
6461
6462 h = (struct tree_decl_map *)
6463 htab_find_with_hash (debug_expr_for_decl, &in, DECL_UID (from));
6464 if (h)
6465 return h->to;
6466 return NULL_TREE;
6467 }
6468
6469 /* Insert a mapping FROM->TO in the debug expression hashtable. */
6470
6471 void
decl_debug_expr_insert(tree from,tree to)6472 decl_debug_expr_insert (tree from, tree to)
6473 {
6474 struct tree_decl_map *h;
6475 void **loc;
6476
6477 h = ggc_alloc_tree_decl_map ();
6478 h->base.from = from;
6479 h->to = to;
6480 loc = htab_find_slot_with_hash (debug_expr_for_decl, h, DECL_UID (from),
6481 INSERT);
6482 *(struct tree_decl_map **) loc = h;
6483 }
6484
6485 /* Lookup a value expression for FROM, and return it if we find one. */
6486
6487 tree
decl_value_expr_lookup(tree from)6488 decl_value_expr_lookup (tree from)
6489 {
6490 struct tree_decl_map *h, in;
6491 in.base.from = from;
6492
6493 h = (struct tree_decl_map *)
6494 htab_find_with_hash (value_expr_for_decl, &in, DECL_UID (from));
6495 if (h)
6496 return h->to;
6497 return NULL_TREE;
6498 }
6499
6500 /* Insert a mapping FROM->TO in the value expression hashtable. */
6501
6502 void
decl_value_expr_insert(tree from,tree to)6503 decl_value_expr_insert (tree from, tree to)
6504 {
6505 struct tree_decl_map *h;
6506 void **loc;
6507
6508 h = ggc_alloc_tree_decl_map ();
6509 h->base.from = from;
6510 h->to = to;
6511 loc = htab_find_slot_with_hash (value_expr_for_decl, h, DECL_UID (from),
6512 INSERT);
6513 *(struct tree_decl_map **) loc = h;
6514 }
6515
6516 /* Lookup a vector of debug arguments for FROM, and return it if we
6517 find one. */
6518
6519 vec<tree, va_gc> **
decl_debug_args_lookup(tree from)6520 decl_debug_args_lookup (tree from)
6521 {
6522 struct tree_vec_map *h, in;
6523
6524 if (!DECL_HAS_DEBUG_ARGS_P (from))
6525 return NULL;
6526 gcc_checking_assert (debug_args_for_decl != NULL);
6527 in.base.from = from;
6528 h = (struct tree_vec_map *)
6529 htab_find_with_hash (debug_args_for_decl, &in, DECL_UID (from));
6530 if (h)
6531 return &h->to;
6532 return NULL;
6533 }
6534
6535 /* Insert a mapping FROM->empty vector of debug arguments in the value
6536 expression hashtable. */
6537
6538 vec<tree, va_gc> **
decl_debug_args_insert(tree from)6539 decl_debug_args_insert (tree from)
6540 {
6541 struct tree_vec_map *h;
6542 void **loc;
6543
6544 if (DECL_HAS_DEBUG_ARGS_P (from))
6545 return decl_debug_args_lookup (from);
6546 if (debug_args_for_decl == NULL)
6547 debug_args_for_decl = htab_create_ggc (64, tree_vec_map_hash,
6548 tree_vec_map_eq, 0);
6549 h = ggc_alloc_tree_vec_map ();
6550 h->base.from = from;
6551 h->to = NULL;
6552 loc = htab_find_slot_with_hash (debug_args_for_decl, h, DECL_UID (from),
6553 INSERT);
6554 *(struct tree_vec_map **) loc = h;
6555 DECL_HAS_DEBUG_ARGS_P (from) = 1;
6556 return &h->to;
6557 }
6558
6559 /* Hashing of types so that we don't make duplicates.
6560 The entry point is `type_hash_canon'. */
6561
6562 /* Compute a hash code for a list of types (chain of TREE_LIST nodes
6563 with types in the TREE_VALUE slots), by adding the hash codes
6564 of the individual types. */
6565
6566 static unsigned int
type_hash_list(const_tree list,hashval_t hashcode)6567 type_hash_list (const_tree list, hashval_t hashcode)
6568 {
6569 const_tree tail;
6570
6571 for (tail = list; tail; tail = TREE_CHAIN (tail))
6572 if (TREE_VALUE (tail) != error_mark_node)
6573 hashcode = iterative_hash_object (TYPE_HASH (TREE_VALUE (tail)),
6574 hashcode);
6575
6576 return hashcode;
6577 }
6578
6579 /* These are the Hashtable callback functions. */
6580
6581 /* Returns true iff the types are equivalent. */
6582
6583 static int
type_hash_eq(const void * va,const void * vb)6584 type_hash_eq (const void *va, const void *vb)
6585 {
6586 const struct type_hash *const a = (const struct type_hash *) va,
6587 *const b = (const struct type_hash *) vb;
6588
6589 /* First test the things that are the same for all types. */
6590 if (a->hash != b->hash
6591 || TREE_CODE (a->type) != TREE_CODE (b->type)
6592 || TREE_TYPE (a->type) != TREE_TYPE (b->type)
6593 || !attribute_list_equal (TYPE_ATTRIBUTES (a->type),
6594 TYPE_ATTRIBUTES (b->type))
6595 || (TREE_CODE (a->type) != COMPLEX_TYPE
6596 && TYPE_NAME (a->type) != TYPE_NAME (b->type)))
6597 return 0;
6598
6599 /* Be careful about comparing arrays before and after the element type
6600 has been completed; don't compare TYPE_ALIGN unless both types are
6601 complete. */
6602 if (COMPLETE_TYPE_P (a->type) && COMPLETE_TYPE_P (b->type)
6603 && (TYPE_ALIGN (a->type) != TYPE_ALIGN (b->type)
6604 || TYPE_MODE (a->type) != TYPE_MODE (b->type)))
6605 return 0;
6606
6607 switch (TREE_CODE (a->type))
6608 {
6609 case VOID_TYPE:
6610 case COMPLEX_TYPE:
6611 case POINTER_TYPE:
6612 case REFERENCE_TYPE:
6613 case NULLPTR_TYPE:
6614 return 1;
6615
6616 case VECTOR_TYPE:
6617 return TYPE_VECTOR_SUBPARTS (a->type) == TYPE_VECTOR_SUBPARTS (b->type);
6618
6619 case ENUMERAL_TYPE:
6620 if (TYPE_VALUES (a->type) != TYPE_VALUES (b->type)
6621 && !(TYPE_VALUES (a->type)
6622 && TREE_CODE (TYPE_VALUES (a->type)) == TREE_LIST
6623 && TYPE_VALUES (b->type)
6624 && TREE_CODE (TYPE_VALUES (b->type)) == TREE_LIST
6625 && type_list_equal (TYPE_VALUES (a->type),
6626 TYPE_VALUES (b->type))))
6627 return 0;
6628
6629 /* ... fall through ... */
6630
6631 case INTEGER_TYPE:
6632 case REAL_TYPE:
6633 case BOOLEAN_TYPE:
6634 return ((TYPE_MAX_VALUE (a->type) == TYPE_MAX_VALUE (b->type)
6635 || tree_int_cst_equal (TYPE_MAX_VALUE (a->type),
6636 TYPE_MAX_VALUE (b->type)))
6637 && (TYPE_MIN_VALUE (a->type) == TYPE_MIN_VALUE (b->type)
6638 || tree_int_cst_equal (TYPE_MIN_VALUE (a->type),
6639 TYPE_MIN_VALUE (b->type))));
6640
6641 case FIXED_POINT_TYPE:
6642 return TYPE_SATURATING (a->type) == TYPE_SATURATING (b->type);
6643
6644 case OFFSET_TYPE:
6645 return TYPE_OFFSET_BASETYPE (a->type) == TYPE_OFFSET_BASETYPE (b->type);
6646
6647 case METHOD_TYPE:
6648 if (TYPE_METHOD_BASETYPE (a->type) == TYPE_METHOD_BASETYPE (b->type)
6649 && (TYPE_ARG_TYPES (a->type) == TYPE_ARG_TYPES (b->type)
6650 || (TYPE_ARG_TYPES (a->type)
6651 && TREE_CODE (TYPE_ARG_TYPES (a->type)) == TREE_LIST
6652 && TYPE_ARG_TYPES (b->type)
6653 && TREE_CODE (TYPE_ARG_TYPES (b->type)) == TREE_LIST
6654 && type_list_equal (TYPE_ARG_TYPES (a->type),
6655 TYPE_ARG_TYPES (b->type)))))
6656 break;
6657 return 0;
6658 case ARRAY_TYPE:
6659 return TYPE_DOMAIN (a->type) == TYPE_DOMAIN (b->type);
6660
6661 case RECORD_TYPE:
6662 case UNION_TYPE:
6663 case QUAL_UNION_TYPE:
6664 return (TYPE_FIELDS (a->type) == TYPE_FIELDS (b->type)
6665 || (TYPE_FIELDS (a->type)
6666 && TREE_CODE (TYPE_FIELDS (a->type)) == TREE_LIST
6667 && TYPE_FIELDS (b->type)
6668 && TREE_CODE (TYPE_FIELDS (b->type)) == TREE_LIST
6669 && type_list_equal (TYPE_FIELDS (a->type),
6670 TYPE_FIELDS (b->type))));
6671
6672 case FUNCTION_TYPE:
6673 if (TYPE_ARG_TYPES (a->type) == TYPE_ARG_TYPES (b->type)
6674 || (TYPE_ARG_TYPES (a->type)
6675 && TREE_CODE (TYPE_ARG_TYPES (a->type)) == TREE_LIST
6676 && TYPE_ARG_TYPES (b->type)
6677 && TREE_CODE (TYPE_ARG_TYPES (b->type)) == TREE_LIST
6678 && type_list_equal (TYPE_ARG_TYPES (a->type),
6679 TYPE_ARG_TYPES (b->type))))
6680 break;
6681 return 0;
6682
6683 default:
6684 return 0;
6685 }
6686
6687 if (lang_hooks.types.type_hash_eq != NULL)
6688 return lang_hooks.types.type_hash_eq (a->type, b->type);
6689
6690 return 1;
6691 }
6692
6693 /* Return the cached hash value. */
6694
6695 static hashval_t
type_hash_hash(const void * item)6696 type_hash_hash (const void *item)
6697 {
6698 return ((const struct type_hash *) item)->hash;
6699 }
6700
6701 /* Look in the type hash table for a type isomorphic to TYPE.
6702 If one is found, return it. Otherwise return 0. */
6703
6704 static tree
type_hash_lookup(hashval_t hashcode,tree type)6705 type_hash_lookup (hashval_t hashcode, tree type)
6706 {
6707 struct type_hash *h, in;
6708
6709 /* The TYPE_ALIGN field of a type is set by layout_type(), so we
6710 must call that routine before comparing TYPE_ALIGNs. */
6711 layout_type (type);
6712
6713 in.hash = hashcode;
6714 in.type = type;
6715
6716 h = (struct type_hash *) htab_find_with_hash (type_hash_table, &in,
6717 hashcode);
6718 if (h)
6719 return h->type;
6720 return NULL_TREE;
6721 }
6722
6723 /* Add an entry to the type-hash-table
6724 for a type TYPE whose hash code is HASHCODE. */
6725
6726 static void
type_hash_add(hashval_t hashcode,tree type)6727 type_hash_add (hashval_t hashcode, tree type)
6728 {
6729 struct type_hash *h;
6730 void **loc;
6731
6732 h = ggc_alloc_type_hash ();
6733 h->hash = hashcode;
6734 h->type = type;
6735 loc = htab_find_slot_with_hash (type_hash_table, h, hashcode, INSERT);
6736 *loc = (void *)h;
6737 }
6738
6739 /* Given TYPE, and HASHCODE its hash code, return the canonical
6740 object for an identical type if one already exists.
6741 Otherwise, return TYPE, and record it as the canonical object.
6742
6743 To use this function, first create a type of the sort you want.
6744 Then compute its hash code from the fields of the type that
6745 make it different from other similar types.
6746 Then call this function and use the value. */
6747
6748 tree
type_hash_canon(unsigned int hashcode,tree type)6749 type_hash_canon (unsigned int hashcode, tree type)
6750 {
6751 tree t1;
6752
6753 /* The hash table only contains main variants, so ensure that's what we're
6754 being passed. */
6755 gcc_assert (TYPE_MAIN_VARIANT (type) == type);
6756
6757 /* See if the type is in the hash table already. If so, return it.
6758 Otherwise, add the type. */
6759 t1 = type_hash_lookup (hashcode, type);
6760 if (t1 != 0)
6761 {
6762 if (GATHER_STATISTICS)
6763 {
6764 tree_code_counts[(int) TREE_CODE (type)]--;
6765 tree_node_counts[(int) t_kind]--;
6766 tree_node_sizes[(int) t_kind] -= sizeof (struct tree_type_non_common);
6767 }
6768 return t1;
6769 }
6770 else
6771 {
6772 type_hash_add (hashcode, type);
6773 return type;
6774 }
6775 }
6776
6777 /* See if the data pointed to by the type hash table is marked. We consider
6778 it marked if the type is marked or if a debug type number or symbol
6779 table entry has been made for the type. */
6780
6781 static int
type_hash_marked_p(const void * p)6782 type_hash_marked_p (const void *p)
6783 {
6784 const_tree const type = ((const struct type_hash *) p)->type;
6785
6786 return ggc_marked_p (type);
6787 }
6788
6789 static void
print_type_hash_statistics(void)6790 print_type_hash_statistics (void)
6791 {
6792 fprintf (stderr, "Type hash: size %ld, %ld elements, %f collisions\n",
6793 (long) htab_size (type_hash_table),
6794 (long) htab_elements (type_hash_table),
6795 htab_collisions (type_hash_table));
6796 }
6797
6798 /* Compute a hash code for a list of attributes (chain of TREE_LIST nodes
6799 with names in the TREE_PURPOSE slots and args in the TREE_VALUE slots),
6800 by adding the hash codes of the individual attributes. */
6801
6802 static unsigned int
attribute_hash_list(const_tree list,hashval_t hashcode)6803 attribute_hash_list (const_tree list, hashval_t hashcode)
6804 {
6805 const_tree tail;
6806
6807 for (tail = list; tail; tail = TREE_CHAIN (tail))
6808 /* ??? Do we want to add in TREE_VALUE too? */
6809 hashcode = iterative_hash_object
6810 (IDENTIFIER_HASH_VALUE (get_attribute_name (tail)), hashcode);
6811 return hashcode;
6812 }
6813
6814 /* Given two lists of attributes, return true if list l2 is
6815 equivalent to l1. */
6816
6817 int
attribute_list_equal(const_tree l1,const_tree l2)6818 attribute_list_equal (const_tree l1, const_tree l2)
6819 {
6820 if (l1 == l2)
6821 return 1;
6822
6823 return attribute_list_contained (l1, l2)
6824 && attribute_list_contained (l2, l1);
6825 }
6826
6827 /* Given two lists of attributes, return true if list L2 is
6828 completely contained within L1. */
6829 /* ??? This would be faster if attribute names were stored in a canonicalized
6830 form. Otherwise, if L1 uses `foo' and L2 uses `__foo__', the long method
6831 must be used to show these elements are equivalent (which they are). */
6832 /* ??? It's not clear that attributes with arguments will always be handled
6833 correctly. */
6834
6835 int
attribute_list_contained(const_tree l1,const_tree l2)6836 attribute_list_contained (const_tree l1, const_tree l2)
6837 {
6838 const_tree t1, t2;
6839
6840 /* First check the obvious, maybe the lists are identical. */
6841 if (l1 == l2)
6842 return 1;
6843
6844 /* Maybe the lists are similar. */
6845 for (t1 = l1, t2 = l2;
6846 t1 != 0 && t2 != 0
6847 && get_attribute_name (t1) == get_attribute_name (t2)
6848 && TREE_VALUE (t1) == TREE_VALUE (t2);
6849 t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2))
6850 ;
6851
6852 /* Maybe the lists are equal. */
6853 if (t1 == 0 && t2 == 0)
6854 return 1;
6855
6856 for (; t2 != 0; t2 = TREE_CHAIN (t2))
6857 {
6858 const_tree attr;
6859 /* This CONST_CAST is okay because lookup_attribute does not
6860 modify its argument and the return value is assigned to a
6861 const_tree. */
6862 for (attr = lookup_ident_attribute (get_attribute_name (t2),
6863 CONST_CAST_TREE (l1));
6864 attr != NULL_TREE && !attribute_value_equal (t2, attr);
6865 attr = lookup_ident_attribute (get_attribute_name (t2),
6866 TREE_CHAIN (attr)))
6867 ;
6868
6869 if (attr == NULL_TREE)
6870 return 0;
6871 }
6872
6873 return 1;
6874 }
6875
6876 /* Given two lists of types
6877 (chains of TREE_LIST nodes with types in the TREE_VALUE slots)
6878 return 1 if the lists contain the same types in the same order.
6879 Also, the TREE_PURPOSEs must match. */
6880
6881 int
type_list_equal(const_tree l1,const_tree l2)6882 type_list_equal (const_tree l1, const_tree l2)
6883 {
6884 const_tree t1, t2;
6885
6886 for (t1 = l1, t2 = l2; t1 && t2; t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2))
6887 if (TREE_VALUE (t1) != TREE_VALUE (t2)
6888 || (TREE_PURPOSE (t1) != TREE_PURPOSE (t2)
6889 && ! (1 == simple_cst_equal (TREE_PURPOSE (t1), TREE_PURPOSE (t2))
6890 && (TREE_TYPE (TREE_PURPOSE (t1))
6891 == TREE_TYPE (TREE_PURPOSE (t2))))))
6892 return 0;
6893
6894 return t1 == t2;
6895 }
6896
6897 /* Returns the number of arguments to the FUNCTION_TYPE or METHOD_TYPE
6898 given by TYPE. If the argument list accepts variable arguments,
6899 then this function counts only the ordinary arguments. */
6900
6901 int
type_num_arguments(const_tree type)6902 type_num_arguments (const_tree type)
6903 {
6904 int i = 0;
6905 tree t;
6906
6907 for (t = TYPE_ARG_TYPES (type); t; t = TREE_CHAIN (t))
6908 /* If the function does not take a variable number of arguments,
6909 the last element in the list will have type `void'. */
6910 if (VOID_TYPE_P (TREE_VALUE (t)))
6911 break;
6912 else
6913 ++i;
6914
6915 return i;
6916 }
6917
6918 /* Nonzero if integer constants T1 and T2
6919 represent the same constant value. */
6920
6921 int
tree_int_cst_equal(const_tree t1,const_tree t2)6922 tree_int_cst_equal (const_tree t1, const_tree t2)
6923 {
6924 if (t1 == t2)
6925 return 1;
6926
6927 if (t1 == 0 || t2 == 0)
6928 return 0;
6929
6930 if (TREE_CODE (t1) == INTEGER_CST
6931 && TREE_CODE (t2) == INTEGER_CST
6932 && TREE_INT_CST_LOW (t1) == TREE_INT_CST_LOW (t2)
6933 && TREE_INT_CST_HIGH (t1) == TREE_INT_CST_HIGH (t2))
6934 return 1;
6935
6936 return 0;
6937 }
6938
6939 /* Nonzero if integer constants T1 and T2 represent values that satisfy <.
6940 The precise way of comparison depends on their data type. */
6941
6942 int
tree_int_cst_lt(const_tree t1,const_tree t2)6943 tree_int_cst_lt (const_tree t1, const_tree t2)
6944 {
6945 if (t1 == t2)
6946 return 0;
6947
6948 if (TYPE_UNSIGNED (TREE_TYPE (t1)) != TYPE_UNSIGNED (TREE_TYPE (t2)))
6949 {
6950 int t1_sgn = tree_int_cst_sgn (t1);
6951 int t2_sgn = tree_int_cst_sgn (t2);
6952
6953 if (t1_sgn < t2_sgn)
6954 return 1;
6955 else if (t1_sgn > t2_sgn)
6956 return 0;
6957 /* Otherwise, both are non-negative, so we compare them as
6958 unsigned just in case one of them would overflow a signed
6959 type. */
6960 }
6961 else if (!TYPE_UNSIGNED (TREE_TYPE (t1)))
6962 return INT_CST_LT (t1, t2);
6963
6964 return INT_CST_LT_UNSIGNED (t1, t2);
6965 }
6966
6967 /* Returns -1 if T1 < T2, 0 if T1 == T2, and 1 if T1 > T2. */
6968
6969 int
tree_int_cst_compare(const_tree t1,const_tree t2)6970 tree_int_cst_compare (const_tree t1, const_tree t2)
6971 {
6972 if (tree_int_cst_lt (t1, t2))
6973 return -1;
6974 else if (tree_int_cst_lt (t2, t1))
6975 return 1;
6976 else
6977 return 0;
6978 }
6979
6980 /* Return true if T is an INTEGER_CST whose numerical value (extended
6981 according to TYPE_UNSIGNED) fits in a signed HOST_WIDE_INT. */
6982
6983 bool
tree_fits_shwi_p(const_tree t)6984 tree_fits_shwi_p (const_tree t)
6985 {
6986 return (t != NULL_TREE
6987 && TREE_CODE (t) == INTEGER_CST
6988 && ((TREE_INT_CST_HIGH (t) == 0
6989 && (HOST_WIDE_INT) TREE_INT_CST_LOW (t) >= 0)
6990 || (TREE_INT_CST_HIGH (t) == -1
6991 && (HOST_WIDE_INT) TREE_INT_CST_LOW (t) < 0
6992 && !TYPE_UNSIGNED (TREE_TYPE (t)))));
6993 }
6994
6995 /* Return true if T is an INTEGER_CST whose numerical value (extended
6996 according to TYPE_UNSIGNED) fits in an unsigned HOST_WIDE_INT. */
6997
6998 bool
tree_fits_uhwi_p(const_tree t)6999 tree_fits_uhwi_p (const_tree t)
7000 {
7001 return (t != NULL_TREE
7002 && TREE_CODE (t) == INTEGER_CST
7003 && TREE_INT_CST_HIGH (t) == 0);
7004 }
7005
7006 /* T is an INTEGER_CST whose numerical value (extended according to
7007 TYPE_UNSIGNED) fits in a signed HOST_WIDE_INT. Return that
7008 HOST_WIDE_INT. */
7009
7010 HOST_WIDE_INT
tree_to_shwi(const_tree t)7011 tree_to_shwi (const_tree t)
7012 {
7013 gcc_assert (tree_fits_shwi_p (t));
7014 return TREE_INT_CST_LOW (t);
7015 }
7016
7017 /* T is an INTEGER_CST whose numerical value (extended according to
7018 TYPE_UNSIGNED) fits in an unsigned HOST_WIDE_INT. Return that
7019 HOST_WIDE_INT. */
7020
7021 unsigned HOST_WIDE_INT
tree_to_uhwi(const_tree t)7022 tree_to_uhwi (const_tree t)
7023 {
7024 gcc_assert (tree_fits_uhwi_p (t));
7025 return TREE_INT_CST_LOW (t);
7026 }
7027
7028 /* Return the most significant (sign) bit of T. */
7029
7030 int
tree_int_cst_sign_bit(const_tree t)7031 tree_int_cst_sign_bit (const_tree t)
7032 {
7033 unsigned bitno = TYPE_PRECISION (TREE_TYPE (t)) - 1;
7034 unsigned HOST_WIDE_INT w;
7035
7036 if (bitno < HOST_BITS_PER_WIDE_INT)
7037 w = TREE_INT_CST_LOW (t);
7038 else
7039 {
7040 w = TREE_INT_CST_HIGH (t);
7041 bitno -= HOST_BITS_PER_WIDE_INT;
7042 }
7043
7044 return (w >> bitno) & 1;
7045 }
7046
7047 /* Return an indication of the sign of the integer constant T.
7048 The return value is -1 if T < 0, 0 if T == 0, and 1 if T > 0.
7049 Note that -1 will never be returned if T's type is unsigned. */
7050
7051 int
tree_int_cst_sgn(const_tree t)7052 tree_int_cst_sgn (const_tree t)
7053 {
7054 if (TREE_INT_CST_LOW (t) == 0 && TREE_INT_CST_HIGH (t) == 0)
7055 return 0;
7056 else if (TYPE_UNSIGNED (TREE_TYPE (t)))
7057 return 1;
7058 else if (TREE_INT_CST_HIGH (t) < 0)
7059 return -1;
7060 else
7061 return 1;
7062 }
7063
7064 /* Return the minimum number of bits needed to represent VALUE in a
7065 signed or unsigned type, UNSIGNEDP says which. */
7066
7067 unsigned int
tree_int_cst_min_precision(tree value,bool unsignedp)7068 tree_int_cst_min_precision (tree value, bool unsignedp)
7069 {
7070 /* If the value is negative, compute its negative minus 1. The latter
7071 adjustment is because the absolute value of the largest negative value
7072 is one larger than the largest positive value. This is equivalent to
7073 a bit-wise negation, so use that operation instead. */
7074
7075 if (tree_int_cst_sgn (value) < 0)
7076 value = fold_build1 (BIT_NOT_EXPR, TREE_TYPE (value), value);
7077
7078 /* Return the number of bits needed, taking into account the fact
7079 that we need one more bit for a signed than unsigned type.
7080 If value is 0 or -1, the minimum precision is 1 no matter
7081 whether unsignedp is true or false. */
7082
7083 if (integer_zerop (value))
7084 return 1;
7085 else
7086 return tree_floor_log2 (value) + 1 + !unsignedp;
7087 }
7088
7089 /* Return truthvalue of whether T1 is the same tree structure as T2.
7090 Return 1 if they are the same.
7091 Return 0 if they are understandably different.
7092 Return -1 if either contains tree structure not understood by
7093 this function. */
7094
7095 int
simple_cst_equal(const_tree t1,const_tree t2)7096 simple_cst_equal (const_tree t1, const_tree t2)
7097 {
7098 enum tree_code code1, code2;
7099 int cmp;
7100 int i;
7101
7102 if (t1 == t2)
7103 return 1;
7104 if (t1 == 0 || t2 == 0)
7105 return 0;
7106
7107 code1 = TREE_CODE (t1);
7108 code2 = TREE_CODE (t2);
7109
7110 if (CONVERT_EXPR_CODE_P (code1) || code1 == NON_LVALUE_EXPR)
7111 {
7112 if (CONVERT_EXPR_CODE_P (code2)
7113 || code2 == NON_LVALUE_EXPR)
7114 return simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
7115 else
7116 return simple_cst_equal (TREE_OPERAND (t1, 0), t2);
7117 }
7118
7119 else if (CONVERT_EXPR_CODE_P (code2)
7120 || code2 == NON_LVALUE_EXPR)
7121 return simple_cst_equal (t1, TREE_OPERAND (t2, 0));
7122
7123 if (code1 != code2)
7124 return 0;
7125
7126 switch (code1)
7127 {
7128 case INTEGER_CST:
7129 return (TREE_INT_CST_LOW (t1) == TREE_INT_CST_LOW (t2)
7130 && TREE_INT_CST_HIGH (t1) == TREE_INT_CST_HIGH (t2));
7131
7132 case REAL_CST:
7133 return REAL_VALUES_IDENTICAL (TREE_REAL_CST (t1), TREE_REAL_CST (t2));
7134
7135 case FIXED_CST:
7136 return FIXED_VALUES_IDENTICAL (TREE_FIXED_CST (t1), TREE_FIXED_CST (t2));
7137
7138 case STRING_CST:
7139 return (TREE_STRING_LENGTH (t1) == TREE_STRING_LENGTH (t2)
7140 && ! memcmp (TREE_STRING_POINTER (t1), TREE_STRING_POINTER (t2),
7141 TREE_STRING_LENGTH (t1)));
7142
7143 case CONSTRUCTOR:
7144 {
7145 unsigned HOST_WIDE_INT idx;
7146 vec<constructor_elt, va_gc> *v1 = CONSTRUCTOR_ELTS (t1);
7147 vec<constructor_elt, va_gc> *v2 = CONSTRUCTOR_ELTS (t2);
7148
7149 if (vec_safe_length (v1) != vec_safe_length (v2))
7150 return false;
7151
7152 for (idx = 0; idx < vec_safe_length (v1); ++idx)
7153 /* ??? Should we handle also fields here? */
7154 if (!simple_cst_equal ((*v1)[idx].value, (*v2)[idx].value))
7155 return false;
7156 return true;
7157 }
7158
7159 case SAVE_EXPR:
7160 return simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
7161
7162 case CALL_EXPR:
7163 cmp = simple_cst_equal (CALL_EXPR_FN (t1), CALL_EXPR_FN (t2));
7164 if (cmp <= 0)
7165 return cmp;
7166 if (call_expr_nargs (t1) != call_expr_nargs (t2))
7167 return 0;
7168 {
7169 const_tree arg1, arg2;
7170 const_call_expr_arg_iterator iter1, iter2;
7171 for (arg1 = first_const_call_expr_arg (t1, &iter1),
7172 arg2 = first_const_call_expr_arg (t2, &iter2);
7173 arg1 && arg2;
7174 arg1 = next_const_call_expr_arg (&iter1),
7175 arg2 = next_const_call_expr_arg (&iter2))
7176 {
7177 cmp = simple_cst_equal (arg1, arg2);
7178 if (cmp <= 0)
7179 return cmp;
7180 }
7181 return arg1 == arg2;
7182 }
7183
7184 case TARGET_EXPR:
7185 /* Special case: if either target is an unallocated VAR_DECL,
7186 it means that it's going to be unified with whatever the
7187 TARGET_EXPR is really supposed to initialize, so treat it
7188 as being equivalent to anything. */
7189 if ((TREE_CODE (TREE_OPERAND (t1, 0)) == VAR_DECL
7190 && DECL_NAME (TREE_OPERAND (t1, 0)) == NULL_TREE
7191 && !DECL_RTL_SET_P (TREE_OPERAND (t1, 0)))
7192 || (TREE_CODE (TREE_OPERAND (t2, 0)) == VAR_DECL
7193 && DECL_NAME (TREE_OPERAND (t2, 0)) == NULL_TREE
7194 && !DECL_RTL_SET_P (TREE_OPERAND (t2, 0))))
7195 cmp = 1;
7196 else
7197 cmp = simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
7198
7199 if (cmp <= 0)
7200 return cmp;
7201
7202 return simple_cst_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1));
7203
7204 case WITH_CLEANUP_EXPR:
7205 cmp = simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
7206 if (cmp <= 0)
7207 return cmp;
7208
7209 return simple_cst_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t1, 1));
7210
7211 case COMPONENT_REF:
7212 if (TREE_OPERAND (t1, 1) == TREE_OPERAND (t2, 1))
7213 return simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
7214
7215 return 0;
7216
7217 case VAR_DECL:
7218 case PARM_DECL:
7219 case CONST_DECL:
7220 case FUNCTION_DECL:
7221 return 0;
7222
7223 default:
7224 break;
7225 }
7226
7227 /* This general rule works for most tree codes. All exceptions should be
7228 handled above. If this is a language-specific tree code, we can't
7229 trust what might be in the operand, so say we don't know
7230 the situation. */
7231 if ((int) code1 >= (int) LAST_AND_UNUSED_TREE_CODE)
7232 return -1;
7233
7234 switch (TREE_CODE_CLASS (code1))
7235 {
7236 case tcc_unary:
7237 case tcc_binary:
7238 case tcc_comparison:
7239 case tcc_expression:
7240 case tcc_reference:
7241 case tcc_statement:
7242 cmp = 1;
7243 for (i = 0; i < TREE_CODE_LENGTH (code1); i++)
7244 {
7245 cmp = simple_cst_equal (TREE_OPERAND (t1, i), TREE_OPERAND (t2, i));
7246 if (cmp <= 0)
7247 return cmp;
7248 }
7249
7250 return cmp;
7251
7252 default:
7253 return -1;
7254 }
7255 }
7256
7257 /* Compare the value of T, an INTEGER_CST, with U, an unsigned integer value.
7258 Return -1, 0, or 1 if the value of T is less than, equal to, or greater
7259 than U, respectively. */
7260
7261 int
compare_tree_int(const_tree t,unsigned HOST_WIDE_INT u)7262 compare_tree_int (const_tree t, unsigned HOST_WIDE_INT u)
7263 {
7264 if (tree_int_cst_sgn (t) < 0)
7265 return -1;
7266 else if (TREE_INT_CST_HIGH (t) != 0)
7267 return 1;
7268 else if (TREE_INT_CST_LOW (t) == u)
7269 return 0;
7270 else if (TREE_INT_CST_LOW (t) < u)
7271 return -1;
7272 else
7273 return 1;
7274 }
7275
7276 /* Return true if SIZE represents a constant size that is in bounds of
7277 what the middle-end and the backend accepts (covering not more than
7278 half of the address-space). */
7279
7280 bool
valid_constant_size_p(const_tree size)7281 valid_constant_size_p (const_tree size)
7282 {
7283 if (! tree_fits_uhwi_p (size)
7284 || TREE_OVERFLOW (size)
7285 || tree_int_cst_sign_bit (size) != 0)
7286 return false;
7287 return true;
7288 }
7289
7290 /* Return the precision of the type, or for a complex or vector type the
7291 precision of the type of its elements. */
7292
7293 unsigned int
element_precision(const_tree type)7294 element_precision (const_tree type)
7295 {
7296 enum tree_code code = TREE_CODE (type);
7297 if (code == COMPLEX_TYPE || code == VECTOR_TYPE)
7298 type = TREE_TYPE (type);
7299
7300 return TYPE_PRECISION (type);
7301 }
7302
7303 /* Return true if CODE represents an associative tree code. Otherwise
7304 return false. */
7305 bool
associative_tree_code(enum tree_code code)7306 associative_tree_code (enum tree_code code)
7307 {
7308 switch (code)
7309 {
7310 case BIT_IOR_EXPR:
7311 case BIT_AND_EXPR:
7312 case BIT_XOR_EXPR:
7313 case PLUS_EXPR:
7314 case MULT_EXPR:
7315 case MIN_EXPR:
7316 case MAX_EXPR:
7317 return true;
7318
7319 default:
7320 break;
7321 }
7322 return false;
7323 }
7324
7325 /* Return true if CODE represents a commutative tree code. Otherwise
7326 return false. */
7327 bool
commutative_tree_code(enum tree_code code)7328 commutative_tree_code (enum tree_code code)
7329 {
7330 switch (code)
7331 {
7332 case PLUS_EXPR:
7333 case MULT_EXPR:
7334 case MULT_HIGHPART_EXPR:
7335 case MIN_EXPR:
7336 case MAX_EXPR:
7337 case BIT_IOR_EXPR:
7338 case BIT_XOR_EXPR:
7339 case BIT_AND_EXPR:
7340 case NE_EXPR:
7341 case EQ_EXPR:
7342 case UNORDERED_EXPR:
7343 case ORDERED_EXPR:
7344 case UNEQ_EXPR:
7345 case LTGT_EXPR:
7346 case TRUTH_AND_EXPR:
7347 case TRUTH_XOR_EXPR:
7348 case TRUTH_OR_EXPR:
7349 case WIDEN_MULT_EXPR:
7350 case VEC_WIDEN_MULT_HI_EXPR:
7351 case VEC_WIDEN_MULT_LO_EXPR:
7352 case VEC_WIDEN_MULT_EVEN_EXPR:
7353 case VEC_WIDEN_MULT_ODD_EXPR:
7354 return true;
7355
7356 default:
7357 break;
7358 }
7359 return false;
7360 }
7361
7362 /* Return true if CODE represents a ternary tree code for which the
7363 first two operands are commutative. Otherwise return false. */
7364 bool
commutative_ternary_tree_code(enum tree_code code)7365 commutative_ternary_tree_code (enum tree_code code)
7366 {
7367 switch (code)
7368 {
7369 case WIDEN_MULT_PLUS_EXPR:
7370 case WIDEN_MULT_MINUS_EXPR:
7371 return true;
7372
7373 default:
7374 break;
7375 }
7376 return false;
7377 }
7378
7379 /* Generate a hash value for an expression. This can be used iteratively
7380 by passing a previous result as the VAL argument.
7381
7382 This function is intended to produce the same hash for expressions which
7383 would compare equal using operand_equal_p. */
7384
7385 hashval_t
iterative_hash_expr(const_tree t,hashval_t val)7386 iterative_hash_expr (const_tree t, hashval_t val)
7387 {
7388 int i;
7389 enum tree_code code;
7390 char tclass;
7391
7392 if (t == NULL_TREE)
7393 return iterative_hash_hashval_t (0, val);
7394
7395 code = TREE_CODE (t);
7396
7397 switch (code)
7398 {
7399 /* Alas, constants aren't shared, so we can't rely on pointer
7400 identity. */
7401 case INTEGER_CST:
7402 val = iterative_hash_host_wide_int (TREE_INT_CST_LOW (t), val);
7403 return iterative_hash_host_wide_int (TREE_INT_CST_HIGH (t), val);
7404 case REAL_CST:
7405 {
7406 unsigned int val2 = real_hash (TREE_REAL_CST_PTR (t));
7407
7408 return iterative_hash_hashval_t (val2, val);
7409 }
7410 case FIXED_CST:
7411 {
7412 unsigned int val2 = fixed_hash (TREE_FIXED_CST_PTR (t));
7413
7414 return iterative_hash_hashval_t (val2, val);
7415 }
7416 case STRING_CST:
7417 return iterative_hash (TREE_STRING_POINTER (t),
7418 TREE_STRING_LENGTH (t), val);
7419 case COMPLEX_CST:
7420 val = iterative_hash_expr (TREE_REALPART (t), val);
7421 return iterative_hash_expr (TREE_IMAGPART (t), val);
7422 case VECTOR_CST:
7423 {
7424 unsigned i;
7425 for (i = 0; i < VECTOR_CST_NELTS (t); ++i)
7426 val = iterative_hash_expr (VECTOR_CST_ELT (t, i), val);
7427 return val;
7428 }
7429 case SSA_NAME:
7430 /* We can just compare by pointer. */
7431 return iterative_hash_host_wide_int (SSA_NAME_VERSION (t), val);
7432 case PLACEHOLDER_EXPR:
7433 /* The node itself doesn't matter. */
7434 return val;
7435 case TREE_LIST:
7436 /* A list of expressions, for a CALL_EXPR or as the elements of a
7437 VECTOR_CST. */
7438 for (; t; t = TREE_CHAIN (t))
7439 val = iterative_hash_expr (TREE_VALUE (t), val);
7440 return val;
7441 case CONSTRUCTOR:
7442 {
7443 unsigned HOST_WIDE_INT idx;
7444 tree field, value;
7445 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t), idx, field, value)
7446 {
7447 val = iterative_hash_expr (field, val);
7448 val = iterative_hash_expr (value, val);
7449 }
7450 return val;
7451 }
7452 case FUNCTION_DECL:
7453 /* When referring to a built-in FUNCTION_DECL, use the __builtin__ form.
7454 Otherwise nodes that compare equal according to operand_equal_p might
7455 get different hash codes. However, don't do this for machine specific
7456 or front end builtins, since the function code is overloaded in those
7457 cases. */
7458 if (DECL_BUILT_IN_CLASS (t) == BUILT_IN_NORMAL
7459 && builtin_decl_explicit_p (DECL_FUNCTION_CODE (t)))
7460 {
7461 t = builtin_decl_explicit (DECL_FUNCTION_CODE (t));
7462 code = TREE_CODE (t);
7463 }
7464 /* FALL THROUGH */
7465 default:
7466 tclass = TREE_CODE_CLASS (code);
7467
7468 if (tclass == tcc_declaration)
7469 {
7470 /* DECL's have a unique ID */
7471 val = iterative_hash_host_wide_int (DECL_UID (t), val);
7472 }
7473 else
7474 {
7475 gcc_assert (IS_EXPR_CODE_CLASS (tclass));
7476
7477 val = iterative_hash_object (code, val);
7478
7479 /* Don't hash the type, that can lead to having nodes which
7480 compare equal according to operand_equal_p, but which
7481 have different hash codes. */
7482 if (CONVERT_EXPR_CODE_P (code)
7483 || code == NON_LVALUE_EXPR)
7484 {
7485 /* Make sure to include signness in the hash computation. */
7486 val += TYPE_UNSIGNED (TREE_TYPE (t));
7487 val = iterative_hash_expr (TREE_OPERAND (t, 0), val);
7488 }
7489
7490 else if (commutative_tree_code (code))
7491 {
7492 /* It's a commutative expression. We want to hash it the same
7493 however it appears. We do this by first hashing both operands
7494 and then rehashing based on the order of their independent
7495 hashes. */
7496 hashval_t one = iterative_hash_expr (TREE_OPERAND (t, 0), 0);
7497 hashval_t two = iterative_hash_expr (TREE_OPERAND (t, 1), 0);
7498 hashval_t t;
7499
7500 if (one > two)
7501 t = one, one = two, two = t;
7502
7503 val = iterative_hash_hashval_t (one, val);
7504 val = iterative_hash_hashval_t (two, val);
7505 }
7506 else
7507 for (i = TREE_OPERAND_LENGTH (t) - 1; i >= 0; --i)
7508 val = iterative_hash_expr (TREE_OPERAND (t, i), val);
7509 }
7510 return val;
7511 }
7512 }
7513
7514 /* Constructors for pointer, array and function types.
7515 (RECORD_TYPE, UNION_TYPE and ENUMERAL_TYPE nodes are
7516 constructed by language-dependent code, not here.) */
7517
7518 /* Construct, lay out and return the type of pointers to TO_TYPE with
7519 mode MODE. If CAN_ALIAS_ALL is TRUE, indicate this type can
7520 reference all of memory. If such a type has already been
7521 constructed, reuse it. */
7522
7523 tree
build_pointer_type_for_mode(tree to_type,enum machine_mode mode,bool can_alias_all)7524 build_pointer_type_for_mode (tree to_type, enum machine_mode mode,
7525 bool can_alias_all)
7526 {
7527 tree t;
7528
7529 if (to_type == error_mark_node)
7530 return error_mark_node;
7531
7532 /* If the pointed-to type has the may_alias attribute set, force
7533 a TYPE_REF_CAN_ALIAS_ALL pointer to be generated. */
7534 if (lookup_attribute ("may_alias", TYPE_ATTRIBUTES (to_type)))
7535 can_alias_all = true;
7536
7537 /* In some cases, languages will have things that aren't a POINTER_TYPE
7538 (such as a RECORD_TYPE for fat pointers in Ada) as TYPE_POINTER_TO.
7539 In that case, return that type without regard to the rest of our
7540 operands.
7541
7542 ??? This is a kludge, but consistent with the way this function has
7543 always operated and there doesn't seem to be a good way to avoid this
7544 at the moment. */
7545 if (TYPE_POINTER_TO (to_type) != 0
7546 && TREE_CODE (TYPE_POINTER_TO (to_type)) != POINTER_TYPE)
7547 return TYPE_POINTER_TO (to_type);
7548
7549 /* First, if we already have a type for pointers to TO_TYPE and it's
7550 the proper mode, use it. */
7551 for (t = TYPE_POINTER_TO (to_type); t; t = TYPE_NEXT_PTR_TO (t))
7552 if (TYPE_MODE (t) == mode && TYPE_REF_CAN_ALIAS_ALL (t) == can_alias_all)
7553 return t;
7554
7555 t = make_node (POINTER_TYPE);
7556
7557 TREE_TYPE (t) = to_type;
7558 SET_TYPE_MODE (t, mode);
7559 TYPE_REF_CAN_ALIAS_ALL (t) = can_alias_all;
7560 TYPE_NEXT_PTR_TO (t) = TYPE_POINTER_TO (to_type);
7561 TYPE_POINTER_TO (to_type) = t;
7562
7563 if (TYPE_STRUCTURAL_EQUALITY_P (to_type))
7564 SET_TYPE_STRUCTURAL_EQUALITY (t);
7565 else if (TYPE_CANONICAL (to_type) != to_type)
7566 TYPE_CANONICAL (t)
7567 = build_pointer_type_for_mode (TYPE_CANONICAL (to_type),
7568 mode, can_alias_all);
7569
7570 /* Lay out the type. This function has many callers that are concerned
7571 with expression-construction, and this simplifies them all. */
7572 layout_type (t);
7573
7574 return t;
7575 }
7576
7577 /* By default build pointers in ptr_mode. */
7578
7579 tree
build_pointer_type(tree to_type)7580 build_pointer_type (tree to_type)
7581 {
7582 addr_space_t as = to_type == error_mark_node? ADDR_SPACE_GENERIC
7583 : TYPE_ADDR_SPACE (to_type);
7584 enum machine_mode pointer_mode = targetm.addr_space.pointer_mode (as);
7585 return build_pointer_type_for_mode (to_type, pointer_mode, false);
7586 }
7587
7588 /* Same as build_pointer_type_for_mode, but for REFERENCE_TYPE. */
7589
7590 tree
build_reference_type_for_mode(tree to_type,enum machine_mode mode,bool can_alias_all)7591 build_reference_type_for_mode (tree to_type, enum machine_mode mode,
7592 bool can_alias_all)
7593 {
7594 tree t;
7595
7596 if (to_type == error_mark_node)
7597 return error_mark_node;
7598
7599 /* If the pointed-to type has the may_alias attribute set, force
7600 a TYPE_REF_CAN_ALIAS_ALL pointer to be generated. */
7601 if (lookup_attribute ("may_alias", TYPE_ATTRIBUTES (to_type)))
7602 can_alias_all = true;
7603
7604 /* In some cases, languages will have things that aren't a REFERENCE_TYPE
7605 (such as a RECORD_TYPE for fat pointers in Ada) as TYPE_REFERENCE_TO.
7606 In that case, return that type without regard to the rest of our
7607 operands.
7608
7609 ??? This is a kludge, but consistent with the way this function has
7610 always operated and there doesn't seem to be a good way to avoid this
7611 at the moment. */
7612 if (TYPE_REFERENCE_TO (to_type) != 0
7613 && TREE_CODE (TYPE_REFERENCE_TO (to_type)) != REFERENCE_TYPE)
7614 return TYPE_REFERENCE_TO (to_type);
7615
7616 /* First, if we already have a type for pointers to TO_TYPE and it's
7617 the proper mode, use it. */
7618 for (t = TYPE_REFERENCE_TO (to_type); t; t = TYPE_NEXT_REF_TO (t))
7619 if (TYPE_MODE (t) == mode && TYPE_REF_CAN_ALIAS_ALL (t) == can_alias_all)
7620 return t;
7621
7622 t = make_node (REFERENCE_TYPE);
7623
7624 TREE_TYPE (t) = to_type;
7625 SET_TYPE_MODE (t, mode);
7626 TYPE_REF_CAN_ALIAS_ALL (t) = can_alias_all;
7627 TYPE_NEXT_REF_TO (t) = TYPE_REFERENCE_TO (to_type);
7628 TYPE_REFERENCE_TO (to_type) = t;
7629
7630 if (TYPE_STRUCTURAL_EQUALITY_P (to_type))
7631 SET_TYPE_STRUCTURAL_EQUALITY (t);
7632 else if (TYPE_CANONICAL (to_type) != to_type)
7633 TYPE_CANONICAL (t)
7634 = build_reference_type_for_mode (TYPE_CANONICAL (to_type),
7635 mode, can_alias_all);
7636
7637 layout_type (t);
7638
7639 return t;
7640 }
7641
7642
7643 /* Build the node for the type of references-to-TO_TYPE by default
7644 in ptr_mode. */
7645
7646 tree
build_reference_type(tree to_type)7647 build_reference_type (tree to_type)
7648 {
7649 addr_space_t as = to_type == error_mark_node? ADDR_SPACE_GENERIC
7650 : TYPE_ADDR_SPACE (to_type);
7651 enum machine_mode pointer_mode = targetm.addr_space.pointer_mode (as);
7652 return build_reference_type_for_mode (to_type, pointer_mode, false);
7653 }
7654
7655 #define MAX_INT_CACHED_PREC \
7656 (HOST_BITS_PER_WIDE_INT > 64 ? HOST_BITS_PER_WIDE_INT : 64)
7657 static GTY(()) tree nonstandard_integer_type_cache[2 * MAX_INT_CACHED_PREC + 2];
7658
7659 /* Builds a signed or unsigned integer type of precision PRECISION.
7660 Used for C bitfields whose precision does not match that of
7661 built-in target types. */
7662 tree
build_nonstandard_integer_type(unsigned HOST_WIDE_INT precision,int unsignedp)7663 build_nonstandard_integer_type (unsigned HOST_WIDE_INT precision,
7664 int unsignedp)
7665 {
7666 tree itype, ret;
7667
7668 if (unsignedp)
7669 unsignedp = MAX_INT_CACHED_PREC + 1;
7670
7671 if (precision <= MAX_INT_CACHED_PREC)
7672 {
7673 itype = nonstandard_integer_type_cache[precision + unsignedp];
7674 if (itype)
7675 return itype;
7676 }
7677
7678 itype = make_node (INTEGER_TYPE);
7679 TYPE_PRECISION (itype) = precision;
7680
7681 if (unsignedp)
7682 fixup_unsigned_type (itype);
7683 else
7684 fixup_signed_type (itype);
7685
7686 ret = itype;
7687 if (tree_fits_uhwi_p (TYPE_MAX_VALUE (itype)))
7688 ret = type_hash_canon (tree_to_uhwi (TYPE_MAX_VALUE (itype)), itype);
7689 if (precision <= MAX_INT_CACHED_PREC)
7690 nonstandard_integer_type_cache[precision + unsignedp] = ret;
7691
7692 return ret;
7693 }
7694
7695 /* Create a range of some discrete type TYPE (an INTEGER_TYPE, ENUMERAL_TYPE
7696 or BOOLEAN_TYPE) with low bound LOWVAL and high bound HIGHVAL. If SHARED
7697 is true, reuse such a type that has already been constructed. */
7698
7699 static tree
build_range_type_1(tree type,tree lowval,tree highval,bool shared)7700 build_range_type_1 (tree type, tree lowval, tree highval, bool shared)
7701 {
7702 tree itype = make_node (INTEGER_TYPE);
7703 hashval_t hashcode = 0;
7704
7705 TREE_TYPE (itype) = type;
7706
7707 TYPE_MIN_VALUE (itype) = fold_convert (type, lowval);
7708 TYPE_MAX_VALUE (itype) = highval ? fold_convert (type, highval) : NULL;
7709
7710 TYPE_PRECISION (itype) = TYPE_PRECISION (type);
7711 SET_TYPE_MODE (itype, TYPE_MODE (type));
7712 TYPE_SIZE (itype) = TYPE_SIZE (type);
7713 TYPE_SIZE_UNIT (itype) = TYPE_SIZE_UNIT (type);
7714 TYPE_ALIGN (itype) = TYPE_ALIGN (type);
7715 TYPE_USER_ALIGN (itype) = TYPE_USER_ALIGN (type);
7716
7717 if (!shared)
7718 return itype;
7719
7720 if ((TYPE_MIN_VALUE (itype)
7721 && TREE_CODE (TYPE_MIN_VALUE (itype)) != INTEGER_CST)
7722 || (TYPE_MAX_VALUE (itype)
7723 && TREE_CODE (TYPE_MAX_VALUE (itype)) != INTEGER_CST))
7724 {
7725 /* Since we cannot reliably merge this type, we need to compare it using
7726 structural equality checks. */
7727 SET_TYPE_STRUCTURAL_EQUALITY (itype);
7728 return itype;
7729 }
7730
7731 hashcode = iterative_hash_expr (TYPE_MIN_VALUE (itype), hashcode);
7732 hashcode = iterative_hash_expr (TYPE_MAX_VALUE (itype), hashcode);
7733 hashcode = iterative_hash_hashval_t (TYPE_HASH (type), hashcode);
7734 itype = type_hash_canon (hashcode, itype);
7735
7736 return itype;
7737 }
7738
7739 /* Wrapper around build_range_type_1 with SHARED set to true. */
7740
7741 tree
build_range_type(tree type,tree lowval,tree highval)7742 build_range_type (tree type, tree lowval, tree highval)
7743 {
7744 return build_range_type_1 (type, lowval, highval, true);
7745 }
7746
7747 /* Wrapper around build_range_type_1 with SHARED set to false. */
7748
7749 tree
build_nonshared_range_type(tree type,tree lowval,tree highval)7750 build_nonshared_range_type (tree type, tree lowval, tree highval)
7751 {
7752 return build_range_type_1 (type, lowval, highval, false);
7753 }
7754
7755 /* Create a type of integers to be the TYPE_DOMAIN of an ARRAY_TYPE.
7756 MAXVAL should be the maximum value in the domain
7757 (one less than the length of the array).
7758
7759 The maximum value that MAXVAL can have is INT_MAX for a HOST_WIDE_INT.
7760 We don't enforce this limit, that is up to caller (e.g. language front end).
7761 The limit exists because the result is a signed type and we don't handle
7762 sizes that use more than one HOST_WIDE_INT. */
7763
7764 tree
build_index_type(tree maxval)7765 build_index_type (tree maxval)
7766 {
7767 return build_range_type (sizetype, size_zero_node, maxval);
7768 }
7769
7770 /* Return true if the debug information for TYPE, a subtype, should be emitted
7771 as a subrange type. If so, set LOWVAL to the low bound and HIGHVAL to the
7772 high bound, respectively. Sometimes doing so unnecessarily obfuscates the
7773 debug info and doesn't reflect the source code. */
7774
7775 bool
subrange_type_for_debug_p(const_tree type,tree * lowval,tree * highval)7776 subrange_type_for_debug_p (const_tree type, tree *lowval, tree *highval)
7777 {
7778 tree base_type = TREE_TYPE (type), low, high;
7779
7780 /* Subrange types have a base type which is an integral type. */
7781 if (!INTEGRAL_TYPE_P (base_type))
7782 return false;
7783
7784 /* Get the real bounds of the subtype. */
7785 if (lang_hooks.types.get_subrange_bounds)
7786 lang_hooks.types.get_subrange_bounds (type, &low, &high);
7787 else
7788 {
7789 low = TYPE_MIN_VALUE (type);
7790 high = TYPE_MAX_VALUE (type);
7791 }
7792
7793 /* If the type and its base type have the same representation and the same
7794 name, then the type is not a subrange but a copy of the base type. */
7795 if ((TREE_CODE (base_type) == INTEGER_TYPE
7796 || TREE_CODE (base_type) == BOOLEAN_TYPE)
7797 && int_size_in_bytes (type) == int_size_in_bytes (base_type)
7798 && tree_int_cst_equal (low, TYPE_MIN_VALUE (base_type))
7799 && tree_int_cst_equal (high, TYPE_MAX_VALUE (base_type)))
7800 {
7801 tree type_name = TYPE_NAME (type);
7802 tree base_type_name = TYPE_NAME (base_type);
7803
7804 if (type_name && TREE_CODE (type_name) == TYPE_DECL)
7805 type_name = DECL_NAME (type_name);
7806
7807 if (base_type_name && TREE_CODE (base_type_name) == TYPE_DECL)
7808 base_type_name = DECL_NAME (base_type_name);
7809
7810 if (type_name == base_type_name)
7811 return false;
7812 }
7813
7814 if (lowval)
7815 *lowval = low;
7816 if (highval)
7817 *highval = high;
7818 return true;
7819 }
7820
7821 /* Construct, lay out and return the type of arrays of elements with ELT_TYPE
7822 and number of elements specified by the range of values of INDEX_TYPE.
7823 If SHARED is true, reuse such a type that has already been constructed. */
7824
7825 static tree
build_array_type_1(tree elt_type,tree index_type,bool shared)7826 build_array_type_1 (tree elt_type, tree index_type, bool shared)
7827 {
7828 tree t;
7829
7830 if (TREE_CODE (elt_type) == FUNCTION_TYPE)
7831 {
7832 error ("arrays of functions are not meaningful");
7833 elt_type = integer_type_node;
7834 }
7835
7836 t = make_node (ARRAY_TYPE);
7837 TREE_TYPE (t) = elt_type;
7838 TYPE_DOMAIN (t) = index_type;
7839 TYPE_ADDR_SPACE (t) = TYPE_ADDR_SPACE (elt_type);
7840 layout_type (t);
7841
7842 /* If the element type is incomplete at this point we get marked for
7843 structural equality. Do not record these types in the canonical
7844 type hashtable. */
7845 if (TYPE_STRUCTURAL_EQUALITY_P (t))
7846 return t;
7847
7848 if (shared)
7849 {
7850 hashval_t hashcode = iterative_hash_object (TYPE_HASH (elt_type), 0);
7851 if (index_type)
7852 hashcode = iterative_hash_object (TYPE_HASH (index_type), hashcode);
7853 t = type_hash_canon (hashcode, t);
7854 }
7855
7856 if (TYPE_CANONICAL (t) == t)
7857 {
7858 if (TYPE_STRUCTURAL_EQUALITY_P (elt_type)
7859 || (index_type && TYPE_STRUCTURAL_EQUALITY_P (index_type)))
7860 SET_TYPE_STRUCTURAL_EQUALITY (t);
7861 else if (TYPE_CANONICAL (elt_type) != elt_type
7862 || (index_type && TYPE_CANONICAL (index_type) != index_type))
7863 TYPE_CANONICAL (t)
7864 = build_array_type_1 (TYPE_CANONICAL (elt_type),
7865 index_type
7866 ? TYPE_CANONICAL (index_type) : NULL_TREE,
7867 shared);
7868 }
7869
7870 return t;
7871 }
7872
7873 /* Wrapper around build_array_type_1 with SHARED set to true. */
7874
7875 tree
build_array_type(tree elt_type,tree index_type)7876 build_array_type (tree elt_type, tree index_type)
7877 {
7878 return build_array_type_1 (elt_type, index_type, true);
7879 }
7880
7881 /* Wrapper around build_array_type_1 with SHARED set to false. */
7882
7883 tree
build_nonshared_array_type(tree elt_type,tree index_type)7884 build_nonshared_array_type (tree elt_type, tree index_type)
7885 {
7886 return build_array_type_1 (elt_type, index_type, false);
7887 }
7888
7889 /* Return a representation of ELT_TYPE[NELTS], using indices of type
7890 sizetype. */
7891
7892 tree
build_array_type_nelts(tree elt_type,unsigned HOST_WIDE_INT nelts)7893 build_array_type_nelts (tree elt_type, unsigned HOST_WIDE_INT nelts)
7894 {
7895 return build_array_type (elt_type, build_index_type (size_int (nelts - 1)));
7896 }
7897
7898 /* Recursively examines the array elements of TYPE, until a non-array
7899 element type is found. */
7900
7901 tree
strip_array_types(tree type)7902 strip_array_types (tree type)
7903 {
7904 while (TREE_CODE (type) == ARRAY_TYPE)
7905 type = TREE_TYPE (type);
7906
7907 return type;
7908 }
7909
7910 /* Computes the canonical argument types from the argument type list
7911 ARGTYPES.
7912
7913 Upon return, *ANY_STRUCTURAL_P will be true iff either it was true
7914 on entry to this function, or if any of the ARGTYPES are
7915 structural.
7916
7917 Upon return, *ANY_NONCANONICAL_P will be true iff either it was
7918 true on entry to this function, or if any of the ARGTYPES are
7919 non-canonical.
7920
7921 Returns a canonical argument list, which may be ARGTYPES when the
7922 canonical argument list is unneeded (i.e., *ANY_STRUCTURAL_P is
7923 true) or would not differ from ARGTYPES. */
7924
7925 static tree
maybe_canonicalize_argtypes(tree argtypes,bool * any_structural_p,bool * any_noncanonical_p)7926 maybe_canonicalize_argtypes (tree argtypes,
7927 bool *any_structural_p,
7928 bool *any_noncanonical_p)
7929 {
7930 tree arg;
7931 bool any_noncanonical_argtypes_p = false;
7932
7933 for (arg = argtypes; arg && !(*any_structural_p); arg = TREE_CHAIN (arg))
7934 {
7935 if (!TREE_VALUE (arg) || TREE_VALUE (arg) == error_mark_node)
7936 /* Fail gracefully by stating that the type is structural. */
7937 *any_structural_p = true;
7938 else if (TYPE_STRUCTURAL_EQUALITY_P (TREE_VALUE (arg)))
7939 *any_structural_p = true;
7940 else if (TYPE_CANONICAL (TREE_VALUE (arg)) != TREE_VALUE (arg)
7941 || TREE_PURPOSE (arg))
7942 /* If the argument has a default argument, we consider it
7943 non-canonical even though the type itself is canonical.
7944 That way, different variants of function and method types
7945 with default arguments will all point to the variant with
7946 no defaults as their canonical type. */
7947 any_noncanonical_argtypes_p = true;
7948 }
7949
7950 if (*any_structural_p)
7951 return argtypes;
7952
7953 if (any_noncanonical_argtypes_p)
7954 {
7955 /* Build the canonical list of argument types. */
7956 tree canon_argtypes = NULL_TREE;
7957 bool is_void = false;
7958
7959 for (arg = argtypes; arg; arg = TREE_CHAIN (arg))
7960 {
7961 if (arg == void_list_node)
7962 is_void = true;
7963 else
7964 canon_argtypes = tree_cons (NULL_TREE,
7965 TYPE_CANONICAL (TREE_VALUE (arg)),
7966 canon_argtypes);
7967 }
7968
7969 canon_argtypes = nreverse (canon_argtypes);
7970 if (is_void)
7971 canon_argtypes = chainon (canon_argtypes, void_list_node);
7972
7973 /* There is a non-canonical type. */
7974 *any_noncanonical_p = true;
7975 return canon_argtypes;
7976 }
7977
7978 /* The canonical argument types are the same as ARGTYPES. */
7979 return argtypes;
7980 }
7981
7982 /* Construct, lay out and return
7983 the type of functions returning type VALUE_TYPE
7984 given arguments of types ARG_TYPES.
7985 ARG_TYPES is a chain of TREE_LIST nodes whose TREE_VALUEs
7986 are data type nodes for the arguments of the function.
7987 If such a type has already been constructed, reuse it. */
7988
7989 tree
build_function_type(tree value_type,tree arg_types)7990 build_function_type (tree value_type, tree arg_types)
7991 {
7992 tree t;
7993 hashval_t hashcode = 0;
7994 bool any_structural_p, any_noncanonical_p;
7995 tree canon_argtypes;
7996
7997 if (TREE_CODE (value_type) == FUNCTION_TYPE)
7998 {
7999 error ("function return type cannot be function");
8000 value_type = integer_type_node;
8001 }
8002
8003 /* Make a node of the sort we want. */
8004 t = make_node (FUNCTION_TYPE);
8005 TREE_TYPE (t) = value_type;
8006 TYPE_ARG_TYPES (t) = arg_types;
8007
8008 /* If we already have such a type, use the old one. */
8009 hashcode = iterative_hash_object (TYPE_HASH (value_type), hashcode);
8010 hashcode = type_hash_list (arg_types, hashcode);
8011 t = type_hash_canon (hashcode, t);
8012
8013 /* Set up the canonical type. */
8014 any_structural_p = TYPE_STRUCTURAL_EQUALITY_P (value_type);
8015 any_noncanonical_p = TYPE_CANONICAL (value_type) != value_type;
8016 canon_argtypes = maybe_canonicalize_argtypes (arg_types,
8017 &any_structural_p,
8018 &any_noncanonical_p);
8019 if (any_structural_p)
8020 SET_TYPE_STRUCTURAL_EQUALITY (t);
8021 else if (any_noncanonical_p)
8022 TYPE_CANONICAL (t) = build_function_type (TYPE_CANONICAL (value_type),
8023 canon_argtypes);
8024
8025 if (!COMPLETE_TYPE_P (t))
8026 layout_type (t);
8027 return t;
8028 }
8029
8030 /* Build a function type. The RETURN_TYPE is the type returned by the
8031 function. If VAARGS is set, no void_type_node is appended to the
8032 the list. ARGP must be always be terminated be a NULL_TREE. */
8033
8034 static tree
build_function_type_list_1(bool vaargs,tree return_type,va_list argp)8035 build_function_type_list_1 (bool vaargs, tree return_type, va_list argp)
8036 {
8037 tree t, args, last;
8038
8039 t = va_arg (argp, tree);
8040 for (args = NULL_TREE; t != NULL_TREE; t = va_arg (argp, tree))
8041 args = tree_cons (NULL_TREE, t, args);
8042
8043 if (vaargs)
8044 {
8045 last = args;
8046 if (args != NULL_TREE)
8047 args = nreverse (args);
8048 gcc_assert (last != void_list_node);
8049 }
8050 else if (args == NULL_TREE)
8051 args = void_list_node;
8052 else
8053 {
8054 last = args;
8055 args = nreverse (args);
8056 TREE_CHAIN (last) = void_list_node;
8057 }
8058 args = build_function_type (return_type, args);
8059
8060 return args;
8061 }
8062
8063 /* Build a function type. The RETURN_TYPE is the type returned by the
8064 function. If additional arguments are provided, they are
8065 additional argument types. The list of argument types must always
8066 be terminated by NULL_TREE. */
8067
8068 tree
build_function_type_list(tree return_type,...)8069 build_function_type_list (tree return_type, ...)
8070 {
8071 tree args;
8072 va_list p;
8073
8074 va_start (p, return_type);
8075 args = build_function_type_list_1 (false, return_type, p);
8076 va_end (p);
8077 return args;
8078 }
8079
8080 /* Build a variable argument function type. The RETURN_TYPE is the
8081 type returned by the function. If additional arguments are provided,
8082 they are additional argument types. The list of argument types must
8083 always be terminated by NULL_TREE. */
8084
8085 tree
build_varargs_function_type_list(tree return_type,...)8086 build_varargs_function_type_list (tree return_type, ...)
8087 {
8088 tree args;
8089 va_list p;
8090
8091 va_start (p, return_type);
8092 args = build_function_type_list_1 (true, return_type, p);
8093 va_end (p);
8094
8095 return args;
8096 }
8097
8098 /* Build a function type. RETURN_TYPE is the type returned by the
8099 function; VAARGS indicates whether the function takes varargs. The
8100 function takes N named arguments, the types of which are provided in
8101 ARG_TYPES. */
8102
8103 static tree
build_function_type_array_1(bool vaargs,tree return_type,int n,tree * arg_types)8104 build_function_type_array_1 (bool vaargs, tree return_type, int n,
8105 tree *arg_types)
8106 {
8107 int i;
8108 tree t = vaargs ? NULL_TREE : void_list_node;
8109
8110 for (i = n - 1; i >= 0; i--)
8111 t = tree_cons (NULL_TREE, arg_types[i], t);
8112
8113 return build_function_type (return_type, t);
8114 }
8115
8116 /* Build a function type. RETURN_TYPE is the type returned by the
8117 function. The function takes N named arguments, the types of which
8118 are provided in ARG_TYPES. */
8119
8120 tree
build_function_type_array(tree return_type,int n,tree * arg_types)8121 build_function_type_array (tree return_type, int n, tree *arg_types)
8122 {
8123 return build_function_type_array_1 (false, return_type, n, arg_types);
8124 }
8125
8126 /* Build a variable argument function type. RETURN_TYPE is the type
8127 returned by the function. The function takes N named arguments, the
8128 types of which are provided in ARG_TYPES. */
8129
8130 tree
build_varargs_function_type_array(tree return_type,int n,tree * arg_types)8131 build_varargs_function_type_array (tree return_type, int n, tree *arg_types)
8132 {
8133 return build_function_type_array_1 (true, return_type, n, arg_types);
8134 }
8135
8136 /* Build a METHOD_TYPE for a member of BASETYPE. The RETTYPE (a TYPE)
8137 and ARGTYPES (a TREE_LIST) are the return type and arguments types
8138 for the method. An implicit additional parameter (of type
8139 pointer-to-BASETYPE) is added to the ARGTYPES. */
8140
8141 tree
build_method_type_directly(tree basetype,tree rettype,tree argtypes)8142 build_method_type_directly (tree basetype,
8143 tree rettype,
8144 tree argtypes)
8145 {
8146 tree t;
8147 tree ptype;
8148 int hashcode = 0;
8149 bool any_structural_p, any_noncanonical_p;
8150 tree canon_argtypes;
8151
8152 /* Make a node of the sort we want. */
8153 t = make_node (METHOD_TYPE);
8154
8155 TYPE_METHOD_BASETYPE (t) = TYPE_MAIN_VARIANT (basetype);
8156 TREE_TYPE (t) = rettype;
8157 ptype = build_pointer_type (basetype);
8158
8159 /* The actual arglist for this function includes a "hidden" argument
8160 which is "this". Put it into the list of argument types. */
8161 argtypes = tree_cons (NULL_TREE, ptype, argtypes);
8162 TYPE_ARG_TYPES (t) = argtypes;
8163
8164 /* If we already have such a type, use the old one. */
8165 hashcode = iterative_hash_object (TYPE_HASH (basetype), hashcode);
8166 hashcode = iterative_hash_object (TYPE_HASH (rettype), hashcode);
8167 hashcode = type_hash_list (argtypes, hashcode);
8168 t = type_hash_canon (hashcode, t);
8169
8170 /* Set up the canonical type. */
8171 any_structural_p
8172 = (TYPE_STRUCTURAL_EQUALITY_P (basetype)
8173 || TYPE_STRUCTURAL_EQUALITY_P (rettype));
8174 any_noncanonical_p
8175 = (TYPE_CANONICAL (basetype) != basetype
8176 || TYPE_CANONICAL (rettype) != rettype);
8177 canon_argtypes = maybe_canonicalize_argtypes (TREE_CHAIN (argtypes),
8178 &any_structural_p,
8179 &any_noncanonical_p);
8180 if (any_structural_p)
8181 SET_TYPE_STRUCTURAL_EQUALITY (t);
8182 else if (any_noncanonical_p)
8183 TYPE_CANONICAL (t)
8184 = build_method_type_directly (TYPE_CANONICAL (basetype),
8185 TYPE_CANONICAL (rettype),
8186 canon_argtypes);
8187 if (!COMPLETE_TYPE_P (t))
8188 layout_type (t);
8189
8190 return t;
8191 }
8192
8193 /* Construct, lay out and return the type of methods belonging to class
8194 BASETYPE and whose arguments and values are described by TYPE.
8195 If that type exists already, reuse it.
8196 TYPE must be a FUNCTION_TYPE node. */
8197
8198 tree
build_method_type(tree basetype,tree type)8199 build_method_type (tree basetype, tree type)
8200 {
8201 gcc_assert (TREE_CODE (type) == FUNCTION_TYPE);
8202
8203 return build_method_type_directly (basetype,
8204 TREE_TYPE (type),
8205 TYPE_ARG_TYPES (type));
8206 }
8207
8208 /* Construct, lay out and return the type of offsets to a value
8209 of type TYPE, within an object of type BASETYPE.
8210 If a suitable offset type exists already, reuse it. */
8211
8212 tree
build_offset_type(tree basetype,tree type)8213 build_offset_type (tree basetype, tree type)
8214 {
8215 tree t;
8216 hashval_t hashcode = 0;
8217
8218 /* Make a node of the sort we want. */
8219 t = make_node (OFFSET_TYPE);
8220
8221 TYPE_OFFSET_BASETYPE (t) = TYPE_MAIN_VARIANT (basetype);
8222 TREE_TYPE (t) = type;
8223
8224 /* If we already have such a type, use the old one. */
8225 hashcode = iterative_hash_object (TYPE_HASH (basetype), hashcode);
8226 hashcode = iterative_hash_object (TYPE_HASH (type), hashcode);
8227 t = type_hash_canon (hashcode, t);
8228
8229 if (!COMPLETE_TYPE_P (t))
8230 layout_type (t);
8231
8232 if (TYPE_CANONICAL (t) == t)
8233 {
8234 if (TYPE_STRUCTURAL_EQUALITY_P (basetype)
8235 || TYPE_STRUCTURAL_EQUALITY_P (type))
8236 SET_TYPE_STRUCTURAL_EQUALITY (t);
8237 else if (TYPE_CANONICAL (TYPE_MAIN_VARIANT (basetype)) != basetype
8238 || TYPE_CANONICAL (type) != type)
8239 TYPE_CANONICAL (t)
8240 = build_offset_type (TYPE_CANONICAL (TYPE_MAIN_VARIANT (basetype)),
8241 TYPE_CANONICAL (type));
8242 }
8243
8244 return t;
8245 }
8246
8247 /* Create a complex type whose components are COMPONENT_TYPE. */
8248
8249 tree
build_complex_type(tree component_type)8250 build_complex_type (tree component_type)
8251 {
8252 tree t;
8253 hashval_t hashcode;
8254
8255 gcc_assert (INTEGRAL_TYPE_P (component_type)
8256 || SCALAR_FLOAT_TYPE_P (component_type)
8257 || FIXED_POINT_TYPE_P (component_type));
8258
8259 /* Make a node of the sort we want. */
8260 t = make_node (COMPLEX_TYPE);
8261
8262 TREE_TYPE (t) = TYPE_MAIN_VARIANT (component_type);
8263
8264 /* If we already have such a type, use the old one. */
8265 hashcode = iterative_hash_object (TYPE_HASH (component_type), 0);
8266 t = type_hash_canon (hashcode, t);
8267
8268 if (!COMPLETE_TYPE_P (t))
8269 layout_type (t);
8270
8271 if (TYPE_CANONICAL (t) == t)
8272 {
8273 if (TYPE_STRUCTURAL_EQUALITY_P (component_type))
8274 SET_TYPE_STRUCTURAL_EQUALITY (t);
8275 else if (TYPE_CANONICAL (component_type) != component_type)
8276 TYPE_CANONICAL (t)
8277 = build_complex_type (TYPE_CANONICAL (component_type));
8278 }
8279
8280 /* We need to create a name, since complex is a fundamental type. */
8281 if (! TYPE_NAME (t))
8282 {
8283 const char *name;
8284 if (component_type == char_type_node)
8285 name = "complex char";
8286 else if (component_type == signed_char_type_node)
8287 name = "complex signed char";
8288 else if (component_type == unsigned_char_type_node)
8289 name = "complex unsigned char";
8290 else if (component_type == short_integer_type_node)
8291 name = "complex short int";
8292 else if (component_type == short_unsigned_type_node)
8293 name = "complex short unsigned int";
8294 else if (component_type == integer_type_node)
8295 name = "complex int";
8296 else if (component_type == unsigned_type_node)
8297 name = "complex unsigned int";
8298 else if (component_type == long_integer_type_node)
8299 name = "complex long int";
8300 else if (component_type == long_unsigned_type_node)
8301 name = "complex long unsigned int";
8302 else if (component_type == long_long_integer_type_node)
8303 name = "complex long long int";
8304 else if (component_type == long_long_unsigned_type_node)
8305 name = "complex long long unsigned int";
8306 else
8307 name = 0;
8308
8309 if (name != 0)
8310 TYPE_NAME (t) = build_decl (UNKNOWN_LOCATION, TYPE_DECL,
8311 get_identifier (name), t);
8312 }
8313
8314 return build_qualified_type (t, TYPE_QUALS (component_type));
8315 }
8316
8317 /* If TYPE is a real or complex floating-point type and the target
8318 does not directly support arithmetic on TYPE then return the wider
8319 type to be used for arithmetic on TYPE. Otherwise, return
8320 NULL_TREE. */
8321
8322 tree
excess_precision_type(tree type)8323 excess_precision_type (tree type)
8324 {
8325 if (flag_excess_precision != EXCESS_PRECISION_FAST)
8326 {
8327 int flt_eval_method = TARGET_FLT_EVAL_METHOD;
8328 switch (TREE_CODE (type))
8329 {
8330 case REAL_TYPE:
8331 switch (flt_eval_method)
8332 {
8333 case 1:
8334 if (TYPE_MODE (type) == TYPE_MODE (float_type_node))
8335 return double_type_node;
8336 break;
8337 case 2:
8338 if (TYPE_MODE (type) == TYPE_MODE (float_type_node)
8339 || TYPE_MODE (type) == TYPE_MODE (double_type_node))
8340 return long_double_type_node;
8341 break;
8342 default:
8343 gcc_unreachable ();
8344 }
8345 break;
8346 case COMPLEX_TYPE:
8347 if (TREE_CODE (TREE_TYPE (type)) != REAL_TYPE)
8348 return NULL_TREE;
8349 switch (flt_eval_method)
8350 {
8351 case 1:
8352 if (TYPE_MODE (TREE_TYPE (type)) == TYPE_MODE (float_type_node))
8353 return complex_double_type_node;
8354 break;
8355 case 2:
8356 if (TYPE_MODE (TREE_TYPE (type)) == TYPE_MODE (float_type_node)
8357 || (TYPE_MODE (TREE_TYPE (type))
8358 == TYPE_MODE (double_type_node)))
8359 return complex_long_double_type_node;
8360 break;
8361 default:
8362 gcc_unreachable ();
8363 }
8364 break;
8365 default:
8366 break;
8367 }
8368 }
8369 return NULL_TREE;
8370 }
8371
8372 /* Return OP, stripped of any conversions to wider types as much as is safe.
8373 Converting the value back to OP's type makes a value equivalent to OP.
8374
8375 If FOR_TYPE is nonzero, we return a value which, if converted to
8376 type FOR_TYPE, would be equivalent to converting OP to type FOR_TYPE.
8377
8378 OP must have integer, real or enumeral type. Pointers are not allowed!
8379
8380 There are some cases where the obvious value we could return
8381 would regenerate to OP if converted to OP's type,
8382 but would not extend like OP to wider types.
8383 If FOR_TYPE indicates such extension is contemplated, we eschew such values.
8384 For example, if OP is (unsigned short)(signed char)-1,
8385 we avoid returning (signed char)-1 if FOR_TYPE is int,
8386 even though extending that to an unsigned short would regenerate OP,
8387 since the result of extending (signed char)-1 to (int)
8388 is different from (int) OP. */
8389
8390 tree
get_unwidened(tree op,tree for_type)8391 get_unwidened (tree op, tree for_type)
8392 {
8393 /* Set UNS initially if converting OP to FOR_TYPE is a zero-extension. */
8394 tree type = TREE_TYPE (op);
8395 unsigned final_prec
8396 = TYPE_PRECISION (for_type != 0 ? for_type : type);
8397 int uns
8398 = (for_type != 0 && for_type != type
8399 && final_prec > TYPE_PRECISION (type)
8400 && TYPE_UNSIGNED (type));
8401 tree win = op;
8402
8403 while (CONVERT_EXPR_P (op))
8404 {
8405 int bitschange;
8406
8407 /* TYPE_PRECISION on vector types has different meaning
8408 (TYPE_VECTOR_SUBPARTS) and casts from vectors are view conversions,
8409 so avoid them here. */
8410 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (op, 0))) == VECTOR_TYPE)
8411 break;
8412
8413 bitschange = TYPE_PRECISION (TREE_TYPE (op))
8414 - TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op, 0)));
8415
8416 /* Truncations are many-one so cannot be removed.
8417 Unless we are later going to truncate down even farther. */
8418 if (bitschange < 0
8419 && final_prec > TYPE_PRECISION (TREE_TYPE (op)))
8420 break;
8421
8422 /* See what's inside this conversion. If we decide to strip it,
8423 we will set WIN. */
8424 op = TREE_OPERAND (op, 0);
8425
8426 /* If we have not stripped any zero-extensions (uns is 0),
8427 we can strip any kind of extension.
8428 If we have previously stripped a zero-extension,
8429 only zero-extensions can safely be stripped.
8430 Any extension can be stripped if the bits it would produce
8431 are all going to be discarded later by truncating to FOR_TYPE. */
8432
8433 if (bitschange > 0)
8434 {
8435 if (! uns || final_prec <= TYPE_PRECISION (TREE_TYPE (op)))
8436 win = op;
8437 /* TYPE_UNSIGNED says whether this is a zero-extension.
8438 Let's avoid computing it if it does not affect WIN
8439 and if UNS will not be needed again. */
8440 if ((uns
8441 || CONVERT_EXPR_P (op))
8442 && TYPE_UNSIGNED (TREE_TYPE (op)))
8443 {
8444 uns = 1;
8445 win = op;
8446 }
8447 }
8448 }
8449
8450 /* If we finally reach a constant see if it fits in for_type and
8451 in that case convert it. */
8452 if (for_type
8453 && TREE_CODE (win) == INTEGER_CST
8454 && TREE_TYPE (win) != for_type
8455 && int_fits_type_p (win, for_type))
8456 win = fold_convert (for_type, win);
8457
8458 return win;
8459 }
8460
8461 /* Return OP or a simpler expression for a narrower value
8462 which can be sign-extended or zero-extended to give back OP.
8463 Store in *UNSIGNEDP_PTR either 1 if the value should be zero-extended
8464 or 0 if the value should be sign-extended. */
8465
8466 tree
get_narrower(tree op,int * unsignedp_ptr)8467 get_narrower (tree op, int *unsignedp_ptr)
8468 {
8469 int uns = 0;
8470 int first = 1;
8471 tree win = op;
8472 bool integral_p = INTEGRAL_TYPE_P (TREE_TYPE (op));
8473
8474 while (TREE_CODE (op) == NOP_EXPR)
8475 {
8476 int bitschange
8477 = (TYPE_PRECISION (TREE_TYPE (op))
8478 - TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op, 0))));
8479
8480 /* Truncations are many-one so cannot be removed. */
8481 if (bitschange < 0)
8482 break;
8483
8484 /* See what's inside this conversion. If we decide to strip it,
8485 we will set WIN. */
8486
8487 if (bitschange > 0)
8488 {
8489 op = TREE_OPERAND (op, 0);
8490 /* An extension: the outermost one can be stripped,
8491 but remember whether it is zero or sign extension. */
8492 if (first)
8493 uns = TYPE_UNSIGNED (TREE_TYPE (op));
8494 /* Otherwise, if a sign extension has been stripped,
8495 only sign extensions can now be stripped;
8496 if a zero extension has been stripped, only zero-extensions. */
8497 else if (uns != TYPE_UNSIGNED (TREE_TYPE (op)))
8498 break;
8499 first = 0;
8500 }
8501 else /* bitschange == 0 */
8502 {
8503 /* A change in nominal type can always be stripped, but we must
8504 preserve the unsignedness. */
8505 if (first)
8506 uns = TYPE_UNSIGNED (TREE_TYPE (op));
8507 first = 0;
8508 op = TREE_OPERAND (op, 0);
8509 /* Keep trying to narrow, but don't assign op to win if it
8510 would turn an integral type into something else. */
8511 if (INTEGRAL_TYPE_P (TREE_TYPE (op)) != integral_p)
8512 continue;
8513 }
8514
8515 win = op;
8516 }
8517
8518 if (TREE_CODE (op) == COMPONENT_REF
8519 /* Since type_for_size always gives an integer type. */
8520 && TREE_CODE (TREE_TYPE (op)) != REAL_TYPE
8521 && TREE_CODE (TREE_TYPE (op)) != FIXED_POINT_TYPE
8522 /* Ensure field is laid out already. */
8523 && DECL_SIZE (TREE_OPERAND (op, 1)) != 0
8524 && tree_fits_uhwi_p (DECL_SIZE (TREE_OPERAND (op, 1))))
8525 {
8526 unsigned HOST_WIDE_INT innerprec
8527 = tree_to_uhwi (DECL_SIZE (TREE_OPERAND (op, 1)));
8528 int unsignedp = (DECL_UNSIGNED (TREE_OPERAND (op, 1))
8529 || TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op, 1))));
8530 tree type = lang_hooks.types.type_for_size (innerprec, unsignedp);
8531
8532 /* We can get this structure field in a narrower type that fits it,
8533 but the resulting extension to its nominal type (a fullword type)
8534 must satisfy the same conditions as for other extensions.
8535
8536 Do this only for fields that are aligned (not bit-fields),
8537 because when bit-field insns will be used there is no
8538 advantage in doing this. */
8539
8540 if (innerprec < TYPE_PRECISION (TREE_TYPE (op))
8541 && ! DECL_BIT_FIELD (TREE_OPERAND (op, 1))
8542 && (first || uns == DECL_UNSIGNED (TREE_OPERAND (op, 1)))
8543 && type != 0)
8544 {
8545 if (first)
8546 uns = DECL_UNSIGNED (TREE_OPERAND (op, 1));
8547 win = fold_convert (type, op);
8548 }
8549 }
8550
8551 *unsignedp_ptr = uns;
8552 return win;
8553 }
8554
8555 /* Returns true if integer constant C has a value that is permissible
8556 for type TYPE (an INTEGER_TYPE). */
8557
8558 bool
int_fits_type_p(const_tree c,const_tree type)8559 int_fits_type_p (const_tree c, const_tree type)
8560 {
8561 tree type_low_bound, type_high_bound;
8562 bool ok_for_low_bound, ok_for_high_bound, unsc;
8563 double_int dc, dd;
8564
8565 dc = tree_to_double_int (c);
8566 unsc = TYPE_UNSIGNED (TREE_TYPE (c));
8567
8568 retry:
8569 type_low_bound = TYPE_MIN_VALUE (type);
8570 type_high_bound = TYPE_MAX_VALUE (type);
8571
8572 /* If at least one bound of the type is a constant integer, we can check
8573 ourselves and maybe make a decision. If no such decision is possible, but
8574 this type is a subtype, try checking against that. Otherwise, use
8575 double_int_fits_to_tree_p, which checks against the precision.
8576
8577 Compute the status for each possibly constant bound, and return if we see
8578 one does not match. Use ok_for_xxx_bound for this purpose, assigning -1
8579 for "unknown if constant fits", 0 for "constant known *not* to fit" and 1
8580 for "constant known to fit". */
8581
8582 /* Check if c >= type_low_bound. */
8583 if (type_low_bound && TREE_CODE (type_low_bound) == INTEGER_CST)
8584 {
8585 dd = tree_to_double_int (type_low_bound);
8586 if (unsc != TYPE_UNSIGNED (TREE_TYPE (type_low_bound)))
8587 {
8588 int c_neg = (!unsc && dc.is_negative ());
8589 int t_neg = (unsc && dd.is_negative ());
8590
8591 if (c_neg && !t_neg)
8592 return false;
8593 if ((c_neg || !t_neg) && dc.ult (dd))
8594 return false;
8595 }
8596 else if (dc.cmp (dd, unsc) < 0)
8597 return false;
8598 ok_for_low_bound = true;
8599 }
8600 else
8601 ok_for_low_bound = false;
8602
8603 /* Check if c <= type_high_bound. */
8604 if (type_high_bound && TREE_CODE (type_high_bound) == INTEGER_CST)
8605 {
8606 dd = tree_to_double_int (type_high_bound);
8607 if (unsc != TYPE_UNSIGNED (TREE_TYPE (type_high_bound)))
8608 {
8609 int c_neg = (!unsc && dc.is_negative ());
8610 int t_neg = (unsc && dd.is_negative ());
8611
8612 if (t_neg && !c_neg)
8613 return false;
8614 if ((t_neg || !c_neg) && dc.ugt (dd))
8615 return false;
8616 }
8617 else if (dc.cmp (dd, unsc) > 0)
8618 return false;
8619 ok_for_high_bound = true;
8620 }
8621 else
8622 ok_for_high_bound = false;
8623
8624 /* If the constant fits both bounds, the result is known. */
8625 if (ok_for_low_bound && ok_for_high_bound)
8626 return true;
8627
8628 /* Perform some generic filtering which may allow making a decision
8629 even if the bounds are not constant. First, negative integers
8630 never fit in unsigned types, */
8631 if (TYPE_UNSIGNED (type) && !unsc && dc.is_negative ())
8632 return false;
8633
8634 /* Second, narrower types always fit in wider ones. */
8635 if (TYPE_PRECISION (type) > TYPE_PRECISION (TREE_TYPE (c)))
8636 return true;
8637
8638 /* Third, unsigned integers with top bit set never fit signed types. */
8639 if (! TYPE_UNSIGNED (type) && unsc)
8640 {
8641 int prec = GET_MODE_PRECISION (TYPE_MODE (TREE_TYPE (c))) - 1;
8642 if (prec < HOST_BITS_PER_WIDE_INT)
8643 {
8644 if (((((unsigned HOST_WIDE_INT) 1) << prec) & dc.low) != 0)
8645 return false;
8646 }
8647 else if (((((unsigned HOST_WIDE_INT) 1)
8648 << (prec - HOST_BITS_PER_WIDE_INT)) & dc.high) != 0)
8649 return false;
8650 }
8651
8652 /* If we haven't been able to decide at this point, there nothing more we
8653 can check ourselves here. Look at the base type if we have one and it
8654 has the same precision. */
8655 if (TREE_CODE (type) == INTEGER_TYPE
8656 && TREE_TYPE (type) != 0
8657 && TYPE_PRECISION (type) == TYPE_PRECISION (TREE_TYPE (type)))
8658 {
8659 type = TREE_TYPE (type);
8660 goto retry;
8661 }
8662
8663 /* Or to double_int_fits_to_tree_p, if nothing else. */
8664 return double_int_fits_to_tree_p (type, dc);
8665 }
8666
8667 /* Stores bounds of an integer TYPE in MIN and MAX. If TYPE has non-constant
8668 bounds or is a POINTER_TYPE, the maximum and/or minimum values that can be
8669 represented (assuming two's-complement arithmetic) within the bit
8670 precision of the type are returned instead. */
8671
8672 void
get_type_static_bounds(const_tree type,mpz_t min,mpz_t max)8673 get_type_static_bounds (const_tree type, mpz_t min, mpz_t max)
8674 {
8675 if (!POINTER_TYPE_P (type) && TYPE_MIN_VALUE (type)
8676 && TREE_CODE (TYPE_MIN_VALUE (type)) == INTEGER_CST)
8677 mpz_set_double_int (min, tree_to_double_int (TYPE_MIN_VALUE (type)),
8678 TYPE_UNSIGNED (type));
8679 else
8680 {
8681 if (TYPE_UNSIGNED (type))
8682 mpz_set_ui (min, 0);
8683 else
8684 {
8685 double_int mn;
8686 mn = double_int::mask (TYPE_PRECISION (type) - 1);
8687 mn = (mn + double_int_one).sext (TYPE_PRECISION (type));
8688 mpz_set_double_int (min, mn, false);
8689 }
8690 }
8691
8692 if (!POINTER_TYPE_P (type) && TYPE_MAX_VALUE (type)
8693 && TREE_CODE (TYPE_MAX_VALUE (type)) == INTEGER_CST)
8694 mpz_set_double_int (max, tree_to_double_int (TYPE_MAX_VALUE (type)),
8695 TYPE_UNSIGNED (type));
8696 else
8697 {
8698 if (TYPE_UNSIGNED (type))
8699 mpz_set_double_int (max, double_int::mask (TYPE_PRECISION (type)),
8700 true);
8701 else
8702 mpz_set_double_int (max, double_int::mask (TYPE_PRECISION (type) - 1),
8703 true);
8704 }
8705 }
8706
8707 /* Return true if VAR is an automatic variable defined in function FN. */
8708
8709 bool
auto_var_in_fn_p(const_tree var,const_tree fn)8710 auto_var_in_fn_p (const_tree var, const_tree fn)
8711 {
8712 return (DECL_P (var) && DECL_CONTEXT (var) == fn
8713 && ((((TREE_CODE (var) == VAR_DECL && ! DECL_EXTERNAL (var))
8714 || TREE_CODE (var) == PARM_DECL)
8715 && ! TREE_STATIC (var))
8716 || TREE_CODE (var) == LABEL_DECL
8717 || TREE_CODE (var) == RESULT_DECL));
8718 }
8719
8720 /* Subprogram of following function. Called by walk_tree.
8721
8722 Return *TP if it is an automatic variable or parameter of the
8723 function passed in as DATA. */
8724
8725 static tree
find_var_from_fn(tree * tp,int * walk_subtrees,void * data)8726 find_var_from_fn (tree *tp, int *walk_subtrees, void *data)
8727 {
8728 tree fn = (tree) data;
8729
8730 if (TYPE_P (*tp))
8731 *walk_subtrees = 0;
8732
8733 else if (DECL_P (*tp)
8734 && auto_var_in_fn_p (*tp, fn))
8735 return *tp;
8736
8737 return NULL_TREE;
8738 }
8739
8740 /* Returns true if T is, contains, or refers to a type with variable
8741 size. For METHOD_TYPEs and FUNCTION_TYPEs we exclude the
8742 arguments, but not the return type. If FN is nonzero, only return
8743 true if a modifier of the type or position of FN is a variable or
8744 parameter inside FN.
8745
8746 This concept is more general than that of C99 'variably modified types':
8747 in C99, a struct type is never variably modified because a VLA may not
8748 appear as a structure member. However, in GNU C code like:
8749
8750 struct S { int i[f()]; };
8751
8752 is valid, and other languages may define similar constructs. */
8753
8754 bool
variably_modified_type_p(tree type,tree fn)8755 variably_modified_type_p (tree type, tree fn)
8756 {
8757 tree t;
8758
8759 /* Test if T is either variable (if FN is zero) or an expression containing
8760 a variable in FN. If TYPE isn't gimplified, return true also if
8761 gimplify_one_sizepos would gimplify the expression into a local
8762 variable. */
8763 #define RETURN_TRUE_IF_VAR(T) \
8764 do { tree _t = (T); \
8765 if (_t != NULL_TREE \
8766 && _t != error_mark_node \
8767 && TREE_CODE (_t) != INTEGER_CST \
8768 && TREE_CODE (_t) != PLACEHOLDER_EXPR \
8769 && (!fn \
8770 || (!TYPE_SIZES_GIMPLIFIED (type) \
8771 && !is_gimple_sizepos (_t)) \
8772 || walk_tree (&_t, find_var_from_fn, fn, NULL))) \
8773 return true; } while (0)
8774
8775 if (type == error_mark_node)
8776 return false;
8777
8778 /* If TYPE itself has variable size, it is variably modified. */
8779 RETURN_TRUE_IF_VAR (TYPE_SIZE (type));
8780 RETURN_TRUE_IF_VAR (TYPE_SIZE_UNIT (type));
8781
8782 switch (TREE_CODE (type))
8783 {
8784 case POINTER_TYPE:
8785 case REFERENCE_TYPE:
8786 case VECTOR_TYPE:
8787 if (variably_modified_type_p (TREE_TYPE (type), fn))
8788 return true;
8789 break;
8790
8791 case FUNCTION_TYPE:
8792 case METHOD_TYPE:
8793 /* If TYPE is a function type, it is variably modified if the
8794 return type is variably modified. */
8795 if (variably_modified_type_p (TREE_TYPE (type), fn))
8796 return true;
8797 break;
8798
8799 case INTEGER_TYPE:
8800 case REAL_TYPE:
8801 case FIXED_POINT_TYPE:
8802 case ENUMERAL_TYPE:
8803 case BOOLEAN_TYPE:
8804 /* Scalar types are variably modified if their end points
8805 aren't constant. */
8806 RETURN_TRUE_IF_VAR (TYPE_MIN_VALUE (type));
8807 RETURN_TRUE_IF_VAR (TYPE_MAX_VALUE (type));
8808 break;
8809
8810 case RECORD_TYPE:
8811 case UNION_TYPE:
8812 case QUAL_UNION_TYPE:
8813 /* We can't see if any of the fields are variably-modified by the
8814 definition we normally use, since that would produce infinite
8815 recursion via pointers. */
8816 /* This is variably modified if some field's type is. */
8817 for (t = TYPE_FIELDS (type); t; t = DECL_CHAIN (t))
8818 if (TREE_CODE (t) == FIELD_DECL)
8819 {
8820 RETURN_TRUE_IF_VAR (DECL_FIELD_OFFSET (t));
8821 RETURN_TRUE_IF_VAR (DECL_SIZE (t));
8822 RETURN_TRUE_IF_VAR (DECL_SIZE_UNIT (t));
8823
8824 if (TREE_CODE (type) == QUAL_UNION_TYPE)
8825 RETURN_TRUE_IF_VAR (DECL_QUALIFIER (t));
8826 }
8827 break;
8828
8829 case ARRAY_TYPE:
8830 /* Do not call ourselves to avoid infinite recursion. This is
8831 variably modified if the element type is. */
8832 RETURN_TRUE_IF_VAR (TYPE_SIZE (TREE_TYPE (type)));
8833 RETURN_TRUE_IF_VAR (TYPE_SIZE_UNIT (TREE_TYPE (type)));
8834 break;
8835
8836 default:
8837 break;
8838 }
8839
8840 /* The current language may have other cases to check, but in general,
8841 all other types are not variably modified. */
8842 return lang_hooks.tree_inlining.var_mod_type_p (type, fn);
8843
8844 #undef RETURN_TRUE_IF_VAR
8845 }
8846
8847 /* Given a DECL or TYPE, return the scope in which it was declared, or
8848 NULL_TREE if there is no containing scope. */
8849
8850 tree
get_containing_scope(const_tree t)8851 get_containing_scope (const_tree t)
8852 {
8853 return (TYPE_P (t) ? TYPE_CONTEXT (t) : DECL_CONTEXT (t));
8854 }
8855
8856 /* Return the innermost context enclosing DECL that is
8857 a FUNCTION_DECL, or zero if none. */
8858
8859 tree
decl_function_context(const_tree decl)8860 decl_function_context (const_tree decl)
8861 {
8862 tree context;
8863
8864 if (TREE_CODE (decl) == ERROR_MARK)
8865 return 0;
8866
8867 /* C++ virtual functions use DECL_CONTEXT for the class of the vtable
8868 where we look up the function at runtime. Such functions always take
8869 a first argument of type 'pointer to real context'.
8870
8871 C++ should really be fixed to use DECL_CONTEXT for the real context,
8872 and use something else for the "virtual context". */
8873 else if (TREE_CODE (decl) == FUNCTION_DECL && DECL_VINDEX (decl))
8874 context
8875 = TYPE_MAIN_VARIANT
8876 (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl)))));
8877 else
8878 context = DECL_CONTEXT (decl);
8879
8880 while (context && TREE_CODE (context) != FUNCTION_DECL)
8881 {
8882 if (TREE_CODE (context) == BLOCK)
8883 context = BLOCK_SUPERCONTEXT (context);
8884 else
8885 context = get_containing_scope (context);
8886 }
8887
8888 return context;
8889 }
8890
8891 /* Return the innermost context enclosing DECL that is
8892 a RECORD_TYPE, UNION_TYPE or QUAL_UNION_TYPE, or zero if none.
8893 TYPE_DECLs and FUNCTION_DECLs are transparent to this function. */
8894
8895 tree
decl_type_context(const_tree decl)8896 decl_type_context (const_tree decl)
8897 {
8898 tree context = DECL_CONTEXT (decl);
8899
8900 while (context)
8901 switch (TREE_CODE (context))
8902 {
8903 case NAMESPACE_DECL:
8904 case TRANSLATION_UNIT_DECL:
8905 return NULL_TREE;
8906
8907 case RECORD_TYPE:
8908 case UNION_TYPE:
8909 case QUAL_UNION_TYPE:
8910 return context;
8911
8912 case TYPE_DECL:
8913 case FUNCTION_DECL:
8914 context = DECL_CONTEXT (context);
8915 break;
8916
8917 case BLOCK:
8918 context = BLOCK_SUPERCONTEXT (context);
8919 break;
8920
8921 default:
8922 gcc_unreachable ();
8923 }
8924
8925 return NULL_TREE;
8926 }
8927
8928 /* CALL is a CALL_EXPR. Return the declaration for the function
8929 called, or NULL_TREE if the called function cannot be
8930 determined. */
8931
8932 tree
get_callee_fndecl(const_tree call)8933 get_callee_fndecl (const_tree call)
8934 {
8935 tree addr;
8936
8937 if (call == error_mark_node)
8938 return error_mark_node;
8939
8940 /* It's invalid to call this function with anything but a
8941 CALL_EXPR. */
8942 gcc_assert (TREE_CODE (call) == CALL_EXPR);
8943
8944 /* The first operand to the CALL is the address of the function
8945 called. */
8946 addr = CALL_EXPR_FN (call);
8947
8948 STRIP_NOPS (addr);
8949
8950 /* If this is a readonly function pointer, extract its initial value. */
8951 if (DECL_P (addr) && TREE_CODE (addr) != FUNCTION_DECL
8952 && TREE_READONLY (addr) && ! TREE_THIS_VOLATILE (addr)
8953 && DECL_INITIAL (addr))
8954 addr = DECL_INITIAL (addr);
8955
8956 /* If the address is just `&f' for some function `f', then we know
8957 that `f' is being called. */
8958 if (TREE_CODE (addr) == ADDR_EXPR
8959 && TREE_CODE (TREE_OPERAND (addr, 0)) == FUNCTION_DECL)
8960 return TREE_OPERAND (addr, 0);
8961
8962 /* We couldn't figure out what was being called. */
8963 return NULL_TREE;
8964 }
8965
8966 /* Print debugging information about tree nodes generated during the compile,
8967 and any language-specific information. */
8968
8969 void
dump_tree_statistics(void)8970 dump_tree_statistics (void)
8971 {
8972 if (GATHER_STATISTICS)
8973 {
8974 int i;
8975 int total_nodes, total_bytes;
8976 fprintf (stderr, "Kind Nodes Bytes\n");
8977 fprintf (stderr, "---------------------------------------\n");
8978 total_nodes = total_bytes = 0;
8979 for (i = 0; i < (int) all_kinds; i++)
8980 {
8981 fprintf (stderr, "%-20s %7d %10d\n", tree_node_kind_names[i],
8982 tree_node_counts[i], tree_node_sizes[i]);
8983 total_nodes += tree_node_counts[i];
8984 total_bytes += tree_node_sizes[i];
8985 }
8986 fprintf (stderr, "---------------------------------------\n");
8987 fprintf (stderr, "%-20s %7d %10d\n", "Total", total_nodes, total_bytes);
8988 fprintf (stderr, "---------------------------------------\n");
8989 fprintf (stderr, "Code Nodes\n");
8990 fprintf (stderr, "----------------------------\n");
8991 for (i = 0; i < (int) MAX_TREE_CODES; i++)
8992 fprintf (stderr, "%-20s %7d\n", get_tree_code_name ((enum tree_code) i),
8993 tree_code_counts[i]);
8994 fprintf (stderr, "----------------------------\n");
8995 ssanames_print_statistics ();
8996 phinodes_print_statistics ();
8997 }
8998 else
8999 fprintf (stderr, "(No per-node statistics)\n");
9000
9001 print_type_hash_statistics ();
9002 print_debug_expr_statistics ();
9003 print_value_expr_statistics ();
9004 lang_hooks.print_statistics ();
9005 }
9006
9007 #define FILE_FUNCTION_FORMAT "_GLOBAL__%s_%s"
9008
9009 /* Generate a crc32 of a byte. */
9010
9011 static unsigned
crc32_unsigned_bits(unsigned chksum,unsigned value,unsigned bits)9012 crc32_unsigned_bits (unsigned chksum, unsigned value, unsigned bits)
9013 {
9014 unsigned ix;
9015
9016 for (ix = bits; ix--; value <<= 1)
9017 {
9018 unsigned feedback;
9019
9020 feedback = (value ^ chksum) & 0x80000000 ? 0x04c11db7 : 0;
9021 chksum <<= 1;
9022 chksum ^= feedback;
9023 }
9024 return chksum;
9025 }
9026
9027 /* Generate a crc32 of a 32-bit unsigned. */
9028
9029 unsigned
crc32_unsigned(unsigned chksum,unsigned value)9030 crc32_unsigned (unsigned chksum, unsigned value)
9031 {
9032 return crc32_unsigned_bits (chksum, value, 32);
9033 }
9034
9035 /* Generate a crc32 of a byte. */
9036
9037 unsigned
crc32_byte(unsigned chksum,char byte)9038 crc32_byte (unsigned chksum, char byte)
9039 {
9040 return crc32_unsigned_bits (chksum, (unsigned) byte << 24, 8);
9041 }
9042
9043 /* Generate a crc32 of a string. */
9044
9045 unsigned
crc32_string(unsigned chksum,const char * string)9046 crc32_string (unsigned chksum, const char *string)
9047 {
9048 do
9049 {
9050 chksum = crc32_byte (chksum, *string);
9051 }
9052 while (*string++);
9053 return chksum;
9054 }
9055
9056 /* P is a string that will be used in a symbol. Mask out any characters
9057 that are not valid in that context. */
9058
9059 void
clean_symbol_name(char * p)9060 clean_symbol_name (char *p)
9061 {
9062 for (; *p; p++)
9063 if (! (ISALNUM (*p)
9064 #ifndef NO_DOLLAR_IN_LABEL /* this for `$'; unlikely, but... -- kr */
9065 || *p == '$'
9066 #endif
9067 #ifndef NO_DOT_IN_LABEL /* this for `.'; unlikely, but... */
9068 || *p == '.'
9069 #endif
9070 ))
9071 *p = '_';
9072 }
9073
9074 /* Generate a name for a special-purpose function.
9075 The generated name may need to be unique across the whole link.
9076 Changes to this function may also require corresponding changes to
9077 xstrdup_mask_random.
9078 TYPE is some string to identify the purpose of this function to the
9079 linker or collect2; it must start with an uppercase letter,
9080 one of:
9081 I - for constructors
9082 D - for destructors
9083 N - for C++ anonymous namespaces
9084 F - for DWARF unwind frame information. */
9085
9086 tree
get_file_function_name(const char * type)9087 get_file_function_name (const char *type)
9088 {
9089 char *buf;
9090 const char *p;
9091 char *q;
9092
9093 /* If we already have a name we know to be unique, just use that. */
9094 if (first_global_object_name)
9095 p = q = ASTRDUP (first_global_object_name);
9096 /* If the target is handling the constructors/destructors, they
9097 will be local to this file and the name is only necessary for
9098 debugging purposes.
9099 We also assign sub_I and sub_D sufixes to constructors called from
9100 the global static constructors. These are always local. */
9101 else if (((type[0] == 'I' || type[0] == 'D') && targetm.have_ctors_dtors)
9102 || (strncmp (type, "sub_", 4) == 0
9103 && (type[4] == 'I' || type[4] == 'D')))
9104 {
9105 const char *file = main_input_filename;
9106 if (! file)
9107 file = LOCATION_FILE (input_location);
9108 /* Just use the file's basename, because the full pathname
9109 might be quite long. */
9110 p = q = ASTRDUP (lbasename (file));
9111 }
9112 else
9113 {
9114 /* Otherwise, the name must be unique across the entire link.
9115 We don't have anything that we know to be unique to this translation
9116 unit, so use what we do have and throw in some randomness. */
9117 unsigned len;
9118 const char *name = weak_global_object_name;
9119 const char *file = main_input_filename;
9120
9121 if (! name)
9122 name = "";
9123 if (! file)
9124 file = LOCATION_FILE (input_location);
9125
9126 len = strlen (file);
9127 q = (char *) alloca (9 + 17 + len + 1);
9128 memcpy (q, file, len + 1);
9129
9130 snprintf (q + len, 9 + 17 + 1, "_%08X_" HOST_WIDE_INT_PRINT_HEX,
9131 crc32_string (0, name), get_random_seed (false));
9132
9133 p = q;
9134 }
9135
9136 clean_symbol_name (q);
9137 buf = (char *) alloca (sizeof (FILE_FUNCTION_FORMAT) + strlen (p)
9138 + strlen (type));
9139
9140 /* Set up the name of the file-level functions we may need.
9141 Use a global object (which is already required to be unique over
9142 the program) rather than the file name (which imposes extra
9143 constraints). */
9144 sprintf (buf, FILE_FUNCTION_FORMAT, type, p);
9145
9146 return get_identifier (buf);
9147 }
9148
9149 #if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
9150
9151 /* Complain that the tree code of NODE does not match the expected 0
9152 terminated list of trailing codes. The trailing code list can be
9153 empty, for a more vague error message. FILE, LINE, and FUNCTION
9154 are of the caller. */
9155
9156 void
tree_check_failed(const_tree node,const char * file,int line,const char * function,...)9157 tree_check_failed (const_tree node, const char *file,
9158 int line, const char *function, ...)
9159 {
9160 va_list args;
9161 const char *buffer;
9162 unsigned length = 0;
9163 enum tree_code code;
9164
9165 va_start (args, function);
9166 while ((code = (enum tree_code) va_arg (args, int)))
9167 length += 4 + strlen (get_tree_code_name (code));
9168 va_end (args);
9169 if (length)
9170 {
9171 char *tmp;
9172 va_start (args, function);
9173 length += strlen ("expected ");
9174 buffer = tmp = (char *) alloca (length);
9175 length = 0;
9176 while ((code = (enum tree_code) va_arg (args, int)))
9177 {
9178 const char *prefix = length ? " or " : "expected ";
9179
9180 strcpy (tmp + length, prefix);
9181 length += strlen (prefix);
9182 strcpy (tmp + length, get_tree_code_name (code));
9183 length += strlen (get_tree_code_name (code));
9184 }
9185 va_end (args);
9186 }
9187 else
9188 buffer = "unexpected node";
9189
9190 internal_error ("tree check: %s, have %s in %s, at %s:%d",
9191 buffer, get_tree_code_name (TREE_CODE (node)),
9192 function, trim_filename (file), line);
9193 }
9194
9195 /* Complain that the tree code of NODE does match the expected 0
9196 terminated list of trailing codes. FILE, LINE, and FUNCTION are of
9197 the caller. */
9198
9199 void
tree_not_check_failed(const_tree node,const char * file,int line,const char * function,...)9200 tree_not_check_failed (const_tree node, const char *file,
9201 int line, const char *function, ...)
9202 {
9203 va_list args;
9204 char *buffer;
9205 unsigned length = 0;
9206 enum tree_code code;
9207
9208 va_start (args, function);
9209 while ((code = (enum tree_code) va_arg (args, int)))
9210 length += 4 + strlen (get_tree_code_name (code));
9211 va_end (args);
9212 va_start (args, function);
9213 buffer = (char *) alloca (length);
9214 length = 0;
9215 while ((code = (enum tree_code) va_arg (args, int)))
9216 {
9217 if (length)
9218 {
9219 strcpy (buffer + length, " or ");
9220 length += 4;
9221 }
9222 strcpy (buffer + length, get_tree_code_name (code));
9223 length += strlen (get_tree_code_name (code));
9224 }
9225 va_end (args);
9226
9227 internal_error ("tree check: expected none of %s, have %s in %s, at %s:%d",
9228 buffer, get_tree_code_name (TREE_CODE (node)),
9229 function, trim_filename (file), line);
9230 }
9231
9232 /* Similar to tree_check_failed, except that we check for a class of tree
9233 code, given in CL. */
9234
9235 void
tree_class_check_failed(const_tree node,const enum tree_code_class cl,const char * file,int line,const char * function)9236 tree_class_check_failed (const_tree node, const enum tree_code_class cl,
9237 const char *file, int line, const char *function)
9238 {
9239 internal_error
9240 ("tree check: expected class %qs, have %qs (%s) in %s, at %s:%d",
9241 TREE_CODE_CLASS_STRING (cl),
9242 TREE_CODE_CLASS_STRING (TREE_CODE_CLASS (TREE_CODE (node))),
9243 get_tree_code_name (TREE_CODE (node)), function, trim_filename (file), line);
9244 }
9245
9246 /* Similar to tree_check_failed, except that instead of specifying a
9247 dozen codes, use the knowledge that they're all sequential. */
9248
9249 void
tree_range_check_failed(const_tree node,const char * file,int line,const char * function,enum tree_code c1,enum tree_code c2)9250 tree_range_check_failed (const_tree node, const char *file, int line,
9251 const char *function, enum tree_code c1,
9252 enum tree_code c2)
9253 {
9254 char *buffer;
9255 unsigned length = 0;
9256 unsigned int c;
9257
9258 for (c = c1; c <= c2; ++c)
9259 length += 4 + strlen (get_tree_code_name ((enum tree_code) c));
9260
9261 length += strlen ("expected ");
9262 buffer = (char *) alloca (length);
9263 length = 0;
9264
9265 for (c = c1; c <= c2; ++c)
9266 {
9267 const char *prefix = length ? " or " : "expected ";
9268
9269 strcpy (buffer + length, prefix);
9270 length += strlen (prefix);
9271 strcpy (buffer + length, get_tree_code_name ((enum tree_code) c));
9272 length += strlen (get_tree_code_name ((enum tree_code) c));
9273 }
9274
9275 internal_error ("tree check: %s, have %s in %s, at %s:%d",
9276 buffer, get_tree_code_name (TREE_CODE (node)),
9277 function, trim_filename (file), line);
9278 }
9279
9280
9281 /* Similar to tree_check_failed, except that we check that a tree does
9282 not have the specified code, given in CL. */
9283
9284 void
tree_not_class_check_failed(const_tree node,const enum tree_code_class cl,const char * file,int line,const char * function)9285 tree_not_class_check_failed (const_tree node, const enum tree_code_class cl,
9286 const char *file, int line, const char *function)
9287 {
9288 internal_error
9289 ("tree check: did not expect class %qs, have %qs (%s) in %s, at %s:%d",
9290 TREE_CODE_CLASS_STRING (cl),
9291 TREE_CODE_CLASS_STRING (TREE_CODE_CLASS (TREE_CODE (node))),
9292 get_tree_code_name (TREE_CODE (node)), function, trim_filename (file), line);
9293 }
9294
9295
9296 /* Similar to tree_check_failed but applied to OMP_CLAUSE codes. */
9297
9298 void
omp_clause_check_failed(const_tree node,const char * file,int line,const char * function,enum omp_clause_code code)9299 omp_clause_check_failed (const_tree node, const char *file, int line,
9300 const char *function, enum omp_clause_code code)
9301 {
9302 internal_error ("tree check: expected omp_clause %s, have %s in %s, at %s:%d",
9303 omp_clause_code_name[code], get_tree_code_name (TREE_CODE (node)),
9304 function, trim_filename (file), line);
9305 }
9306
9307
9308 /* Similar to tree_range_check_failed but applied to OMP_CLAUSE codes. */
9309
9310 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)9311 omp_clause_range_check_failed (const_tree node, const char *file, int line,
9312 const char *function, enum omp_clause_code c1,
9313 enum omp_clause_code c2)
9314 {
9315 char *buffer;
9316 unsigned length = 0;
9317 unsigned int c;
9318
9319 for (c = c1; c <= c2; ++c)
9320 length += 4 + strlen (omp_clause_code_name[c]);
9321
9322 length += strlen ("expected ");
9323 buffer = (char *) alloca (length);
9324 length = 0;
9325
9326 for (c = c1; c <= c2; ++c)
9327 {
9328 const char *prefix = length ? " or " : "expected ";
9329
9330 strcpy (buffer + length, prefix);
9331 length += strlen (prefix);
9332 strcpy (buffer + length, omp_clause_code_name[c]);
9333 length += strlen (omp_clause_code_name[c]);
9334 }
9335
9336 internal_error ("tree check: %s, have %s in %s, at %s:%d",
9337 buffer, omp_clause_code_name[TREE_CODE (node)],
9338 function, trim_filename (file), line);
9339 }
9340
9341
9342 #undef DEFTREESTRUCT
9343 #define DEFTREESTRUCT(VAL, NAME) NAME,
9344
9345 static const char *ts_enum_names[] = {
9346 #include "treestruct.def"
9347 };
9348 #undef DEFTREESTRUCT
9349
9350 #define TS_ENUM_NAME(EN) (ts_enum_names[(EN)])
9351
9352 /* Similar to tree_class_check_failed, except that we check for
9353 whether CODE contains the tree structure identified by EN. */
9354
9355 void
tree_contains_struct_check_failed(const_tree node,const enum tree_node_structure_enum en,const char * file,int line,const char * function)9356 tree_contains_struct_check_failed (const_tree node,
9357 const enum tree_node_structure_enum en,
9358 const char *file, int line,
9359 const char *function)
9360 {
9361 internal_error
9362 ("tree check: expected tree that contains %qs structure, have %qs in %s, at %s:%d",
9363 TS_ENUM_NAME (en),
9364 get_tree_code_name (TREE_CODE (node)), function, trim_filename (file), line);
9365 }
9366
9367
9368 /* Similar to above, except that the check is for the bounds of a TREE_VEC's
9369 (dynamically sized) vector. */
9370
9371 void
tree_vec_elt_check_failed(int idx,int len,const char * file,int line,const char * function)9372 tree_vec_elt_check_failed (int idx, int len, const char *file, int line,
9373 const char *function)
9374 {
9375 internal_error
9376 ("tree check: accessed elt %d of tree_vec with %d elts in %s, at %s:%d",
9377 idx + 1, len, function, trim_filename (file), line);
9378 }
9379
9380 /* Similar to above, except that the check is for the bounds of the operand
9381 vector of an expression node EXP. */
9382
9383 void
tree_operand_check_failed(int idx,const_tree exp,const char * file,int line,const char * function)9384 tree_operand_check_failed (int idx, const_tree exp, const char *file,
9385 int line, const char *function)
9386 {
9387 enum tree_code code = TREE_CODE (exp);
9388 internal_error
9389 ("tree check: accessed operand %d of %s with %d operands in %s, at %s:%d",
9390 idx + 1, get_tree_code_name (code), TREE_OPERAND_LENGTH (exp),
9391 function, trim_filename (file), line);
9392 }
9393
9394 /* Similar to above, except that the check is for the number of
9395 operands of an OMP_CLAUSE node. */
9396
9397 void
omp_clause_operand_check_failed(int idx,const_tree t,const char * file,int line,const char * function)9398 omp_clause_operand_check_failed (int idx, const_tree t, const char *file,
9399 int line, const char *function)
9400 {
9401 internal_error
9402 ("tree check: accessed operand %d of omp_clause %s with %d operands "
9403 "in %s, at %s:%d", idx + 1, omp_clause_code_name[OMP_CLAUSE_CODE (t)],
9404 omp_clause_num_ops [OMP_CLAUSE_CODE (t)], function,
9405 trim_filename (file), line);
9406 }
9407 #endif /* ENABLE_TREE_CHECKING */
9408
9409 /* Create a new vector type node holding SUBPARTS units of type INNERTYPE,
9410 and mapped to the machine mode MODE. Initialize its fields and build
9411 the information necessary for debugging output. */
9412
9413 static tree
make_vector_type(tree innertype,int nunits,enum machine_mode mode)9414 make_vector_type (tree innertype, int nunits, enum machine_mode mode)
9415 {
9416 tree t;
9417 hashval_t hashcode = 0;
9418
9419 t = make_node (VECTOR_TYPE);
9420 TREE_TYPE (t) = TYPE_MAIN_VARIANT (innertype);
9421 SET_TYPE_VECTOR_SUBPARTS (t, nunits);
9422 SET_TYPE_MODE (t, mode);
9423
9424 if (TYPE_STRUCTURAL_EQUALITY_P (innertype))
9425 SET_TYPE_STRUCTURAL_EQUALITY (t);
9426 else if (TYPE_CANONICAL (innertype) != innertype
9427 || mode != VOIDmode)
9428 TYPE_CANONICAL (t)
9429 = make_vector_type (TYPE_CANONICAL (innertype), nunits, VOIDmode);
9430
9431 layout_type (t);
9432
9433 hashcode = iterative_hash_host_wide_int (VECTOR_TYPE, hashcode);
9434 hashcode = iterative_hash_host_wide_int (nunits, hashcode);
9435 hashcode = iterative_hash_host_wide_int (mode, hashcode);
9436 hashcode = iterative_hash_object (TYPE_HASH (TREE_TYPE (t)), hashcode);
9437 t = type_hash_canon (hashcode, t);
9438
9439 /* We have built a main variant, based on the main variant of the
9440 inner type. Use it to build the variant we return. */
9441 if ((TYPE_ATTRIBUTES (innertype) || TYPE_QUALS (innertype))
9442 && TREE_TYPE (t) != innertype)
9443 return build_type_attribute_qual_variant (t,
9444 TYPE_ATTRIBUTES (innertype),
9445 TYPE_QUALS (innertype));
9446
9447 return t;
9448 }
9449
9450 static tree
make_or_reuse_type(unsigned size,int unsignedp)9451 make_or_reuse_type (unsigned size, int unsignedp)
9452 {
9453 if (size == INT_TYPE_SIZE)
9454 return unsignedp ? unsigned_type_node : integer_type_node;
9455 if (size == CHAR_TYPE_SIZE)
9456 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
9457 if (size == SHORT_TYPE_SIZE)
9458 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
9459 if (size == LONG_TYPE_SIZE)
9460 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
9461 if (size == LONG_LONG_TYPE_SIZE)
9462 return (unsignedp ? long_long_unsigned_type_node
9463 : long_long_integer_type_node);
9464 if (size == 128 && int128_integer_type_node)
9465 return (unsignedp ? int128_unsigned_type_node
9466 : int128_integer_type_node);
9467
9468 if (unsignedp)
9469 return make_unsigned_type (size);
9470 else
9471 return make_signed_type (size);
9472 }
9473
9474 /* Create or reuse a fract type by SIZE, UNSIGNEDP, and SATP. */
9475
9476 static tree
make_or_reuse_fract_type(unsigned size,int unsignedp,int satp)9477 make_or_reuse_fract_type (unsigned size, int unsignedp, int satp)
9478 {
9479 if (satp)
9480 {
9481 if (size == SHORT_FRACT_TYPE_SIZE)
9482 return unsignedp ? sat_unsigned_short_fract_type_node
9483 : sat_short_fract_type_node;
9484 if (size == FRACT_TYPE_SIZE)
9485 return unsignedp ? sat_unsigned_fract_type_node : sat_fract_type_node;
9486 if (size == LONG_FRACT_TYPE_SIZE)
9487 return unsignedp ? sat_unsigned_long_fract_type_node
9488 : sat_long_fract_type_node;
9489 if (size == LONG_LONG_FRACT_TYPE_SIZE)
9490 return unsignedp ? sat_unsigned_long_long_fract_type_node
9491 : sat_long_long_fract_type_node;
9492 }
9493 else
9494 {
9495 if (size == SHORT_FRACT_TYPE_SIZE)
9496 return unsignedp ? unsigned_short_fract_type_node
9497 : short_fract_type_node;
9498 if (size == FRACT_TYPE_SIZE)
9499 return unsignedp ? unsigned_fract_type_node : fract_type_node;
9500 if (size == LONG_FRACT_TYPE_SIZE)
9501 return unsignedp ? unsigned_long_fract_type_node
9502 : long_fract_type_node;
9503 if (size == LONG_LONG_FRACT_TYPE_SIZE)
9504 return unsignedp ? unsigned_long_long_fract_type_node
9505 : long_long_fract_type_node;
9506 }
9507
9508 return make_fract_type (size, unsignedp, satp);
9509 }
9510
9511 /* Create or reuse an accum type by SIZE, UNSIGNEDP, and SATP. */
9512
9513 static tree
make_or_reuse_accum_type(unsigned size,int unsignedp,int satp)9514 make_or_reuse_accum_type (unsigned size, int unsignedp, int satp)
9515 {
9516 if (satp)
9517 {
9518 if (size == SHORT_ACCUM_TYPE_SIZE)
9519 return unsignedp ? sat_unsigned_short_accum_type_node
9520 : sat_short_accum_type_node;
9521 if (size == ACCUM_TYPE_SIZE)
9522 return unsignedp ? sat_unsigned_accum_type_node : sat_accum_type_node;
9523 if (size == LONG_ACCUM_TYPE_SIZE)
9524 return unsignedp ? sat_unsigned_long_accum_type_node
9525 : sat_long_accum_type_node;
9526 if (size == LONG_LONG_ACCUM_TYPE_SIZE)
9527 return unsignedp ? sat_unsigned_long_long_accum_type_node
9528 : sat_long_long_accum_type_node;
9529 }
9530 else
9531 {
9532 if (size == SHORT_ACCUM_TYPE_SIZE)
9533 return unsignedp ? unsigned_short_accum_type_node
9534 : short_accum_type_node;
9535 if (size == ACCUM_TYPE_SIZE)
9536 return unsignedp ? unsigned_accum_type_node : accum_type_node;
9537 if (size == LONG_ACCUM_TYPE_SIZE)
9538 return unsignedp ? unsigned_long_accum_type_node
9539 : long_accum_type_node;
9540 if (size == LONG_LONG_ACCUM_TYPE_SIZE)
9541 return unsignedp ? unsigned_long_long_accum_type_node
9542 : long_long_accum_type_node;
9543 }
9544
9545 return make_accum_type (size, unsignedp, satp);
9546 }
9547
9548
9549 /* Create an atomic variant node for TYPE. This routine is called
9550 during initialization of data types to create the 5 basic atomic
9551 types. The generic build_variant_type function requires these to
9552 already be set up in order to function properly, so cannot be
9553 called from there. If ALIGN is non-zero, then ensure alignment is
9554 overridden to this value. */
9555
9556 static tree
build_atomic_base(tree type,unsigned int align)9557 build_atomic_base (tree type, unsigned int align)
9558 {
9559 tree t;
9560
9561 /* Make sure its not already registered. */
9562 if ((t = get_qualified_type (type, TYPE_QUAL_ATOMIC)))
9563 return t;
9564
9565 t = build_variant_type_copy (type);
9566 set_type_quals (t, TYPE_QUAL_ATOMIC);
9567
9568 if (align)
9569 TYPE_ALIGN (t) = align;
9570
9571 return t;
9572 }
9573
9574 /* Create nodes for all integer types (and error_mark_node) using the sizes
9575 of C datatypes. SIGNED_CHAR specifies whether char is signed,
9576 SHORT_DOUBLE specifies whether double should be of the same precision
9577 as float. */
9578
9579 void
build_common_tree_nodes(bool signed_char,bool short_double)9580 build_common_tree_nodes (bool signed_char, bool short_double)
9581 {
9582 error_mark_node = make_node (ERROR_MARK);
9583 TREE_TYPE (error_mark_node) = error_mark_node;
9584
9585 initialize_sizetypes ();
9586
9587 /* Define both `signed char' and `unsigned char'. */
9588 signed_char_type_node = make_signed_type (CHAR_TYPE_SIZE);
9589 TYPE_STRING_FLAG (signed_char_type_node) = 1;
9590 unsigned_char_type_node = make_unsigned_type (CHAR_TYPE_SIZE);
9591 TYPE_STRING_FLAG (unsigned_char_type_node) = 1;
9592
9593 /* Define `char', which is like either `signed char' or `unsigned char'
9594 but not the same as either. */
9595 char_type_node
9596 = (signed_char
9597 ? make_signed_type (CHAR_TYPE_SIZE)
9598 : make_unsigned_type (CHAR_TYPE_SIZE));
9599 TYPE_STRING_FLAG (char_type_node) = 1;
9600
9601 short_integer_type_node = make_signed_type (SHORT_TYPE_SIZE);
9602 short_unsigned_type_node = make_unsigned_type (SHORT_TYPE_SIZE);
9603 integer_type_node = make_signed_type (INT_TYPE_SIZE);
9604 unsigned_type_node = make_unsigned_type (INT_TYPE_SIZE);
9605 long_integer_type_node = make_signed_type (LONG_TYPE_SIZE);
9606 long_unsigned_type_node = make_unsigned_type (LONG_TYPE_SIZE);
9607 long_long_integer_type_node = make_signed_type (LONG_LONG_TYPE_SIZE);
9608 long_long_unsigned_type_node = make_unsigned_type (LONG_LONG_TYPE_SIZE);
9609 #if HOST_BITS_PER_WIDE_INT >= 64
9610 /* TODO: This isn't correct, but as logic depends at the moment on
9611 host's instead of target's wide-integer.
9612 If there is a target not supporting TImode, but has an 128-bit
9613 integer-scalar register, this target check needs to be adjusted. */
9614 if (targetm.scalar_mode_supported_p (TImode))
9615 {
9616 int128_integer_type_node = make_signed_type (128);
9617 int128_unsigned_type_node = make_unsigned_type (128);
9618 }
9619 #endif
9620
9621 /* Define a boolean type. This type only represents boolean values but
9622 may be larger than char depending on the value of BOOL_TYPE_SIZE.
9623 Front ends which want to override this size (i.e. Java) can redefine
9624 boolean_type_node before calling build_common_tree_nodes_2. */
9625 boolean_type_node = make_unsigned_type (BOOL_TYPE_SIZE);
9626 TREE_SET_CODE (boolean_type_node, BOOLEAN_TYPE);
9627 TYPE_MAX_VALUE (boolean_type_node) = build_int_cst (boolean_type_node, 1);
9628 TYPE_PRECISION (boolean_type_node) = 1;
9629
9630 /* Define what type to use for size_t. */
9631 if (strcmp (SIZE_TYPE, "unsigned int") == 0)
9632 size_type_node = unsigned_type_node;
9633 else if (strcmp (SIZE_TYPE, "long unsigned int") == 0)
9634 size_type_node = long_unsigned_type_node;
9635 else if (strcmp (SIZE_TYPE, "long long unsigned int") == 0)
9636 size_type_node = long_long_unsigned_type_node;
9637 else if (strcmp (SIZE_TYPE, "short unsigned int") == 0)
9638 size_type_node = short_unsigned_type_node;
9639 else
9640 gcc_unreachable ();
9641
9642 /* Fill in the rest of the sized types. Reuse existing type nodes
9643 when possible. */
9644 intQI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (QImode), 0);
9645 intHI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (HImode), 0);
9646 intSI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (SImode), 0);
9647 intDI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (DImode), 0);
9648 intTI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (TImode), 0);
9649
9650 unsigned_intQI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (QImode), 1);
9651 unsigned_intHI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (HImode), 1);
9652 unsigned_intSI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (SImode), 1);
9653 unsigned_intDI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (DImode), 1);
9654 unsigned_intTI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (TImode), 1);
9655
9656 /* Don't call build_qualified type for atomics. That routine does
9657 special processing for atomics, and until they are initialized
9658 it's better not to make that call.
9659
9660 Check to see if there is a target override for atomic types. */
9661
9662 atomicQI_type_node = build_atomic_base (unsigned_intQI_type_node,
9663 targetm.atomic_align_for_mode (QImode));
9664 atomicHI_type_node = build_atomic_base (unsigned_intHI_type_node,
9665 targetm.atomic_align_for_mode (HImode));
9666 atomicSI_type_node = build_atomic_base (unsigned_intSI_type_node,
9667 targetm.atomic_align_for_mode (SImode));
9668 atomicDI_type_node = build_atomic_base (unsigned_intDI_type_node,
9669 targetm.atomic_align_for_mode (DImode));
9670 atomicTI_type_node = build_atomic_base (unsigned_intTI_type_node,
9671 targetm.atomic_align_for_mode (TImode));
9672
9673 access_public_node = get_identifier ("public");
9674 access_protected_node = get_identifier ("protected");
9675 access_private_node = get_identifier ("private");
9676
9677 /* Define these next since types below may used them. */
9678 integer_zero_node = build_int_cst (integer_type_node, 0);
9679 integer_one_node = build_int_cst (integer_type_node, 1);
9680 integer_three_node = build_int_cst (integer_type_node, 3);
9681 integer_minus_one_node = build_int_cst (integer_type_node, -1);
9682
9683 size_zero_node = size_int (0);
9684 size_one_node = size_int (1);
9685 bitsize_zero_node = bitsize_int (0);
9686 bitsize_one_node = bitsize_int (1);
9687 bitsize_unit_node = bitsize_int (BITS_PER_UNIT);
9688
9689 boolean_false_node = TYPE_MIN_VALUE (boolean_type_node);
9690 boolean_true_node = TYPE_MAX_VALUE (boolean_type_node);
9691
9692 void_type_node = make_node (VOID_TYPE);
9693 layout_type (void_type_node);
9694
9695 /* We are not going to have real types in C with less than byte alignment,
9696 so we might as well not have any types that claim to have it. */
9697 TYPE_ALIGN (void_type_node) = BITS_PER_UNIT;
9698 TYPE_USER_ALIGN (void_type_node) = 0;
9699
9700 null_pointer_node = build_int_cst (build_pointer_type (void_type_node), 0);
9701 layout_type (TREE_TYPE (null_pointer_node));
9702
9703 ptr_type_node = build_pointer_type (void_type_node);
9704 const_ptr_type_node
9705 = build_pointer_type (build_type_variant (void_type_node, 1, 0));
9706 fileptr_type_node = ptr_type_node;
9707
9708 pointer_sized_int_node = build_nonstandard_integer_type (POINTER_SIZE, 1);
9709
9710 float_type_node = make_node (REAL_TYPE);
9711 TYPE_PRECISION (float_type_node) = FLOAT_TYPE_SIZE;
9712 layout_type (float_type_node);
9713
9714 double_type_node = make_node (REAL_TYPE);
9715 if (short_double)
9716 TYPE_PRECISION (double_type_node) = FLOAT_TYPE_SIZE;
9717 else
9718 TYPE_PRECISION (double_type_node) = DOUBLE_TYPE_SIZE;
9719 layout_type (double_type_node);
9720
9721 long_double_type_node = make_node (REAL_TYPE);
9722 TYPE_PRECISION (long_double_type_node) = LONG_DOUBLE_TYPE_SIZE;
9723 layout_type (long_double_type_node);
9724
9725 float_ptr_type_node = build_pointer_type (float_type_node);
9726 double_ptr_type_node = build_pointer_type (double_type_node);
9727 long_double_ptr_type_node = build_pointer_type (long_double_type_node);
9728 integer_ptr_type_node = build_pointer_type (integer_type_node);
9729
9730 /* Fixed size integer types. */
9731 uint16_type_node = build_nonstandard_integer_type (16, true);
9732 uint32_type_node = build_nonstandard_integer_type (32, true);
9733 uint64_type_node = build_nonstandard_integer_type (64, true);
9734
9735 /* Decimal float types. */
9736 dfloat32_type_node = make_node (REAL_TYPE);
9737 TYPE_PRECISION (dfloat32_type_node) = DECIMAL32_TYPE_SIZE;
9738 layout_type (dfloat32_type_node);
9739 SET_TYPE_MODE (dfloat32_type_node, SDmode);
9740 dfloat32_ptr_type_node = build_pointer_type (dfloat32_type_node);
9741
9742 dfloat64_type_node = make_node (REAL_TYPE);
9743 TYPE_PRECISION (dfloat64_type_node) = DECIMAL64_TYPE_SIZE;
9744 layout_type (dfloat64_type_node);
9745 SET_TYPE_MODE (dfloat64_type_node, DDmode);
9746 dfloat64_ptr_type_node = build_pointer_type (dfloat64_type_node);
9747
9748 dfloat128_type_node = make_node (REAL_TYPE);
9749 TYPE_PRECISION (dfloat128_type_node) = DECIMAL128_TYPE_SIZE;
9750 layout_type (dfloat128_type_node);
9751 SET_TYPE_MODE (dfloat128_type_node, TDmode);
9752 dfloat128_ptr_type_node = build_pointer_type (dfloat128_type_node);
9753
9754 complex_integer_type_node = build_complex_type (integer_type_node);
9755 complex_float_type_node = build_complex_type (float_type_node);
9756 complex_double_type_node = build_complex_type (double_type_node);
9757 complex_long_double_type_node = build_complex_type (long_double_type_node);
9758
9759 /* Make fixed-point nodes based on sat/non-sat and signed/unsigned. */
9760 #define MAKE_FIXED_TYPE_NODE(KIND,SIZE) \
9761 sat_ ## KIND ## _type_node = \
9762 make_sat_signed_ ## KIND ## _type (SIZE); \
9763 sat_unsigned_ ## KIND ## _type_node = \
9764 make_sat_unsigned_ ## KIND ## _type (SIZE); \
9765 KIND ## _type_node = make_signed_ ## KIND ## _type (SIZE); \
9766 unsigned_ ## KIND ## _type_node = \
9767 make_unsigned_ ## KIND ## _type (SIZE);
9768
9769 #define MAKE_FIXED_TYPE_NODE_WIDTH(KIND,WIDTH,SIZE) \
9770 sat_ ## WIDTH ## KIND ## _type_node = \
9771 make_sat_signed_ ## KIND ## _type (SIZE); \
9772 sat_unsigned_ ## WIDTH ## KIND ## _type_node = \
9773 make_sat_unsigned_ ## KIND ## _type (SIZE); \
9774 WIDTH ## KIND ## _type_node = make_signed_ ## KIND ## _type (SIZE); \
9775 unsigned_ ## WIDTH ## KIND ## _type_node = \
9776 make_unsigned_ ## KIND ## _type (SIZE);
9777
9778 /* Make fixed-point type nodes based on four different widths. */
9779 #define MAKE_FIXED_TYPE_NODE_FAMILY(N1,N2) \
9780 MAKE_FIXED_TYPE_NODE_WIDTH (N1, short_, SHORT_ ## N2 ## _TYPE_SIZE) \
9781 MAKE_FIXED_TYPE_NODE (N1, N2 ## _TYPE_SIZE) \
9782 MAKE_FIXED_TYPE_NODE_WIDTH (N1, long_, LONG_ ## N2 ## _TYPE_SIZE) \
9783 MAKE_FIXED_TYPE_NODE_WIDTH (N1, long_long_, LONG_LONG_ ## N2 ## _TYPE_SIZE)
9784
9785 /* Make fixed-point mode nodes based on sat/non-sat and signed/unsigned. */
9786 #define MAKE_FIXED_MODE_NODE(KIND,NAME,MODE) \
9787 NAME ## _type_node = \
9788 make_or_reuse_signed_ ## KIND ## _type (GET_MODE_BITSIZE (MODE ## mode)); \
9789 u ## NAME ## _type_node = \
9790 make_or_reuse_unsigned_ ## KIND ## _type \
9791 (GET_MODE_BITSIZE (U ## MODE ## mode)); \
9792 sat_ ## NAME ## _type_node = \
9793 make_or_reuse_sat_signed_ ## KIND ## _type \
9794 (GET_MODE_BITSIZE (MODE ## mode)); \
9795 sat_u ## NAME ## _type_node = \
9796 make_or_reuse_sat_unsigned_ ## KIND ## _type \
9797 (GET_MODE_BITSIZE (U ## MODE ## mode));
9798
9799 /* Fixed-point type and mode nodes. */
9800 MAKE_FIXED_TYPE_NODE_FAMILY (fract, FRACT)
9801 MAKE_FIXED_TYPE_NODE_FAMILY (accum, ACCUM)
9802 MAKE_FIXED_MODE_NODE (fract, qq, QQ)
9803 MAKE_FIXED_MODE_NODE (fract, hq, HQ)
9804 MAKE_FIXED_MODE_NODE (fract, sq, SQ)
9805 MAKE_FIXED_MODE_NODE (fract, dq, DQ)
9806 MAKE_FIXED_MODE_NODE (fract, tq, TQ)
9807 MAKE_FIXED_MODE_NODE (accum, ha, HA)
9808 MAKE_FIXED_MODE_NODE (accum, sa, SA)
9809 MAKE_FIXED_MODE_NODE (accum, da, DA)
9810 MAKE_FIXED_MODE_NODE (accum, ta, TA)
9811
9812 {
9813 tree t = targetm.build_builtin_va_list ();
9814
9815 /* Many back-ends define record types without setting TYPE_NAME.
9816 If we copied the record type here, we'd keep the original
9817 record type without a name. This breaks name mangling. So,
9818 don't copy record types and let c_common_nodes_and_builtins()
9819 declare the type to be __builtin_va_list. */
9820 if (TREE_CODE (t) != RECORD_TYPE)
9821 t = build_variant_type_copy (t);
9822
9823 va_list_type_node = t;
9824 }
9825 }
9826
9827 /* Modify DECL for given flags.
9828 TM_PURE attribute is set only on types, so the function will modify
9829 DECL's type when ECF_TM_PURE is used. */
9830
9831 void
set_call_expr_flags(tree decl,int flags)9832 set_call_expr_flags (tree decl, int flags)
9833 {
9834 if (flags & ECF_NOTHROW)
9835 TREE_NOTHROW (decl) = 1;
9836 if (flags & ECF_CONST)
9837 TREE_READONLY (decl) = 1;
9838 if (flags & ECF_PURE)
9839 DECL_PURE_P (decl) = 1;
9840 if (flags & ECF_LOOPING_CONST_OR_PURE)
9841 DECL_LOOPING_CONST_OR_PURE_P (decl) = 1;
9842 if (flags & ECF_NOVOPS)
9843 DECL_IS_NOVOPS (decl) = 1;
9844 if (flags & ECF_NORETURN)
9845 TREE_THIS_VOLATILE (decl) = 1;
9846 if (flags & ECF_MALLOC)
9847 DECL_IS_MALLOC (decl) = 1;
9848 if (flags & ECF_RETURNS_TWICE)
9849 DECL_IS_RETURNS_TWICE (decl) = 1;
9850 if (flags & ECF_LEAF)
9851 DECL_ATTRIBUTES (decl) = tree_cons (get_identifier ("leaf"),
9852 NULL, DECL_ATTRIBUTES (decl));
9853 if ((flags & ECF_TM_PURE) && flag_tm)
9854 apply_tm_attr (decl, get_identifier ("transaction_pure"));
9855 /* Looping const or pure is implied by noreturn.
9856 There is currently no way to declare looping const or looping pure alone. */
9857 gcc_assert (!(flags & ECF_LOOPING_CONST_OR_PURE)
9858 || ((flags & ECF_NORETURN) && (flags & (ECF_CONST | ECF_PURE))));
9859 }
9860
9861
9862 /* A subroutine of build_common_builtin_nodes. Define a builtin function. */
9863
9864 static void
local_define_builtin(const char * name,tree type,enum built_in_function code,const char * library_name,int ecf_flags)9865 local_define_builtin (const char *name, tree type, enum built_in_function code,
9866 const char *library_name, int ecf_flags)
9867 {
9868 tree decl;
9869
9870 decl = add_builtin_function (name, type, code, BUILT_IN_NORMAL,
9871 library_name, NULL_TREE);
9872 set_call_expr_flags (decl, ecf_flags);
9873
9874 set_builtin_decl (code, decl, true);
9875 }
9876
9877 /* Call this function after instantiating all builtins that the language
9878 front end cares about. This will build the rest of the builtins
9879 and internal functions that are relied upon by the tree optimizers and
9880 the middle-end. */
9881
9882 void
build_common_builtin_nodes(void)9883 build_common_builtin_nodes (void)
9884 {
9885 tree tmp, ftype;
9886 int ecf_flags;
9887
9888 if (!builtin_decl_explicit_p (BUILT_IN_UNREACHABLE))
9889 {
9890 ftype = build_function_type (void_type_node, void_list_node);
9891 local_define_builtin ("__builtin_unreachable", ftype, BUILT_IN_UNREACHABLE,
9892 "__builtin_unreachable",
9893 ECF_NOTHROW | ECF_LEAF | ECF_NORETURN
9894 | ECF_CONST | ECF_LEAF);
9895 }
9896
9897 if (!builtin_decl_explicit_p (BUILT_IN_MEMCPY)
9898 || !builtin_decl_explicit_p (BUILT_IN_MEMMOVE))
9899 {
9900 ftype = build_function_type_list (ptr_type_node,
9901 ptr_type_node, const_ptr_type_node,
9902 size_type_node, NULL_TREE);
9903
9904 if (!builtin_decl_explicit_p (BUILT_IN_MEMCPY))
9905 local_define_builtin ("__builtin_memcpy", ftype, BUILT_IN_MEMCPY,
9906 "memcpy", ECF_NOTHROW | ECF_LEAF);
9907 if (!builtin_decl_explicit_p (BUILT_IN_MEMMOVE))
9908 local_define_builtin ("__builtin_memmove", ftype, BUILT_IN_MEMMOVE,
9909 "memmove", ECF_NOTHROW | ECF_LEAF);
9910 }
9911
9912 if (!builtin_decl_explicit_p (BUILT_IN_MEMCMP))
9913 {
9914 ftype = build_function_type_list (integer_type_node, const_ptr_type_node,
9915 const_ptr_type_node, size_type_node,
9916 NULL_TREE);
9917 local_define_builtin ("__builtin_memcmp", ftype, BUILT_IN_MEMCMP,
9918 "memcmp", ECF_PURE | ECF_NOTHROW | ECF_LEAF);
9919 }
9920
9921 if (!builtin_decl_explicit_p (BUILT_IN_MEMSET))
9922 {
9923 ftype = build_function_type_list (ptr_type_node,
9924 ptr_type_node, integer_type_node,
9925 size_type_node, NULL_TREE);
9926 local_define_builtin ("__builtin_memset", ftype, BUILT_IN_MEMSET,
9927 "memset", ECF_NOTHROW | ECF_LEAF);
9928 }
9929
9930 if (!builtin_decl_explicit_p (BUILT_IN_ALLOCA))
9931 {
9932 ftype = build_function_type_list (ptr_type_node,
9933 size_type_node, NULL_TREE);
9934 local_define_builtin ("__builtin_alloca", ftype, BUILT_IN_ALLOCA,
9935 "alloca", ECF_MALLOC | ECF_NOTHROW | ECF_LEAF);
9936 }
9937
9938 ftype = build_function_type_list (ptr_type_node, size_type_node,
9939 size_type_node, NULL_TREE);
9940 local_define_builtin ("__builtin_alloca_with_align", ftype,
9941 BUILT_IN_ALLOCA_WITH_ALIGN, "alloca",
9942 ECF_MALLOC | ECF_NOTHROW | ECF_LEAF);
9943
9944 /* If we're checking the stack, `alloca' can throw. */
9945 if (flag_stack_check)
9946 {
9947 TREE_NOTHROW (builtin_decl_explicit (BUILT_IN_ALLOCA)) = 0;
9948 TREE_NOTHROW (builtin_decl_explicit (BUILT_IN_ALLOCA_WITH_ALIGN)) = 0;
9949 }
9950
9951 ftype = build_function_type_list (void_type_node,
9952 ptr_type_node, ptr_type_node,
9953 ptr_type_node, NULL_TREE);
9954 local_define_builtin ("__builtin_init_trampoline", ftype,
9955 BUILT_IN_INIT_TRAMPOLINE,
9956 "__builtin_init_trampoline", ECF_NOTHROW | ECF_LEAF);
9957 local_define_builtin ("__builtin_init_heap_trampoline", ftype,
9958 BUILT_IN_INIT_HEAP_TRAMPOLINE,
9959 "__builtin_init_heap_trampoline",
9960 ECF_NOTHROW | ECF_LEAF);
9961
9962 ftype = build_function_type_list (ptr_type_node, ptr_type_node, NULL_TREE);
9963 local_define_builtin ("__builtin_adjust_trampoline", ftype,
9964 BUILT_IN_ADJUST_TRAMPOLINE,
9965 "__builtin_adjust_trampoline",
9966 ECF_CONST | ECF_NOTHROW);
9967
9968 ftype = build_function_type_list (void_type_node,
9969 ptr_type_node, ptr_type_node, NULL_TREE);
9970 local_define_builtin ("__builtin_nonlocal_goto", ftype,
9971 BUILT_IN_NONLOCAL_GOTO,
9972 "__builtin_nonlocal_goto",
9973 ECF_NORETURN | ECF_NOTHROW);
9974
9975 ftype = build_function_type_list (void_type_node,
9976 ptr_type_node, ptr_type_node, NULL_TREE);
9977 local_define_builtin ("__builtin_setjmp_setup", ftype,
9978 BUILT_IN_SETJMP_SETUP,
9979 "__builtin_setjmp_setup", ECF_NOTHROW);
9980
9981 ftype = build_function_type_list (void_type_node, ptr_type_node, NULL_TREE);
9982 local_define_builtin ("__builtin_setjmp_receiver", ftype,
9983 BUILT_IN_SETJMP_RECEIVER,
9984 "__builtin_setjmp_receiver", ECF_NOTHROW | ECF_LEAF);
9985
9986 ftype = build_function_type_list (ptr_type_node, NULL_TREE);
9987 local_define_builtin ("__builtin_stack_save", ftype, BUILT_IN_STACK_SAVE,
9988 "__builtin_stack_save", ECF_NOTHROW | ECF_LEAF);
9989
9990 ftype = build_function_type_list (void_type_node, ptr_type_node, NULL_TREE);
9991 local_define_builtin ("__builtin_stack_restore", ftype,
9992 BUILT_IN_STACK_RESTORE,
9993 "__builtin_stack_restore", ECF_NOTHROW | ECF_LEAF);
9994
9995 /* If there's a possibility that we might use the ARM EABI, build the
9996 alternate __cxa_end_cleanup node used to resume from C++ and Java. */
9997 if (targetm.arm_eabi_unwinder)
9998 {
9999 ftype = build_function_type_list (void_type_node, NULL_TREE);
10000 local_define_builtin ("__builtin_cxa_end_cleanup", ftype,
10001 BUILT_IN_CXA_END_CLEANUP,
10002 "__cxa_end_cleanup", ECF_NORETURN | ECF_LEAF);
10003 }
10004
10005 ftype = build_function_type_list (void_type_node, ptr_type_node, NULL_TREE);
10006 local_define_builtin ("__builtin_unwind_resume", ftype,
10007 BUILT_IN_UNWIND_RESUME,
10008 ((targetm_common.except_unwind_info (&global_options)
10009 == UI_SJLJ)
10010 ? "_Unwind_SjLj_Resume" : "_Unwind_Resume"),
10011 ECF_NORETURN);
10012
10013 if (builtin_decl_explicit (BUILT_IN_RETURN_ADDRESS) == NULL_TREE)
10014 {
10015 ftype = build_function_type_list (ptr_type_node, integer_type_node,
10016 NULL_TREE);
10017 local_define_builtin ("__builtin_return_address", ftype,
10018 BUILT_IN_RETURN_ADDRESS,
10019 "__builtin_return_address",
10020 ECF_NOTHROW);
10021 }
10022
10023 if (!builtin_decl_explicit_p (BUILT_IN_PROFILE_FUNC_ENTER)
10024 || !builtin_decl_explicit_p (BUILT_IN_PROFILE_FUNC_EXIT))
10025 {
10026 ftype = build_function_type_list (void_type_node, ptr_type_node,
10027 ptr_type_node, NULL_TREE);
10028 if (!builtin_decl_explicit_p (BUILT_IN_PROFILE_FUNC_ENTER))
10029 local_define_builtin ("__cyg_profile_func_enter", ftype,
10030 BUILT_IN_PROFILE_FUNC_ENTER,
10031 "__cyg_profile_func_enter", 0);
10032 if (!builtin_decl_explicit_p (BUILT_IN_PROFILE_FUNC_EXIT))
10033 local_define_builtin ("__cyg_profile_func_exit", ftype,
10034 BUILT_IN_PROFILE_FUNC_EXIT,
10035 "__cyg_profile_func_exit", 0);
10036 }
10037
10038 /* The exception object and filter values from the runtime. The argument
10039 must be zero before exception lowering, i.e. from the front end. After
10040 exception lowering, it will be the region number for the exception
10041 landing pad. These functions are PURE instead of CONST to prevent
10042 them from being hoisted past the exception edge that will initialize
10043 its value in the landing pad. */
10044 ftype = build_function_type_list (ptr_type_node,
10045 integer_type_node, NULL_TREE);
10046 ecf_flags = ECF_PURE | ECF_NOTHROW | ECF_LEAF;
10047 /* Only use TM_PURE if we we have TM language support. */
10048 if (builtin_decl_explicit_p (BUILT_IN_TM_LOAD_1))
10049 ecf_flags |= ECF_TM_PURE;
10050 local_define_builtin ("__builtin_eh_pointer", ftype, BUILT_IN_EH_POINTER,
10051 "__builtin_eh_pointer", ecf_flags);
10052
10053 tmp = lang_hooks.types.type_for_mode (targetm.eh_return_filter_mode (), 0);
10054 ftype = build_function_type_list (tmp, integer_type_node, NULL_TREE);
10055 local_define_builtin ("__builtin_eh_filter", ftype, BUILT_IN_EH_FILTER,
10056 "__builtin_eh_filter", ECF_PURE | ECF_NOTHROW | ECF_LEAF);
10057
10058 ftype = build_function_type_list (void_type_node,
10059 integer_type_node, integer_type_node,
10060 NULL_TREE);
10061 local_define_builtin ("__builtin_eh_copy_values", ftype,
10062 BUILT_IN_EH_COPY_VALUES,
10063 "__builtin_eh_copy_values", ECF_NOTHROW);
10064
10065 /* Complex multiplication and division. These are handled as builtins
10066 rather than optabs because emit_library_call_value doesn't support
10067 complex. Further, we can do slightly better with folding these
10068 beasties if the real and complex parts of the arguments are separate. */
10069 {
10070 int mode;
10071
10072 for (mode = MIN_MODE_COMPLEX_FLOAT; mode <= MAX_MODE_COMPLEX_FLOAT; ++mode)
10073 {
10074 char mode_name_buf[4], *q;
10075 const char *p;
10076 enum built_in_function mcode, dcode;
10077 tree type, inner_type;
10078 const char *prefix = "__";
10079
10080 if (targetm.libfunc_gnu_prefix)
10081 prefix = "__gnu_";
10082
10083 type = lang_hooks.types.type_for_mode ((enum machine_mode) mode, 0);
10084 if (type == NULL)
10085 continue;
10086 inner_type = TREE_TYPE (type);
10087
10088 ftype = build_function_type_list (type, inner_type, inner_type,
10089 inner_type, inner_type, NULL_TREE);
10090
10091 mcode = ((enum built_in_function)
10092 (BUILT_IN_COMPLEX_MUL_MIN + mode - MIN_MODE_COMPLEX_FLOAT));
10093 dcode = ((enum built_in_function)
10094 (BUILT_IN_COMPLEX_DIV_MIN + mode - MIN_MODE_COMPLEX_FLOAT));
10095
10096 for (p = GET_MODE_NAME (mode), q = mode_name_buf; *p; p++, q++)
10097 *q = TOLOWER (*p);
10098 *q = '\0';
10099
10100 built_in_names[mcode] = concat (prefix, "mul", mode_name_buf, "3",
10101 NULL);
10102 local_define_builtin (built_in_names[mcode], ftype, mcode,
10103 built_in_names[mcode],
10104 ECF_CONST | ECF_NOTHROW | ECF_LEAF);
10105
10106 built_in_names[dcode] = concat (prefix, "div", mode_name_buf, "3",
10107 NULL);
10108 local_define_builtin (built_in_names[dcode], ftype, dcode,
10109 built_in_names[dcode],
10110 ECF_CONST | ECF_NOTHROW | ECF_LEAF);
10111 }
10112 }
10113
10114 init_internal_fns ();
10115 }
10116
10117 /* HACK. GROSS. This is absolutely disgusting. I wish there was a
10118 better way.
10119
10120 If we requested a pointer to a vector, build up the pointers that
10121 we stripped off while looking for the inner type. Similarly for
10122 return values from functions.
10123
10124 The argument TYPE is the top of the chain, and BOTTOM is the
10125 new type which we will point to. */
10126
10127 tree
reconstruct_complex_type(tree type,tree bottom)10128 reconstruct_complex_type (tree type, tree bottom)
10129 {
10130 tree inner, outer;
10131
10132 if (TREE_CODE (type) == POINTER_TYPE)
10133 {
10134 inner = reconstruct_complex_type (TREE_TYPE (type), bottom);
10135 outer = build_pointer_type_for_mode (inner, TYPE_MODE (type),
10136 TYPE_REF_CAN_ALIAS_ALL (type));
10137 }
10138 else if (TREE_CODE (type) == REFERENCE_TYPE)
10139 {
10140 inner = reconstruct_complex_type (TREE_TYPE (type), bottom);
10141 outer = build_reference_type_for_mode (inner, TYPE_MODE (type),
10142 TYPE_REF_CAN_ALIAS_ALL (type));
10143 }
10144 else if (TREE_CODE (type) == ARRAY_TYPE)
10145 {
10146 inner = reconstruct_complex_type (TREE_TYPE (type), bottom);
10147 outer = build_array_type (inner, TYPE_DOMAIN (type));
10148 }
10149 else if (TREE_CODE (type) == FUNCTION_TYPE)
10150 {
10151 inner = reconstruct_complex_type (TREE_TYPE (type), bottom);
10152 outer = build_function_type (inner, TYPE_ARG_TYPES (type));
10153 }
10154 else if (TREE_CODE (type) == METHOD_TYPE)
10155 {
10156 inner = reconstruct_complex_type (TREE_TYPE (type), bottom);
10157 /* The build_method_type_directly() routine prepends 'this' to argument list,
10158 so we must compensate by getting rid of it. */
10159 outer
10160 = build_method_type_directly
10161 (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (type))),
10162 inner,
10163 TREE_CHAIN (TYPE_ARG_TYPES (type)));
10164 }
10165 else if (TREE_CODE (type) == OFFSET_TYPE)
10166 {
10167 inner = reconstruct_complex_type (TREE_TYPE (type), bottom);
10168 outer = build_offset_type (TYPE_OFFSET_BASETYPE (type), inner);
10169 }
10170 else
10171 return bottom;
10172
10173 return build_type_attribute_qual_variant (outer, TYPE_ATTRIBUTES (type),
10174 TYPE_QUALS (type));
10175 }
10176
10177 /* Returns a vector tree node given a mode (integer, vector, or BLKmode) and
10178 the inner type. */
10179 tree
build_vector_type_for_mode(tree innertype,enum machine_mode mode)10180 build_vector_type_for_mode (tree innertype, enum machine_mode mode)
10181 {
10182 int nunits;
10183
10184 switch (GET_MODE_CLASS (mode))
10185 {
10186 case MODE_VECTOR_INT:
10187 case MODE_VECTOR_FLOAT:
10188 case MODE_VECTOR_FRACT:
10189 case MODE_VECTOR_UFRACT:
10190 case MODE_VECTOR_ACCUM:
10191 case MODE_VECTOR_UACCUM:
10192 nunits = GET_MODE_NUNITS (mode);
10193 break;
10194
10195 case MODE_INT:
10196 /* Check that there are no leftover bits. */
10197 gcc_assert (GET_MODE_BITSIZE (mode)
10198 % TREE_INT_CST_LOW (TYPE_SIZE (innertype)) == 0);
10199
10200 nunits = GET_MODE_BITSIZE (mode)
10201 / TREE_INT_CST_LOW (TYPE_SIZE (innertype));
10202 break;
10203
10204 default:
10205 gcc_unreachable ();
10206 }
10207
10208 return make_vector_type (innertype, nunits, mode);
10209 }
10210
10211 /* Similarly, but takes the inner type and number of units, which must be
10212 a power of two. */
10213
10214 tree
build_vector_type(tree innertype,int nunits)10215 build_vector_type (tree innertype, int nunits)
10216 {
10217 return make_vector_type (innertype, nunits, VOIDmode);
10218 }
10219
10220 /* Similarly, but builds a variant type with TYPE_VECTOR_OPAQUE set. */
10221
10222 tree
build_opaque_vector_type(tree innertype,int nunits)10223 build_opaque_vector_type (tree innertype, int nunits)
10224 {
10225 tree t = make_vector_type (innertype, nunits, VOIDmode);
10226 tree cand;
10227 /* We always build the non-opaque variant before the opaque one,
10228 so if it already exists, it is TYPE_NEXT_VARIANT of this one. */
10229 cand = TYPE_NEXT_VARIANT (t);
10230 if (cand
10231 && TYPE_VECTOR_OPAQUE (cand)
10232 && check_qualified_type (cand, t, TYPE_QUALS (t)))
10233 return cand;
10234 /* Othewise build a variant type and make sure to queue it after
10235 the non-opaque type. */
10236 cand = build_distinct_type_copy (t);
10237 TYPE_VECTOR_OPAQUE (cand) = true;
10238 TYPE_CANONICAL (cand) = TYPE_CANONICAL (t);
10239 TYPE_NEXT_VARIANT (cand) = TYPE_NEXT_VARIANT (t);
10240 TYPE_NEXT_VARIANT (t) = cand;
10241 TYPE_MAIN_VARIANT (cand) = TYPE_MAIN_VARIANT (t);
10242 return cand;
10243 }
10244
10245
10246 /* Given an initializer INIT, return TRUE if INIT is zero or some
10247 aggregate of zeros. Otherwise return FALSE. */
10248 bool
initializer_zerop(const_tree init)10249 initializer_zerop (const_tree init)
10250 {
10251 tree elt;
10252
10253 STRIP_NOPS (init);
10254
10255 switch (TREE_CODE (init))
10256 {
10257 case INTEGER_CST:
10258 return integer_zerop (init);
10259
10260 case REAL_CST:
10261 /* ??? Note that this is not correct for C4X float formats. There,
10262 a bit pattern of all zeros is 1.0; 0.0 is encoded with the most
10263 negative exponent. */
10264 return real_zerop (init)
10265 && ! REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (init));
10266
10267 case FIXED_CST:
10268 return fixed_zerop (init);
10269
10270 case COMPLEX_CST:
10271 return integer_zerop (init)
10272 || (real_zerop (init)
10273 && ! REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (TREE_REALPART (init)))
10274 && ! REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (TREE_IMAGPART (init))));
10275
10276 case VECTOR_CST:
10277 {
10278 unsigned i;
10279 for (i = 0; i < VECTOR_CST_NELTS (init); ++i)
10280 if (!initializer_zerop (VECTOR_CST_ELT (init, i)))
10281 return false;
10282 return true;
10283 }
10284
10285 case CONSTRUCTOR:
10286 {
10287 unsigned HOST_WIDE_INT idx;
10288
10289 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (init), idx, elt)
10290 if (!initializer_zerop (elt))
10291 return false;
10292 return true;
10293 }
10294
10295 case STRING_CST:
10296 {
10297 int i;
10298
10299 /* We need to loop through all elements to handle cases like
10300 "\0" and "\0foobar". */
10301 for (i = 0; i < TREE_STRING_LENGTH (init); ++i)
10302 if (TREE_STRING_POINTER (init)[i] != '\0')
10303 return false;
10304
10305 return true;
10306 }
10307
10308 default:
10309 return false;
10310 }
10311 }
10312
10313 /* Check if vector VEC consists of all the equal elements and
10314 that the number of elements corresponds to the type of VEC.
10315 The function returns first element of the vector
10316 or NULL_TREE if the vector is not uniform. */
10317 tree
uniform_vector_p(const_tree vec)10318 uniform_vector_p (const_tree vec)
10319 {
10320 tree first, t;
10321 unsigned i;
10322
10323 if (vec == NULL_TREE)
10324 return NULL_TREE;
10325
10326 gcc_assert (VECTOR_TYPE_P (TREE_TYPE (vec)));
10327
10328 if (TREE_CODE (vec) == VECTOR_CST)
10329 {
10330 first = VECTOR_CST_ELT (vec, 0);
10331 for (i = 1; i < VECTOR_CST_NELTS (vec); ++i)
10332 if (!operand_equal_p (first, VECTOR_CST_ELT (vec, i), 0))
10333 return NULL_TREE;
10334
10335 return first;
10336 }
10337
10338 else if (TREE_CODE (vec) == CONSTRUCTOR)
10339 {
10340 first = error_mark_node;
10341
10342 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (vec), i, t)
10343 {
10344 if (i == 0)
10345 {
10346 first = t;
10347 continue;
10348 }
10349 if (!operand_equal_p (first, t, 0))
10350 return NULL_TREE;
10351 }
10352 if (i != TYPE_VECTOR_SUBPARTS (TREE_TYPE (vec)))
10353 return NULL_TREE;
10354
10355 return first;
10356 }
10357
10358 return NULL_TREE;
10359 }
10360
10361 /* Build an empty statement at location LOC. */
10362
10363 tree
build_empty_stmt(location_t loc)10364 build_empty_stmt (location_t loc)
10365 {
10366 tree t = build1 (NOP_EXPR, void_type_node, size_zero_node);
10367 SET_EXPR_LOCATION (t, loc);
10368 return t;
10369 }
10370
10371
10372 /* Build an OpenMP clause with code CODE. LOC is the location of the
10373 clause. */
10374
10375 tree
build_omp_clause(location_t loc,enum omp_clause_code code)10376 build_omp_clause (location_t loc, enum omp_clause_code code)
10377 {
10378 tree t;
10379 int size, length;
10380
10381 length = omp_clause_num_ops[code];
10382 size = (sizeof (struct tree_omp_clause) + (length - 1) * sizeof (tree));
10383
10384 record_node_allocation_statistics (OMP_CLAUSE, size);
10385
10386 t = ggc_alloc_tree_node (size);
10387 memset (t, 0, size);
10388 TREE_SET_CODE (t, OMP_CLAUSE);
10389 OMP_CLAUSE_SET_CODE (t, code);
10390 OMP_CLAUSE_LOCATION (t) = loc;
10391
10392 return t;
10393 }
10394
10395 /* Build a tcc_vl_exp object with code CODE and room for LEN operands. LEN
10396 includes the implicit operand count in TREE_OPERAND 0, and so must be >= 1.
10397 Except for the CODE and operand count field, other storage for the
10398 object is initialized to zeros. */
10399
10400 tree
build_vl_exp_stat(enum tree_code code,int len MEM_STAT_DECL)10401 build_vl_exp_stat (enum tree_code code, int len MEM_STAT_DECL)
10402 {
10403 tree t;
10404 int length = (len - 1) * sizeof (tree) + sizeof (struct tree_exp);
10405
10406 gcc_assert (TREE_CODE_CLASS (code) == tcc_vl_exp);
10407 gcc_assert (len >= 1);
10408
10409 record_node_allocation_statistics (code, length);
10410
10411 t = ggc_alloc_cleared_tree_node_stat (length PASS_MEM_STAT);
10412
10413 TREE_SET_CODE (t, code);
10414
10415 /* Can't use TREE_OPERAND to store the length because if checking is
10416 enabled, it will try to check the length before we store it. :-P */
10417 t->exp.operands[0] = build_int_cst (sizetype, len);
10418
10419 return t;
10420 }
10421
10422 /* Helper function for build_call_* functions; build a CALL_EXPR with
10423 indicated RETURN_TYPE, FN, and NARGS, but do not initialize any of
10424 the argument slots. */
10425
10426 static tree
build_call_1(tree return_type,tree fn,int nargs)10427 build_call_1 (tree return_type, tree fn, int nargs)
10428 {
10429 tree t;
10430
10431 t = build_vl_exp (CALL_EXPR, nargs + 3);
10432 TREE_TYPE (t) = return_type;
10433 CALL_EXPR_FN (t) = fn;
10434 CALL_EXPR_STATIC_CHAIN (t) = NULL;
10435
10436 return t;
10437 }
10438
10439 /* Build a CALL_EXPR of class tcc_vl_exp with the indicated RETURN_TYPE and
10440 FN and a null static chain slot. NARGS is the number of call arguments
10441 which are specified as "..." arguments. */
10442
10443 tree
build_call_nary(tree return_type,tree fn,int nargs,...)10444 build_call_nary (tree return_type, tree fn, int nargs, ...)
10445 {
10446 tree ret;
10447 va_list args;
10448 va_start (args, nargs);
10449 ret = build_call_valist (return_type, fn, nargs, args);
10450 va_end (args);
10451 return ret;
10452 }
10453
10454 /* Build a CALL_EXPR of class tcc_vl_exp with the indicated RETURN_TYPE and
10455 FN and a null static chain slot. NARGS is the number of call arguments
10456 which are specified as a va_list ARGS. */
10457
10458 tree
build_call_valist(tree return_type,tree fn,int nargs,va_list args)10459 build_call_valist (tree return_type, tree fn, int nargs, va_list args)
10460 {
10461 tree t;
10462 int i;
10463
10464 t = build_call_1 (return_type, fn, nargs);
10465 for (i = 0; i < nargs; i++)
10466 CALL_EXPR_ARG (t, i) = va_arg (args, tree);
10467 process_call_operands (t);
10468 return t;
10469 }
10470
10471 /* Build a CALL_EXPR of class tcc_vl_exp with the indicated RETURN_TYPE and
10472 FN and a null static chain slot. NARGS is the number of call arguments
10473 which are specified as a tree array ARGS. */
10474
10475 tree
build_call_array_loc(location_t loc,tree return_type,tree fn,int nargs,const tree * args)10476 build_call_array_loc (location_t loc, tree return_type, tree fn,
10477 int nargs, const tree *args)
10478 {
10479 tree t;
10480 int i;
10481
10482 t = build_call_1 (return_type, fn, nargs);
10483 for (i = 0; i < nargs; i++)
10484 CALL_EXPR_ARG (t, i) = args[i];
10485 process_call_operands (t);
10486 SET_EXPR_LOCATION (t, loc);
10487 return t;
10488 }
10489
10490 /* Like build_call_array, but takes a vec. */
10491
10492 tree
build_call_vec(tree return_type,tree fn,vec<tree,va_gc> * args)10493 build_call_vec (tree return_type, tree fn, vec<tree, va_gc> *args)
10494 {
10495 tree ret, t;
10496 unsigned int ix;
10497
10498 ret = build_call_1 (return_type, fn, vec_safe_length (args));
10499 FOR_EACH_VEC_SAFE_ELT (args, ix, t)
10500 CALL_EXPR_ARG (ret, ix) = t;
10501 process_call_operands (ret);
10502 return ret;
10503 }
10504
10505 /* Return true if T (assumed to be a DECL) must be assigned a memory
10506 location. */
10507
10508 bool
needs_to_live_in_memory(const_tree t)10509 needs_to_live_in_memory (const_tree t)
10510 {
10511 return (TREE_ADDRESSABLE (t)
10512 || is_global_var (t)
10513 || (TREE_CODE (t) == RESULT_DECL
10514 && !DECL_BY_REFERENCE (t)
10515 && aggregate_value_p (t, current_function_decl)));
10516 }
10517
10518 /* Return value of a constant X and sign-extend it. */
10519
10520 HOST_WIDE_INT
int_cst_value(const_tree x)10521 int_cst_value (const_tree x)
10522 {
10523 unsigned bits = TYPE_PRECISION (TREE_TYPE (x));
10524 unsigned HOST_WIDE_INT val = TREE_INT_CST_LOW (x);
10525
10526 /* Make sure the sign-extended value will fit in a HOST_WIDE_INT. */
10527 gcc_assert (TREE_INT_CST_HIGH (x) == 0
10528 || TREE_INT_CST_HIGH (x) == -1);
10529
10530 if (bits < HOST_BITS_PER_WIDE_INT)
10531 {
10532 bool negative = ((val >> (bits - 1)) & 1) != 0;
10533 if (negative)
10534 val |= (~(unsigned HOST_WIDE_INT) 0) << (bits - 1) << 1;
10535 else
10536 val &= ~((~(unsigned HOST_WIDE_INT) 0) << (bits - 1) << 1);
10537 }
10538
10539 return val;
10540 }
10541
10542 /* Return value of a constant X and sign-extend it. */
10543
10544 HOST_WIDEST_INT
widest_int_cst_value(const_tree x)10545 widest_int_cst_value (const_tree x)
10546 {
10547 unsigned bits = TYPE_PRECISION (TREE_TYPE (x));
10548 unsigned HOST_WIDEST_INT val = TREE_INT_CST_LOW (x);
10549
10550 #if HOST_BITS_PER_WIDEST_INT > HOST_BITS_PER_WIDE_INT
10551 gcc_assert (HOST_BITS_PER_WIDEST_INT >= HOST_BITS_PER_DOUBLE_INT);
10552 val |= (((unsigned HOST_WIDEST_INT) TREE_INT_CST_HIGH (x))
10553 << HOST_BITS_PER_WIDE_INT);
10554 #else
10555 /* Make sure the sign-extended value will fit in a HOST_WIDE_INT. */
10556 gcc_assert (TREE_INT_CST_HIGH (x) == 0
10557 || TREE_INT_CST_HIGH (x) == -1);
10558 #endif
10559
10560 if (bits < HOST_BITS_PER_WIDEST_INT)
10561 {
10562 bool negative = ((val >> (bits - 1)) & 1) != 0;
10563 if (negative)
10564 val |= (~(unsigned HOST_WIDEST_INT) 0) << (bits - 1) << 1;
10565 else
10566 val &= ~((~(unsigned HOST_WIDEST_INT) 0) << (bits - 1) << 1);
10567 }
10568
10569 return val;
10570 }
10571
10572 /* If TYPE is an integral or pointer type, return an integer type with
10573 the same precision which is unsigned iff UNSIGNEDP is true, or itself
10574 if TYPE is already an integer type of signedness UNSIGNEDP. */
10575
10576 tree
signed_or_unsigned_type_for(int unsignedp,tree type)10577 signed_or_unsigned_type_for (int unsignedp, tree type)
10578 {
10579 if (TREE_CODE (type) == INTEGER_TYPE && TYPE_UNSIGNED (type) == unsignedp)
10580 return type;
10581
10582 if (TREE_CODE (type) == VECTOR_TYPE)
10583 {
10584 tree inner = TREE_TYPE (type);
10585 tree inner2 = signed_or_unsigned_type_for (unsignedp, inner);
10586 if (!inner2)
10587 return NULL_TREE;
10588 if (inner == inner2)
10589 return type;
10590 return build_vector_type (inner2, TYPE_VECTOR_SUBPARTS (type));
10591 }
10592
10593 if (!INTEGRAL_TYPE_P (type)
10594 && !POINTER_TYPE_P (type)
10595 && TREE_CODE (type) != OFFSET_TYPE)
10596 return NULL_TREE;
10597
10598 return build_nonstandard_integer_type (TYPE_PRECISION (type), unsignedp);
10599 }
10600
10601 /* If TYPE is an integral or pointer type, return an integer type with
10602 the same precision which is unsigned, or itself if TYPE is already an
10603 unsigned integer type. */
10604
10605 tree
unsigned_type_for(tree type)10606 unsigned_type_for (tree type)
10607 {
10608 return signed_or_unsigned_type_for (1, type);
10609 }
10610
10611 /* If TYPE is an integral or pointer type, return an integer type with
10612 the same precision which is signed, or itself if TYPE is already a
10613 signed integer type. */
10614
10615 tree
signed_type_for(tree type)10616 signed_type_for (tree type)
10617 {
10618 return signed_or_unsigned_type_for (0, type);
10619 }
10620
10621 /* If TYPE is a vector type, return a signed integer vector type with the
10622 same width and number of subparts. Otherwise return boolean_type_node. */
10623
10624 tree
truth_type_for(tree type)10625 truth_type_for (tree type)
10626 {
10627 if (TREE_CODE (type) == VECTOR_TYPE)
10628 {
10629 tree elem = lang_hooks.types.type_for_size
10630 (GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (type))), 0);
10631 return build_opaque_vector_type (elem, TYPE_VECTOR_SUBPARTS (type));
10632 }
10633 else
10634 return boolean_type_node;
10635 }
10636
10637 /* Returns the largest value obtainable by casting something in INNER type to
10638 OUTER type. */
10639
10640 tree
upper_bound_in_type(tree outer,tree inner)10641 upper_bound_in_type (tree outer, tree inner)
10642 {
10643 double_int high;
10644 unsigned int det = 0;
10645 unsigned oprec = TYPE_PRECISION (outer);
10646 unsigned iprec = TYPE_PRECISION (inner);
10647 unsigned prec;
10648
10649 /* Compute a unique number for every combination. */
10650 det |= (oprec > iprec) ? 4 : 0;
10651 det |= TYPE_UNSIGNED (outer) ? 2 : 0;
10652 det |= TYPE_UNSIGNED (inner) ? 1 : 0;
10653
10654 /* Determine the exponent to use. */
10655 switch (det)
10656 {
10657 case 0:
10658 case 1:
10659 /* oprec <= iprec, outer: signed, inner: don't care. */
10660 prec = oprec - 1;
10661 break;
10662 case 2:
10663 case 3:
10664 /* oprec <= iprec, outer: unsigned, inner: don't care. */
10665 prec = oprec;
10666 break;
10667 case 4:
10668 /* oprec > iprec, outer: signed, inner: signed. */
10669 prec = iprec - 1;
10670 break;
10671 case 5:
10672 /* oprec > iprec, outer: signed, inner: unsigned. */
10673 prec = iprec;
10674 break;
10675 case 6:
10676 /* oprec > iprec, outer: unsigned, inner: signed. */
10677 prec = oprec;
10678 break;
10679 case 7:
10680 /* oprec > iprec, outer: unsigned, inner: unsigned. */
10681 prec = iprec;
10682 break;
10683 default:
10684 gcc_unreachable ();
10685 }
10686
10687 /* Compute 2^^prec - 1. */
10688 if (prec <= HOST_BITS_PER_WIDE_INT)
10689 {
10690 high.high = 0;
10691 high.low = ((~(unsigned HOST_WIDE_INT) 0)
10692 >> (HOST_BITS_PER_WIDE_INT - prec));
10693 }
10694 else
10695 {
10696 high.high = ((~(unsigned HOST_WIDE_INT) 0)
10697 >> (HOST_BITS_PER_DOUBLE_INT - prec));
10698 high.low = ~(unsigned HOST_WIDE_INT) 0;
10699 }
10700
10701 return double_int_to_tree (outer, high);
10702 }
10703
10704 /* Returns the smallest value obtainable by casting something in INNER type to
10705 OUTER type. */
10706
10707 tree
lower_bound_in_type(tree outer,tree inner)10708 lower_bound_in_type (tree outer, tree inner)
10709 {
10710 double_int low;
10711 unsigned oprec = TYPE_PRECISION (outer);
10712 unsigned iprec = TYPE_PRECISION (inner);
10713
10714 /* If OUTER type is unsigned, we can definitely cast 0 to OUTER type
10715 and obtain 0. */
10716 if (TYPE_UNSIGNED (outer)
10717 /* If we are widening something of an unsigned type, OUTER type
10718 contains all values of INNER type. In particular, both INNER
10719 and OUTER types have zero in common. */
10720 || (oprec > iprec && TYPE_UNSIGNED (inner)))
10721 low.low = low.high = 0;
10722 else
10723 {
10724 /* If we are widening a signed type to another signed type, we
10725 want to obtain -2^^(iprec-1). If we are keeping the
10726 precision or narrowing to a signed type, we want to obtain
10727 -2^(oprec-1). */
10728 unsigned prec = oprec > iprec ? iprec : oprec;
10729
10730 if (prec <= HOST_BITS_PER_WIDE_INT)
10731 {
10732 low.high = ~(unsigned HOST_WIDE_INT) 0;
10733 low.low = (~(unsigned HOST_WIDE_INT) 0) << (prec - 1);
10734 }
10735 else
10736 {
10737 low.high = ((~(unsigned HOST_WIDE_INT) 0)
10738 << (prec - HOST_BITS_PER_WIDE_INT - 1));
10739 low.low = 0;
10740 }
10741 }
10742
10743 return double_int_to_tree (outer, low);
10744 }
10745
10746 /* Return nonzero if two operands that are suitable for PHI nodes are
10747 necessarily equal. Specifically, both ARG0 and ARG1 must be either
10748 SSA_NAME or invariant. Note that this is strictly an optimization.
10749 That is, callers of this function can directly call operand_equal_p
10750 and get the same result, only slower. */
10751
10752 int
operand_equal_for_phi_arg_p(const_tree arg0,const_tree arg1)10753 operand_equal_for_phi_arg_p (const_tree arg0, const_tree arg1)
10754 {
10755 if (arg0 == arg1)
10756 return 1;
10757 if (TREE_CODE (arg0) == SSA_NAME || TREE_CODE (arg1) == SSA_NAME)
10758 return 0;
10759 return operand_equal_p (arg0, arg1, 0);
10760 }
10761
10762 /* Returns number of zeros at the end of binary representation of X.
10763
10764 ??? Use ffs if available? */
10765
10766 tree
num_ending_zeros(const_tree x)10767 num_ending_zeros (const_tree x)
10768 {
10769 unsigned HOST_WIDE_INT fr, nfr;
10770 unsigned num, abits;
10771 tree type = TREE_TYPE (x);
10772
10773 if (TREE_INT_CST_LOW (x) == 0)
10774 {
10775 num = HOST_BITS_PER_WIDE_INT;
10776 fr = TREE_INT_CST_HIGH (x);
10777 }
10778 else
10779 {
10780 num = 0;
10781 fr = TREE_INT_CST_LOW (x);
10782 }
10783
10784 for (abits = HOST_BITS_PER_WIDE_INT / 2; abits; abits /= 2)
10785 {
10786 nfr = fr >> abits;
10787 if (nfr << abits == fr)
10788 {
10789 num += abits;
10790 fr = nfr;
10791 }
10792 }
10793
10794 if (num > TYPE_PRECISION (type))
10795 num = TYPE_PRECISION (type);
10796
10797 return build_int_cst_type (type, num);
10798 }
10799
10800
10801 #define WALK_SUBTREE(NODE) \
10802 do \
10803 { \
10804 result = walk_tree_1 (&(NODE), func, data, pset, lh); \
10805 if (result) \
10806 return result; \
10807 } \
10808 while (0)
10809
10810 /* This is a subroutine of walk_tree that walks field of TYPE that are to
10811 be walked whenever a type is seen in the tree. Rest of operands and return
10812 value are as for walk_tree. */
10813
10814 static tree
walk_type_fields(tree type,walk_tree_fn func,void * data,struct pointer_set_t * pset,walk_tree_lh lh)10815 walk_type_fields (tree type, walk_tree_fn func, void *data,
10816 struct pointer_set_t *pset, walk_tree_lh lh)
10817 {
10818 tree result = NULL_TREE;
10819
10820 switch (TREE_CODE (type))
10821 {
10822 case POINTER_TYPE:
10823 case REFERENCE_TYPE:
10824 case VECTOR_TYPE:
10825 /* We have to worry about mutually recursive pointers. These can't
10826 be written in C. They can in Ada. It's pathological, but
10827 there's an ACATS test (c38102a) that checks it. Deal with this
10828 by checking if we're pointing to another pointer, that one
10829 points to another pointer, that one does too, and we have no htab.
10830 If so, get a hash table. We check three levels deep to avoid
10831 the cost of the hash table if we don't need one. */
10832 if (POINTER_TYPE_P (TREE_TYPE (type))
10833 && POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (type)))
10834 && POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (TREE_TYPE (type))))
10835 && !pset)
10836 {
10837 result = walk_tree_without_duplicates (&TREE_TYPE (type),
10838 func, data);
10839 if (result)
10840 return result;
10841
10842 break;
10843 }
10844
10845 /* ... fall through ... */
10846
10847 case COMPLEX_TYPE:
10848 WALK_SUBTREE (TREE_TYPE (type));
10849 break;
10850
10851 case METHOD_TYPE:
10852 WALK_SUBTREE (TYPE_METHOD_BASETYPE (type));
10853
10854 /* Fall through. */
10855
10856 case FUNCTION_TYPE:
10857 WALK_SUBTREE (TREE_TYPE (type));
10858 {
10859 tree arg;
10860
10861 /* We never want to walk into default arguments. */
10862 for (arg = TYPE_ARG_TYPES (type); arg; arg = TREE_CHAIN (arg))
10863 WALK_SUBTREE (TREE_VALUE (arg));
10864 }
10865 break;
10866
10867 case ARRAY_TYPE:
10868 /* Don't follow this nodes's type if a pointer for fear that
10869 we'll have infinite recursion. If we have a PSET, then we
10870 need not fear. */
10871 if (pset
10872 || (!POINTER_TYPE_P (TREE_TYPE (type))
10873 && TREE_CODE (TREE_TYPE (type)) != OFFSET_TYPE))
10874 WALK_SUBTREE (TREE_TYPE (type));
10875 WALK_SUBTREE (TYPE_DOMAIN (type));
10876 break;
10877
10878 case OFFSET_TYPE:
10879 WALK_SUBTREE (TREE_TYPE (type));
10880 WALK_SUBTREE (TYPE_OFFSET_BASETYPE (type));
10881 break;
10882
10883 default:
10884 break;
10885 }
10886
10887 return NULL_TREE;
10888 }
10889
10890 /* Apply FUNC to all the sub-trees of TP in a pre-order traversal. FUNC is
10891 called with the DATA and the address of each sub-tree. If FUNC returns a
10892 non-NULL value, the traversal is stopped, and the value returned by FUNC
10893 is returned. If PSET is non-NULL it is used to record the nodes visited,
10894 and to avoid visiting a node more than once. */
10895
10896 tree
walk_tree_1(tree * tp,walk_tree_fn func,void * data,struct pointer_set_t * pset,walk_tree_lh lh)10897 walk_tree_1 (tree *tp, walk_tree_fn func, void *data,
10898 struct pointer_set_t *pset, walk_tree_lh lh)
10899 {
10900 enum tree_code code;
10901 int walk_subtrees;
10902 tree result;
10903
10904 #define WALK_SUBTREE_TAIL(NODE) \
10905 do \
10906 { \
10907 tp = & (NODE); \
10908 goto tail_recurse; \
10909 } \
10910 while (0)
10911
10912 tail_recurse:
10913 /* Skip empty subtrees. */
10914 if (!*tp)
10915 return NULL_TREE;
10916
10917 /* Don't walk the same tree twice, if the user has requested
10918 that we avoid doing so. */
10919 if (pset && pointer_set_insert (pset, *tp))
10920 return NULL_TREE;
10921
10922 /* Call the function. */
10923 walk_subtrees = 1;
10924 result = (*func) (tp, &walk_subtrees, data);
10925
10926 /* If we found something, return it. */
10927 if (result)
10928 return result;
10929
10930 code = TREE_CODE (*tp);
10931
10932 /* Even if we didn't, FUNC may have decided that there was nothing
10933 interesting below this point in the tree. */
10934 if (!walk_subtrees)
10935 {
10936 /* But we still need to check our siblings. */
10937 if (code == TREE_LIST)
10938 WALK_SUBTREE_TAIL (TREE_CHAIN (*tp));
10939 else if (code == OMP_CLAUSE)
10940 WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp));
10941 else
10942 return NULL_TREE;
10943 }
10944
10945 if (lh)
10946 {
10947 result = (*lh) (tp, &walk_subtrees, func, data, pset);
10948 if (result || !walk_subtrees)
10949 return result;
10950 }
10951
10952 switch (code)
10953 {
10954 case ERROR_MARK:
10955 case IDENTIFIER_NODE:
10956 case INTEGER_CST:
10957 case REAL_CST:
10958 case FIXED_CST:
10959 case VECTOR_CST:
10960 case STRING_CST:
10961 case BLOCK:
10962 case PLACEHOLDER_EXPR:
10963 case SSA_NAME:
10964 case FIELD_DECL:
10965 case RESULT_DECL:
10966 /* None of these have subtrees other than those already walked
10967 above. */
10968 break;
10969
10970 case TREE_LIST:
10971 WALK_SUBTREE (TREE_VALUE (*tp));
10972 WALK_SUBTREE_TAIL (TREE_CHAIN (*tp));
10973 break;
10974
10975 case TREE_VEC:
10976 {
10977 int len = TREE_VEC_LENGTH (*tp);
10978
10979 if (len == 0)
10980 break;
10981
10982 /* Walk all elements but the first. */
10983 while (--len)
10984 WALK_SUBTREE (TREE_VEC_ELT (*tp, len));
10985
10986 /* Now walk the first one as a tail call. */
10987 WALK_SUBTREE_TAIL (TREE_VEC_ELT (*tp, 0));
10988 }
10989
10990 case COMPLEX_CST:
10991 WALK_SUBTREE (TREE_REALPART (*tp));
10992 WALK_SUBTREE_TAIL (TREE_IMAGPART (*tp));
10993
10994 case CONSTRUCTOR:
10995 {
10996 unsigned HOST_WIDE_INT idx;
10997 constructor_elt *ce;
10998
10999 for (idx = 0; vec_safe_iterate (CONSTRUCTOR_ELTS (*tp), idx, &ce);
11000 idx++)
11001 WALK_SUBTREE (ce->value);
11002 }
11003 break;
11004
11005 case SAVE_EXPR:
11006 WALK_SUBTREE_TAIL (TREE_OPERAND (*tp, 0));
11007
11008 case BIND_EXPR:
11009 {
11010 tree decl;
11011 for (decl = BIND_EXPR_VARS (*tp); decl; decl = DECL_CHAIN (decl))
11012 {
11013 /* Walk the DECL_INITIAL and DECL_SIZE. We don't want to walk
11014 into declarations that are just mentioned, rather than
11015 declared; they don't really belong to this part of the tree.
11016 And, we can see cycles: the initializer for a declaration
11017 can refer to the declaration itself. */
11018 WALK_SUBTREE (DECL_INITIAL (decl));
11019 WALK_SUBTREE (DECL_SIZE (decl));
11020 WALK_SUBTREE (DECL_SIZE_UNIT (decl));
11021 }
11022 WALK_SUBTREE_TAIL (BIND_EXPR_BODY (*tp));
11023 }
11024
11025 case STATEMENT_LIST:
11026 {
11027 tree_stmt_iterator i;
11028 for (i = tsi_start (*tp); !tsi_end_p (i); tsi_next (&i))
11029 WALK_SUBTREE (*tsi_stmt_ptr (i));
11030 }
11031 break;
11032
11033 case OMP_CLAUSE:
11034 switch (OMP_CLAUSE_CODE (*tp))
11035 {
11036 case OMP_CLAUSE_PRIVATE:
11037 case OMP_CLAUSE_SHARED:
11038 case OMP_CLAUSE_FIRSTPRIVATE:
11039 case OMP_CLAUSE_COPYIN:
11040 case OMP_CLAUSE_COPYPRIVATE:
11041 case OMP_CLAUSE_FINAL:
11042 case OMP_CLAUSE_IF:
11043 case OMP_CLAUSE_NUM_THREADS:
11044 case OMP_CLAUSE_SCHEDULE:
11045 case OMP_CLAUSE_UNIFORM:
11046 case OMP_CLAUSE_DEPEND:
11047 case OMP_CLAUSE_NUM_TEAMS:
11048 case OMP_CLAUSE_THREAD_LIMIT:
11049 case OMP_CLAUSE_DEVICE:
11050 case OMP_CLAUSE_DIST_SCHEDULE:
11051 case OMP_CLAUSE_SAFELEN:
11052 case OMP_CLAUSE_SIMDLEN:
11053 case OMP_CLAUSE__LOOPTEMP_:
11054 case OMP_CLAUSE__SIMDUID_:
11055 WALK_SUBTREE (OMP_CLAUSE_OPERAND (*tp, 0));
11056 /* FALLTHRU */
11057
11058 case OMP_CLAUSE_NOWAIT:
11059 case OMP_CLAUSE_ORDERED:
11060 case OMP_CLAUSE_DEFAULT:
11061 case OMP_CLAUSE_UNTIED:
11062 case OMP_CLAUSE_MERGEABLE:
11063 case OMP_CLAUSE_PROC_BIND:
11064 case OMP_CLAUSE_INBRANCH:
11065 case OMP_CLAUSE_NOTINBRANCH:
11066 case OMP_CLAUSE_FOR:
11067 case OMP_CLAUSE_PARALLEL:
11068 case OMP_CLAUSE_SECTIONS:
11069 case OMP_CLAUSE_TASKGROUP:
11070 WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp));
11071
11072 case OMP_CLAUSE_LASTPRIVATE:
11073 WALK_SUBTREE (OMP_CLAUSE_DECL (*tp));
11074 WALK_SUBTREE (OMP_CLAUSE_LASTPRIVATE_STMT (*tp));
11075 WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp));
11076
11077 case OMP_CLAUSE_COLLAPSE:
11078 {
11079 int i;
11080 for (i = 0; i < 3; i++)
11081 WALK_SUBTREE (OMP_CLAUSE_OPERAND (*tp, i));
11082 WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp));
11083 }
11084
11085 case OMP_CLAUSE_LINEAR:
11086 WALK_SUBTREE (OMP_CLAUSE_DECL (*tp));
11087 WALK_SUBTREE (OMP_CLAUSE_LINEAR_STEP (*tp));
11088 WALK_SUBTREE (OMP_CLAUSE_LINEAR_STMT (*tp));
11089 WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp));
11090
11091 case OMP_CLAUSE_ALIGNED:
11092 case OMP_CLAUSE_FROM:
11093 case OMP_CLAUSE_TO:
11094 case OMP_CLAUSE_MAP:
11095 WALK_SUBTREE (OMP_CLAUSE_DECL (*tp));
11096 WALK_SUBTREE (OMP_CLAUSE_OPERAND (*tp, 1));
11097 WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp));
11098
11099 case OMP_CLAUSE_REDUCTION:
11100 {
11101 int i;
11102 for (i = 0; i < 4; i++)
11103 WALK_SUBTREE (OMP_CLAUSE_OPERAND (*tp, i));
11104 WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp));
11105 }
11106
11107 default:
11108 gcc_unreachable ();
11109 }
11110 break;
11111
11112 case TARGET_EXPR:
11113 {
11114 int i, len;
11115
11116 /* TARGET_EXPRs are peculiar: operands 1 and 3 can be the same.
11117 But, we only want to walk once. */
11118 len = (TREE_OPERAND (*tp, 3) == TREE_OPERAND (*tp, 1)) ? 2 : 3;
11119 for (i = 0; i < len; ++i)
11120 WALK_SUBTREE (TREE_OPERAND (*tp, i));
11121 WALK_SUBTREE_TAIL (TREE_OPERAND (*tp, len));
11122 }
11123
11124 case DECL_EXPR:
11125 /* If this is a TYPE_DECL, walk into the fields of the type that it's
11126 defining. We only want to walk into these fields of a type in this
11127 case and not in the general case of a mere reference to the type.
11128
11129 The criterion is as follows: if the field can be an expression, it
11130 must be walked only here. This should be in keeping with the fields
11131 that are directly gimplified in gimplify_type_sizes in order for the
11132 mark/copy-if-shared/unmark machinery of the gimplifier to work with
11133 variable-sized types.
11134
11135 Note that DECLs get walked as part of processing the BIND_EXPR. */
11136 if (TREE_CODE (DECL_EXPR_DECL (*tp)) == TYPE_DECL)
11137 {
11138 tree *type_p = &TREE_TYPE (DECL_EXPR_DECL (*tp));
11139 if (TREE_CODE (*type_p) == ERROR_MARK)
11140 return NULL_TREE;
11141
11142 /* Call the function for the type. See if it returns anything or
11143 doesn't want us to continue. If we are to continue, walk both
11144 the normal fields and those for the declaration case. */
11145 result = (*func) (type_p, &walk_subtrees, data);
11146 if (result || !walk_subtrees)
11147 return result;
11148
11149 /* But do not walk a pointed-to type since it may itself need to
11150 be walked in the declaration case if it isn't anonymous. */
11151 if (!POINTER_TYPE_P (*type_p))
11152 {
11153 result = walk_type_fields (*type_p, func, data, pset, lh);
11154 if (result)
11155 return result;
11156 }
11157
11158 /* If this is a record type, also walk the fields. */
11159 if (RECORD_OR_UNION_TYPE_P (*type_p))
11160 {
11161 tree field;
11162
11163 for (field = TYPE_FIELDS (*type_p); field;
11164 field = DECL_CHAIN (field))
11165 {
11166 /* We'd like to look at the type of the field, but we can
11167 easily get infinite recursion. So assume it's pointed
11168 to elsewhere in the tree. Also, ignore things that
11169 aren't fields. */
11170 if (TREE_CODE (field) != FIELD_DECL)
11171 continue;
11172
11173 WALK_SUBTREE (DECL_FIELD_OFFSET (field));
11174 WALK_SUBTREE (DECL_SIZE (field));
11175 WALK_SUBTREE (DECL_SIZE_UNIT (field));
11176 if (TREE_CODE (*type_p) == QUAL_UNION_TYPE)
11177 WALK_SUBTREE (DECL_QUALIFIER (field));
11178 }
11179 }
11180
11181 /* Same for scalar types. */
11182 else if (TREE_CODE (*type_p) == BOOLEAN_TYPE
11183 || TREE_CODE (*type_p) == ENUMERAL_TYPE
11184 || TREE_CODE (*type_p) == INTEGER_TYPE
11185 || TREE_CODE (*type_p) == FIXED_POINT_TYPE
11186 || TREE_CODE (*type_p) == REAL_TYPE)
11187 {
11188 WALK_SUBTREE (TYPE_MIN_VALUE (*type_p));
11189 WALK_SUBTREE (TYPE_MAX_VALUE (*type_p));
11190 }
11191
11192 WALK_SUBTREE (TYPE_SIZE (*type_p));
11193 WALK_SUBTREE_TAIL (TYPE_SIZE_UNIT (*type_p));
11194 }
11195 /* FALLTHRU */
11196
11197 default:
11198 if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (code)))
11199 {
11200 int i, len;
11201
11202 /* Walk over all the sub-trees of this operand. */
11203 len = TREE_OPERAND_LENGTH (*tp);
11204
11205 /* Go through the subtrees. We need to do this in forward order so
11206 that the scope of a FOR_EXPR is handled properly. */
11207 if (len)
11208 {
11209 for (i = 0; i < len - 1; ++i)
11210 WALK_SUBTREE (TREE_OPERAND (*tp, i));
11211 WALK_SUBTREE_TAIL (TREE_OPERAND (*tp, len - 1));
11212 }
11213 }
11214 /* If this is a type, walk the needed fields in the type. */
11215 else if (TYPE_P (*tp))
11216 return walk_type_fields (*tp, func, data, pset, lh);
11217 break;
11218 }
11219
11220 /* We didn't find what we were looking for. */
11221 return NULL_TREE;
11222
11223 #undef WALK_SUBTREE_TAIL
11224 }
11225 #undef WALK_SUBTREE
11226
11227 /* Like walk_tree, but does not walk duplicate nodes more than once. */
11228
11229 tree
walk_tree_without_duplicates_1(tree * tp,walk_tree_fn func,void * data,walk_tree_lh lh)11230 walk_tree_without_duplicates_1 (tree *tp, walk_tree_fn func, void *data,
11231 walk_tree_lh lh)
11232 {
11233 tree result;
11234 struct pointer_set_t *pset;
11235
11236 pset = pointer_set_create ();
11237 result = walk_tree_1 (tp, func, data, pset, lh);
11238 pointer_set_destroy (pset);
11239 return result;
11240 }
11241
11242
11243 tree
tree_block(tree t)11244 tree_block (tree t)
11245 {
11246 char const c = TREE_CODE_CLASS (TREE_CODE (t));
11247
11248 if (IS_EXPR_CODE_CLASS (c))
11249 return LOCATION_BLOCK (t->exp.locus);
11250 gcc_unreachable ();
11251 return NULL;
11252 }
11253
11254 void
tree_set_block(tree t,tree b)11255 tree_set_block (tree t, tree b)
11256 {
11257 char const c = TREE_CODE_CLASS (TREE_CODE (t));
11258
11259 if (IS_EXPR_CODE_CLASS (c))
11260 {
11261 if (b)
11262 t->exp.locus = COMBINE_LOCATION_DATA (line_table, t->exp.locus, b);
11263 else
11264 t->exp.locus = LOCATION_LOCUS (t->exp.locus);
11265 }
11266 else
11267 gcc_unreachable ();
11268 }
11269
11270 /* Create a nameless artificial label and put it in the current
11271 function context. The label has a location of LOC. Returns the
11272 newly created label. */
11273
11274 tree
create_artificial_label(location_t loc)11275 create_artificial_label (location_t loc)
11276 {
11277 tree lab = build_decl (loc,
11278 LABEL_DECL, NULL_TREE, void_type_node);
11279
11280 DECL_ARTIFICIAL (lab) = 1;
11281 DECL_IGNORED_P (lab) = 1;
11282 DECL_CONTEXT (lab) = current_function_decl;
11283 return lab;
11284 }
11285
11286 /* Given a tree, try to return a useful variable name that we can use
11287 to prefix a temporary that is being assigned the value of the tree.
11288 I.E. given <temp> = &A, return A. */
11289
11290 const char *
get_name(tree t)11291 get_name (tree t)
11292 {
11293 tree stripped_decl;
11294
11295 stripped_decl = t;
11296 STRIP_NOPS (stripped_decl);
11297 if (DECL_P (stripped_decl) && DECL_NAME (stripped_decl))
11298 return IDENTIFIER_POINTER (DECL_NAME (stripped_decl));
11299 else if (TREE_CODE (stripped_decl) == SSA_NAME)
11300 {
11301 tree name = SSA_NAME_IDENTIFIER (stripped_decl);
11302 if (!name)
11303 return NULL;
11304 return IDENTIFIER_POINTER (name);
11305 }
11306 else
11307 {
11308 switch (TREE_CODE (stripped_decl))
11309 {
11310 case ADDR_EXPR:
11311 return get_name (TREE_OPERAND (stripped_decl, 0));
11312 default:
11313 return NULL;
11314 }
11315 }
11316 }
11317
11318 /* Return true if TYPE has a variable argument list. */
11319
11320 bool
stdarg_p(const_tree fntype)11321 stdarg_p (const_tree fntype)
11322 {
11323 function_args_iterator args_iter;
11324 tree n = NULL_TREE, t;
11325
11326 if (!fntype)
11327 return false;
11328
11329 FOREACH_FUNCTION_ARGS (fntype, t, args_iter)
11330 {
11331 n = t;
11332 }
11333
11334 return n != NULL_TREE && n != void_type_node;
11335 }
11336
11337 /* Return true if TYPE has a prototype. */
11338
11339 bool
prototype_p(tree fntype)11340 prototype_p (tree fntype)
11341 {
11342 tree t;
11343
11344 gcc_assert (fntype != NULL_TREE);
11345
11346 t = TYPE_ARG_TYPES (fntype);
11347 return (t != NULL_TREE);
11348 }
11349
11350 /* If BLOCK is inlined from an __attribute__((__artificial__))
11351 routine, return pointer to location from where it has been
11352 called. */
11353 location_t *
block_nonartificial_location(tree block)11354 block_nonartificial_location (tree block)
11355 {
11356 location_t *ret = NULL;
11357
11358 while (block && TREE_CODE (block) == BLOCK
11359 && BLOCK_ABSTRACT_ORIGIN (block))
11360 {
11361 tree ao = BLOCK_ABSTRACT_ORIGIN (block);
11362
11363 while (TREE_CODE (ao) == BLOCK
11364 && BLOCK_ABSTRACT_ORIGIN (ao)
11365 && BLOCK_ABSTRACT_ORIGIN (ao) != ao)
11366 ao = BLOCK_ABSTRACT_ORIGIN (ao);
11367
11368 if (TREE_CODE (ao) == FUNCTION_DECL)
11369 {
11370 /* If AO is an artificial inline, point RET to the
11371 call site locus at which it has been inlined and continue
11372 the loop, in case AO's caller is also an artificial
11373 inline. */
11374 if (DECL_DECLARED_INLINE_P (ao)
11375 && lookup_attribute ("artificial", DECL_ATTRIBUTES (ao)))
11376 ret = &BLOCK_SOURCE_LOCATION (block);
11377 else
11378 break;
11379 }
11380 else if (TREE_CODE (ao) != BLOCK)
11381 break;
11382
11383 block = BLOCK_SUPERCONTEXT (block);
11384 }
11385 return ret;
11386 }
11387
11388
11389 /* If EXP is inlined from an __attribute__((__artificial__))
11390 function, return the location of the original call expression. */
11391
11392 location_t
tree_nonartificial_location(tree exp)11393 tree_nonartificial_location (tree exp)
11394 {
11395 location_t *loc = block_nonartificial_location (TREE_BLOCK (exp));
11396
11397 if (loc)
11398 return *loc;
11399 else
11400 return EXPR_LOCATION (exp);
11401 }
11402
11403
11404 /* These are the hash table functions for the hash table of OPTIMIZATION_NODEq
11405 nodes. */
11406
11407 /* Return the hash code code X, an OPTIMIZATION_NODE or TARGET_OPTION code. */
11408
11409 static hashval_t
cl_option_hash_hash(const void * x)11410 cl_option_hash_hash (const void *x)
11411 {
11412 const_tree const t = (const_tree) x;
11413 const char *p;
11414 size_t i;
11415 size_t len = 0;
11416 hashval_t hash = 0;
11417
11418 if (TREE_CODE (t) == OPTIMIZATION_NODE)
11419 {
11420 p = (const char *)TREE_OPTIMIZATION (t);
11421 len = sizeof (struct cl_optimization);
11422 }
11423
11424 else if (TREE_CODE (t) == TARGET_OPTION_NODE)
11425 {
11426 p = (const char *)TREE_TARGET_OPTION (t);
11427 len = sizeof (struct cl_target_option);
11428 }
11429
11430 else
11431 gcc_unreachable ();
11432
11433 /* assume most opt flags are just 0/1, some are 2-3, and a few might be
11434 something else. */
11435 for (i = 0; i < len; i++)
11436 if (p[i])
11437 hash = (hash << 4) ^ ((i << 2) | p[i]);
11438
11439 return hash;
11440 }
11441
11442 /* Return nonzero if the value represented by *X (an OPTIMIZATION or
11443 TARGET_OPTION tree node) is the same as that given by *Y, which is the
11444 same. */
11445
11446 static int
cl_option_hash_eq(const void * x,const void * y)11447 cl_option_hash_eq (const void *x, const void *y)
11448 {
11449 const_tree const xt = (const_tree) x;
11450 const_tree const yt = (const_tree) y;
11451 const char *xp;
11452 const char *yp;
11453 size_t len;
11454
11455 if (TREE_CODE (xt) != TREE_CODE (yt))
11456 return 0;
11457
11458 if (TREE_CODE (xt) == OPTIMIZATION_NODE)
11459 {
11460 xp = (const char *)TREE_OPTIMIZATION (xt);
11461 yp = (const char *)TREE_OPTIMIZATION (yt);
11462 len = sizeof (struct cl_optimization);
11463 }
11464
11465 else if (TREE_CODE (xt) == TARGET_OPTION_NODE)
11466 {
11467 xp = (const char *)TREE_TARGET_OPTION (xt);
11468 yp = (const char *)TREE_TARGET_OPTION (yt);
11469 len = sizeof (struct cl_target_option);
11470 }
11471
11472 else
11473 gcc_unreachable ();
11474
11475 return (memcmp (xp, yp, len) == 0);
11476 }
11477
11478 /* Build an OPTIMIZATION_NODE based on the options in OPTS. */
11479
11480 tree
build_optimization_node(struct gcc_options * opts)11481 build_optimization_node (struct gcc_options *opts)
11482 {
11483 tree t;
11484 void **slot;
11485
11486 /* Use the cache of optimization nodes. */
11487
11488 cl_optimization_save (TREE_OPTIMIZATION (cl_optimization_node),
11489 opts);
11490
11491 slot = htab_find_slot (cl_option_hash_table, cl_optimization_node, INSERT);
11492 t = (tree) *slot;
11493 if (!t)
11494 {
11495 /* Insert this one into the hash table. */
11496 t = cl_optimization_node;
11497 *slot = t;
11498
11499 /* Make a new node for next time round. */
11500 cl_optimization_node = make_node (OPTIMIZATION_NODE);
11501 }
11502
11503 return t;
11504 }
11505
11506 /* Build a TARGET_OPTION_NODE based on the options in OPTS. */
11507
11508 tree
build_target_option_node(struct gcc_options * opts)11509 build_target_option_node (struct gcc_options *opts)
11510 {
11511 tree t;
11512 void **slot;
11513
11514 /* Use the cache of optimization nodes. */
11515
11516 cl_target_option_save (TREE_TARGET_OPTION (cl_target_option_node),
11517 opts);
11518
11519 slot = htab_find_slot (cl_option_hash_table, cl_target_option_node, INSERT);
11520 t = (tree) *slot;
11521 if (!t)
11522 {
11523 /* Insert this one into the hash table. */
11524 t = cl_target_option_node;
11525 *slot = t;
11526
11527 /* Make a new node for next time round. */
11528 cl_target_option_node = make_node (TARGET_OPTION_NODE);
11529 }
11530
11531 return t;
11532 }
11533
11534 /* Reset TREE_TARGET_GLOBALS cache for TARGET_OPTION_NODE.
11535 Called through htab_traverse. */
11536
11537 static int
prepare_target_option_node_for_pch(void ** slot,void *)11538 prepare_target_option_node_for_pch (void **slot, void *)
11539 {
11540 tree node = (tree) *slot;
11541 if (TREE_CODE (node) == TARGET_OPTION_NODE)
11542 TREE_TARGET_GLOBALS (node) = NULL;
11543 return 1;
11544 }
11545
11546 /* Clear TREE_TARGET_GLOBALS of all TARGET_OPTION_NODE trees,
11547 so that they aren't saved during PCH writing. */
11548
11549 void
prepare_target_option_nodes_for_pch(void)11550 prepare_target_option_nodes_for_pch (void)
11551 {
11552 htab_traverse (cl_option_hash_table, prepare_target_option_node_for_pch,
11553 NULL);
11554 }
11555
11556 /* Determine the "ultimate origin" of a block. The block may be an inlined
11557 instance of an inlined instance of a block which is local to an inline
11558 function, so we have to trace all of the way back through the origin chain
11559 to find out what sort of node actually served as the original seed for the
11560 given block. */
11561
11562 tree
block_ultimate_origin(const_tree block)11563 block_ultimate_origin (const_tree block)
11564 {
11565 tree immediate_origin = BLOCK_ABSTRACT_ORIGIN (block);
11566
11567 /* output_inline_function sets BLOCK_ABSTRACT_ORIGIN for all the
11568 nodes in the function to point to themselves; ignore that if
11569 we're trying to output the abstract instance of this function. */
11570 if (BLOCK_ABSTRACT (block) && immediate_origin == block)
11571 return NULL_TREE;
11572
11573 if (immediate_origin == NULL_TREE)
11574 return NULL_TREE;
11575 else
11576 {
11577 tree ret_val;
11578 tree lookahead = immediate_origin;
11579
11580 do
11581 {
11582 ret_val = lookahead;
11583 lookahead = (TREE_CODE (ret_val) == BLOCK
11584 ? BLOCK_ABSTRACT_ORIGIN (ret_val) : NULL);
11585 }
11586 while (lookahead != NULL && lookahead != ret_val);
11587
11588 /* The block's abstract origin chain may not be the *ultimate* origin of
11589 the block. It could lead to a DECL that has an abstract origin set.
11590 If so, we want that DECL's abstract origin (which is what DECL_ORIGIN
11591 will give us if it has one). Note that DECL's abstract origins are
11592 supposed to be the most distant ancestor (or so decl_ultimate_origin
11593 claims), so we don't need to loop following the DECL origins. */
11594 if (DECL_P (ret_val))
11595 return DECL_ORIGIN (ret_val);
11596
11597 return ret_val;
11598 }
11599 }
11600
11601 /* Return true iff conversion in EXP generates no instruction. Mark
11602 it inline so that we fully inline into the stripping functions even
11603 though we have two uses of this function. */
11604
11605 static inline bool
tree_nop_conversion(const_tree exp)11606 tree_nop_conversion (const_tree exp)
11607 {
11608 tree outer_type, inner_type;
11609
11610 if (!CONVERT_EXPR_P (exp)
11611 && TREE_CODE (exp) != NON_LVALUE_EXPR)
11612 return false;
11613 if (TREE_OPERAND (exp, 0) == error_mark_node)
11614 return false;
11615
11616 outer_type = TREE_TYPE (exp);
11617 inner_type = TREE_TYPE (TREE_OPERAND (exp, 0));
11618
11619 if (!inner_type)
11620 return false;
11621
11622 /* Use precision rather then machine mode when we can, which gives
11623 the correct answer even for submode (bit-field) types. */
11624 if ((INTEGRAL_TYPE_P (outer_type)
11625 || POINTER_TYPE_P (outer_type)
11626 || TREE_CODE (outer_type) == OFFSET_TYPE)
11627 && (INTEGRAL_TYPE_P (inner_type)
11628 || POINTER_TYPE_P (inner_type)
11629 || TREE_CODE (inner_type) == OFFSET_TYPE))
11630 return TYPE_PRECISION (outer_type) == TYPE_PRECISION (inner_type);
11631
11632 /* Otherwise fall back on comparing machine modes (e.g. for
11633 aggregate types, floats). */
11634 return TYPE_MODE (outer_type) == TYPE_MODE (inner_type);
11635 }
11636
11637 /* Return true iff conversion in EXP generates no instruction. Don't
11638 consider conversions changing the signedness. */
11639
11640 static bool
tree_sign_nop_conversion(const_tree exp)11641 tree_sign_nop_conversion (const_tree exp)
11642 {
11643 tree outer_type, inner_type;
11644
11645 if (!tree_nop_conversion (exp))
11646 return false;
11647
11648 outer_type = TREE_TYPE (exp);
11649 inner_type = TREE_TYPE (TREE_OPERAND (exp, 0));
11650
11651 return (TYPE_UNSIGNED (outer_type) == TYPE_UNSIGNED (inner_type)
11652 && POINTER_TYPE_P (outer_type) == POINTER_TYPE_P (inner_type));
11653 }
11654
11655 /* Strip conversions from EXP according to tree_nop_conversion and
11656 return the resulting expression. */
11657
11658 tree
tree_strip_nop_conversions(tree exp)11659 tree_strip_nop_conversions (tree exp)
11660 {
11661 while (tree_nop_conversion (exp))
11662 exp = TREE_OPERAND (exp, 0);
11663 return exp;
11664 }
11665
11666 /* Strip conversions from EXP according to tree_sign_nop_conversion
11667 and return the resulting expression. */
11668
11669 tree
tree_strip_sign_nop_conversions(tree exp)11670 tree_strip_sign_nop_conversions (tree exp)
11671 {
11672 while (tree_sign_nop_conversion (exp))
11673 exp = TREE_OPERAND (exp, 0);
11674 return exp;
11675 }
11676
11677 /* Avoid any floating point extensions from EXP. */
11678 tree
strip_float_extensions(tree exp)11679 strip_float_extensions (tree exp)
11680 {
11681 tree sub, expt, subt;
11682
11683 /* For floating point constant look up the narrowest type that can hold
11684 it properly and handle it like (type)(narrowest_type)constant.
11685 This way we can optimize for instance a=a*2.0 where "a" is float
11686 but 2.0 is double constant. */
11687 if (TREE_CODE (exp) == REAL_CST && !DECIMAL_FLOAT_TYPE_P (TREE_TYPE (exp)))
11688 {
11689 REAL_VALUE_TYPE orig;
11690 tree type = NULL;
11691
11692 orig = TREE_REAL_CST (exp);
11693 if (TYPE_PRECISION (TREE_TYPE (exp)) > TYPE_PRECISION (float_type_node)
11694 && exact_real_truncate (TYPE_MODE (float_type_node), &orig))
11695 type = float_type_node;
11696 else if (TYPE_PRECISION (TREE_TYPE (exp))
11697 > TYPE_PRECISION (double_type_node)
11698 && exact_real_truncate (TYPE_MODE (double_type_node), &orig))
11699 type = double_type_node;
11700 if (type)
11701 return build_real (type, real_value_truncate (TYPE_MODE (type), orig));
11702 }
11703
11704 if (!CONVERT_EXPR_P (exp))
11705 return exp;
11706
11707 sub = TREE_OPERAND (exp, 0);
11708 subt = TREE_TYPE (sub);
11709 expt = TREE_TYPE (exp);
11710
11711 if (!FLOAT_TYPE_P (subt))
11712 return exp;
11713
11714 if (DECIMAL_FLOAT_TYPE_P (expt) != DECIMAL_FLOAT_TYPE_P (subt))
11715 return exp;
11716
11717 if (TYPE_PRECISION (subt) > TYPE_PRECISION (expt))
11718 return exp;
11719
11720 return strip_float_extensions (sub);
11721 }
11722
11723 /* Strip out all handled components that produce invariant
11724 offsets. */
11725
11726 const_tree
strip_invariant_refs(const_tree op)11727 strip_invariant_refs (const_tree op)
11728 {
11729 while (handled_component_p (op))
11730 {
11731 switch (TREE_CODE (op))
11732 {
11733 case ARRAY_REF:
11734 case ARRAY_RANGE_REF:
11735 if (!is_gimple_constant (TREE_OPERAND (op, 1))
11736 || TREE_OPERAND (op, 2) != NULL_TREE
11737 || TREE_OPERAND (op, 3) != NULL_TREE)
11738 return NULL;
11739 break;
11740
11741 case COMPONENT_REF:
11742 if (TREE_OPERAND (op, 2) != NULL_TREE)
11743 return NULL;
11744 break;
11745
11746 default:;
11747 }
11748 op = TREE_OPERAND (op, 0);
11749 }
11750
11751 return op;
11752 }
11753
11754 static GTY(()) tree gcc_eh_personality_decl;
11755
11756 /* Return the GCC personality function decl. */
11757
11758 tree
lhd_gcc_personality(void)11759 lhd_gcc_personality (void)
11760 {
11761 if (!gcc_eh_personality_decl)
11762 gcc_eh_personality_decl = build_personality_function ("gcc");
11763 return gcc_eh_personality_decl;
11764 }
11765
11766 /* For languages with One Definition Rule, work out if
11767 trees are actually the same even if the tree representation
11768 differs. This handles only decls appearing in TYPE_NAME
11769 and TYPE_CONTEXT. That is NAMESPACE_DECL, TYPE_DECL,
11770 RECORD_TYPE and IDENTIFIER_NODE. */
11771
11772 static bool
same_for_odr(tree t1,tree t2)11773 same_for_odr (tree t1, tree t2)
11774 {
11775 if (t1 == t2)
11776 return true;
11777 if (!t1 || !t2)
11778 return false;
11779 /* C and C++ FEs differ by using IDENTIFIER_NODE and TYPE_DECL. */
11780 if (TREE_CODE (t1) == IDENTIFIER_NODE
11781 && TREE_CODE (t2) == TYPE_DECL
11782 && DECL_FILE_SCOPE_P (t1))
11783 {
11784 t2 = DECL_NAME (t2);
11785 gcc_assert (TREE_CODE (t2) == IDENTIFIER_NODE);
11786 }
11787 if (TREE_CODE (t2) == IDENTIFIER_NODE
11788 && TREE_CODE (t1) == TYPE_DECL
11789 && DECL_FILE_SCOPE_P (t2))
11790 {
11791 t1 = DECL_NAME (t1);
11792 gcc_assert (TREE_CODE (t1) == IDENTIFIER_NODE);
11793 }
11794 if (TREE_CODE (t1) != TREE_CODE (t2))
11795 return false;
11796 if (TYPE_P (t1))
11797 return types_same_for_odr (t1, t2);
11798 if (DECL_P (t1))
11799 return decls_same_for_odr (t1, t2);
11800 return false;
11801 }
11802
11803 /* For languages with One Definition Rule, work out if
11804 decls are actually the same even if the tree representation
11805 differs. This handles only decls appearing in TYPE_NAME
11806 and TYPE_CONTEXT. That is NAMESPACE_DECL, TYPE_DECL,
11807 RECORD_TYPE and IDENTIFIER_NODE. */
11808
11809 static bool
decls_same_for_odr(tree decl1,tree decl2)11810 decls_same_for_odr (tree decl1, tree decl2)
11811 {
11812 if (decl1 && TREE_CODE (decl1) == TYPE_DECL
11813 && DECL_ORIGINAL_TYPE (decl1))
11814 decl1 = DECL_ORIGINAL_TYPE (decl1);
11815 if (decl2 && TREE_CODE (decl2) == TYPE_DECL
11816 && DECL_ORIGINAL_TYPE (decl2))
11817 decl2 = DECL_ORIGINAL_TYPE (decl2);
11818 if (decl1 == decl2)
11819 return true;
11820 if (!decl1 || !decl2)
11821 return false;
11822 gcc_checking_assert (DECL_P (decl1) && DECL_P (decl2));
11823 if (TREE_CODE (decl1) != TREE_CODE (decl2))
11824 return false;
11825 if (TREE_CODE (decl1) == TRANSLATION_UNIT_DECL)
11826 return true;
11827 if (TREE_CODE (decl1) != NAMESPACE_DECL
11828 && TREE_CODE (decl1) != TYPE_DECL)
11829 return false;
11830 if (!DECL_NAME (decl1))
11831 return false;
11832 gcc_checking_assert (TREE_CODE (DECL_NAME (decl1)) == IDENTIFIER_NODE);
11833 gcc_checking_assert (!DECL_NAME (decl2)
11834 || TREE_CODE (DECL_NAME (decl2)) == IDENTIFIER_NODE);
11835 if (DECL_NAME (decl1) != DECL_NAME (decl2))
11836 return false;
11837 return same_for_odr (DECL_CONTEXT (decl1),
11838 DECL_CONTEXT (decl2));
11839 }
11840
11841 /* For languages with One Definition Rule, work out if
11842 types are same even if the tree representation differs.
11843 This is non-trivial for LTO where minnor differences in
11844 the type representation may have prevented type merging
11845 to merge two copies of otherwise equivalent type. */
11846
11847 bool
types_same_for_odr(tree type1,tree type2)11848 types_same_for_odr (tree type1, tree type2)
11849 {
11850 gcc_checking_assert (TYPE_P (type1) && TYPE_P (type2));
11851 type1 = TYPE_MAIN_VARIANT (type1);
11852 type2 = TYPE_MAIN_VARIANT (type2);
11853 if (type1 == type2)
11854 return true;
11855
11856 #ifndef ENABLE_CHECKING
11857 if (!in_lto_p)
11858 return false;
11859 #endif
11860
11861 /* Check for anonymous namespaces. Those have !TREE_PUBLIC
11862 on the corresponding TYPE_STUB_DECL. */
11863 if (type_in_anonymous_namespace_p (type1)
11864 || type_in_anonymous_namespace_p (type2))
11865 return false;
11866 /* When assembler name of virtual table is available, it is
11867 easy to compare types for equivalence. */
11868 if (TYPE_BINFO (type1) && TYPE_BINFO (type2)
11869 && BINFO_VTABLE (TYPE_BINFO (type1))
11870 && BINFO_VTABLE (TYPE_BINFO (type2)))
11871 {
11872 tree v1 = BINFO_VTABLE (TYPE_BINFO (type1));
11873 tree v2 = BINFO_VTABLE (TYPE_BINFO (type2));
11874
11875 if (TREE_CODE (v1) == POINTER_PLUS_EXPR)
11876 {
11877 if (TREE_CODE (v2) != POINTER_PLUS_EXPR
11878 || !operand_equal_p (TREE_OPERAND (v1, 1),
11879 TREE_OPERAND (v2, 1), 0))
11880 return false;
11881 v1 = TREE_OPERAND (TREE_OPERAND (v1, 0), 0);
11882 v2 = TREE_OPERAND (TREE_OPERAND (v2, 0), 0);
11883 }
11884 v1 = DECL_ASSEMBLER_NAME (v1);
11885 v2 = DECL_ASSEMBLER_NAME (v2);
11886 return (v1 == v2);
11887 }
11888
11889 /* FIXME: the code comparing type names consider all instantiations of the
11890 same template to have same name. This is because we have no access
11891 to template parameters. For types with no virtual method tables
11892 we thus can return false positives. At the moment we do not need
11893 to compare types in other scenarios than devirtualization. */
11894
11895 /* If types are not structuraly same, do not bother to contnue.
11896 Match in the remainder of code would mean ODR violation. */
11897 if (!types_compatible_p (type1, type2))
11898 return false;
11899 if (!TYPE_NAME (type1))
11900 return false;
11901 if (!decls_same_for_odr (TYPE_NAME (type1), TYPE_NAME (type2)))
11902 return false;
11903 if (!same_for_odr (TYPE_CONTEXT (type1), TYPE_CONTEXT (type2)))
11904 return false;
11905 /* When not in LTO the MAIN_VARIANT check should be the same. */
11906 gcc_assert (in_lto_p);
11907
11908 return true;
11909 }
11910
11911 /* TARGET is a call target of GIMPLE call statement
11912 (obtained by gimple_call_fn). Return true if it is
11913 OBJ_TYPE_REF representing an virtual call of C++ method.
11914 (As opposed to OBJ_TYPE_REF representing objc calls
11915 through a cast where middle-end devirtualization machinery
11916 can't apply.) */
11917
11918 bool
virtual_method_call_p(tree target)11919 virtual_method_call_p (tree target)
11920 {
11921 if (TREE_CODE (target) != OBJ_TYPE_REF)
11922 return false;
11923 target = TREE_TYPE (target);
11924 gcc_checking_assert (TREE_CODE (target) == POINTER_TYPE);
11925 target = TREE_TYPE (target);
11926 if (TREE_CODE (target) == FUNCTION_TYPE)
11927 return false;
11928 gcc_checking_assert (TREE_CODE (target) == METHOD_TYPE);
11929 return true;
11930 }
11931
11932 /* REF is OBJ_TYPE_REF, return the class the ref corresponds to. */
11933
11934 tree
obj_type_ref_class(tree ref)11935 obj_type_ref_class (tree ref)
11936 {
11937 gcc_checking_assert (TREE_CODE (ref) == OBJ_TYPE_REF);
11938 ref = TREE_TYPE (ref);
11939 gcc_checking_assert (TREE_CODE (ref) == POINTER_TYPE);
11940 ref = TREE_TYPE (ref);
11941 /* We look for type THIS points to. ObjC also builds
11942 OBJ_TYPE_REF with non-method calls, Their first parameter
11943 ID however also corresponds to class type. */
11944 gcc_checking_assert (TREE_CODE (ref) == METHOD_TYPE
11945 || TREE_CODE (ref) == FUNCTION_TYPE);
11946 ref = TREE_VALUE (TYPE_ARG_TYPES (ref));
11947 gcc_checking_assert (TREE_CODE (ref) == POINTER_TYPE);
11948 return TREE_TYPE (ref);
11949 }
11950
11951 /* Return true if T is in anonymous namespace. */
11952
11953 bool
type_in_anonymous_namespace_p(tree t)11954 type_in_anonymous_namespace_p (tree t)
11955 {
11956 return (TYPE_STUB_DECL (t) && !TREE_PUBLIC (TYPE_STUB_DECL (t)));
11957 }
11958
11959 /* Try to find a base info of BINFO that would have its field decl at offset
11960 OFFSET within the BINFO type and which is of EXPECTED_TYPE. If it can be
11961 found, return, otherwise return NULL_TREE. */
11962
11963 tree
get_binfo_at_offset(tree binfo,HOST_WIDE_INT offset,tree expected_type)11964 get_binfo_at_offset (tree binfo, HOST_WIDE_INT offset, tree expected_type)
11965 {
11966 tree type = BINFO_TYPE (binfo);
11967
11968 while (true)
11969 {
11970 HOST_WIDE_INT pos, size;
11971 tree fld;
11972 int i;
11973
11974 if (types_same_for_odr (type, expected_type))
11975 return binfo;
11976 if (offset < 0)
11977 return NULL_TREE;
11978
11979 for (fld = TYPE_FIELDS (type); fld; fld = DECL_CHAIN (fld))
11980 {
11981 if (TREE_CODE (fld) != FIELD_DECL)
11982 continue;
11983
11984 pos = int_bit_position (fld);
11985 size = tree_to_uhwi (DECL_SIZE (fld));
11986 if (pos <= offset && (pos + size) > offset)
11987 break;
11988 }
11989 if (!fld || TREE_CODE (TREE_TYPE (fld)) != RECORD_TYPE)
11990 return NULL_TREE;
11991
11992 if (!DECL_ARTIFICIAL (fld))
11993 {
11994 binfo = TYPE_BINFO (TREE_TYPE (fld));
11995 if (!binfo)
11996 return NULL_TREE;
11997 }
11998 /* Offset 0 indicates the primary base, whose vtable contents are
11999 represented in the binfo for the derived class. */
12000 else if (offset != 0)
12001 {
12002 tree base_binfo, binfo2 = binfo;
12003
12004 /* Find BINFO corresponding to FLD. This is bit harder
12005 by a fact that in virtual inheritance we may need to walk down
12006 the non-virtual inheritance chain. */
12007 while (true)
12008 {
12009 tree containing_binfo = NULL, found_binfo = NULL;
12010 for (i = 0; BINFO_BASE_ITERATE (binfo2, i, base_binfo); i++)
12011 if (types_same_for_odr (TREE_TYPE (base_binfo), TREE_TYPE (fld)))
12012 {
12013 found_binfo = base_binfo;
12014 break;
12015 }
12016 else
12017 if ((tree_to_shwi (BINFO_OFFSET (base_binfo))
12018 - tree_to_shwi (BINFO_OFFSET (binfo)))
12019 * BITS_PER_UNIT < pos
12020 /* Rule out types with no virtual methods or we can get confused
12021 here by zero sized bases. */
12022 && BINFO_VTABLE (TYPE_BINFO (BINFO_TYPE (base_binfo)))
12023 && (!containing_binfo
12024 || (tree_to_shwi (BINFO_OFFSET (containing_binfo))
12025 < tree_to_shwi (BINFO_OFFSET (base_binfo)))))
12026 containing_binfo = base_binfo;
12027 if (found_binfo)
12028 {
12029 binfo = found_binfo;
12030 break;
12031 }
12032 if (!containing_binfo)
12033 return NULL_TREE;
12034 binfo2 = containing_binfo;
12035 }
12036 }
12037
12038 type = TREE_TYPE (fld);
12039 offset -= pos;
12040 }
12041 }
12042
12043 /* Returns true if X is a typedef decl. */
12044
12045 bool
is_typedef_decl(tree x)12046 is_typedef_decl (tree x)
12047 {
12048 return (x && TREE_CODE (x) == TYPE_DECL
12049 && DECL_ORIGINAL_TYPE (x) != NULL_TREE);
12050 }
12051
12052 /* Returns true iff TYPE is a type variant created for a typedef. */
12053
12054 bool
typedef_variant_p(tree type)12055 typedef_variant_p (tree type)
12056 {
12057 return is_typedef_decl (TYPE_NAME (type));
12058 }
12059
12060 /* Warn about a use of an identifier which was marked deprecated. */
12061 void
warn_deprecated_use(tree node,tree attr)12062 warn_deprecated_use (tree node, tree attr)
12063 {
12064 const char *msg;
12065
12066 if (node == 0 || !warn_deprecated_decl)
12067 return;
12068
12069 if (!attr)
12070 {
12071 if (DECL_P (node))
12072 attr = DECL_ATTRIBUTES (node);
12073 else if (TYPE_P (node))
12074 {
12075 tree decl = TYPE_STUB_DECL (node);
12076 if (decl)
12077 attr = lookup_attribute ("deprecated",
12078 TYPE_ATTRIBUTES (TREE_TYPE (decl)));
12079 }
12080 }
12081
12082 if (attr)
12083 attr = lookup_attribute ("deprecated", attr);
12084
12085 if (attr)
12086 msg = TREE_STRING_POINTER (TREE_VALUE (TREE_VALUE (attr)));
12087 else
12088 msg = NULL;
12089
12090 if (DECL_P (node))
12091 {
12092 expanded_location xloc = expand_location (DECL_SOURCE_LOCATION (node));
12093 if (msg)
12094 warning (OPT_Wdeprecated_declarations,
12095 "%qD is deprecated (declared at %r%s:%d%R): %s",
12096 node, "locus", xloc.file, xloc.line, msg);
12097 else
12098 warning (OPT_Wdeprecated_declarations,
12099 "%qD is deprecated (declared at %r%s:%d%R)",
12100 node, "locus", xloc.file, xloc.line);
12101 }
12102 else if (TYPE_P (node))
12103 {
12104 tree what = NULL_TREE;
12105 tree decl = TYPE_STUB_DECL (node);
12106
12107 if (TYPE_NAME (node))
12108 {
12109 if (TREE_CODE (TYPE_NAME (node)) == IDENTIFIER_NODE)
12110 what = TYPE_NAME (node);
12111 else if (TREE_CODE (TYPE_NAME (node)) == TYPE_DECL
12112 && DECL_NAME (TYPE_NAME (node)))
12113 what = DECL_NAME (TYPE_NAME (node));
12114 }
12115
12116 if (decl)
12117 {
12118 expanded_location xloc
12119 = expand_location (DECL_SOURCE_LOCATION (decl));
12120 if (what)
12121 {
12122 if (msg)
12123 warning (OPT_Wdeprecated_declarations,
12124 "%qE is deprecated (declared at %r%s:%d%R): %s",
12125 what, "locus", xloc.file, xloc.line, msg);
12126 else
12127 warning (OPT_Wdeprecated_declarations,
12128 "%qE is deprecated (declared at %r%s:%d%R)",
12129 what, "locus", xloc.file, xloc.line);
12130 }
12131 else
12132 {
12133 if (msg)
12134 warning (OPT_Wdeprecated_declarations,
12135 "type is deprecated (declared at %r%s:%d%R): %s",
12136 "locus", xloc.file, xloc.line, msg);
12137 else
12138 warning (OPT_Wdeprecated_declarations,
12139 "type is deprecated (declared at %r%s:%d%R)",
12140 "locus", xloc.file, xloc.line);
12141 }
12142 }
12143 else
12144 {
12145 if (what)
12146 {
12147 if (msg)
12148 warning (OPT_Wdeprecated_declarations, "%qE is deprecated: %s",
12149 what, msg);
12150 else
12151 warning (OPT_Wdeprecated_declarations, "%qE is deprecated", what);
12152 }
12153 else
12154 {
12155 if (msg)
12156 warning (OPT_Wdeprecated_declarations, "type is deprecated: %s",
12157 msg);
12158 else
12159 warning (OPT_Wdeprecated_declarations, "type is deprecated");
12160 }
12161 }
12162 }
12163 }
12164
12165 /* Return true if REF has a COMPONENT_REF with a bit-field field declaration
12166 somewhere in it. */
12167
12168 bool
contains_bitfld_component_ref_p(const_tree ref)12169 contains_bitfld_component_ref_p (const_tree ref)
12170 {
12171 while (handled_component_p (ref))
12172 {
12173 if (TREE_CODE (ref) == COMPONENT_REF
12174 && DECL_BIT_FIELD (TREE_OPERAND (ref, 1)))
12175 return true;
12176 ref = TREE_OPERAND (ref, 0);
12177 }
12178
12179 return false;
12180 }
12181
12182 /* Try to determine whether a TRY_CATCH expression can fall through.
12183 This is a subroutine of block_may_fallthru. */
12184
12185 static bool
try_catch_may_fallthru(const_tree stmt)12186 try_catch_may_fallthru (const_tree stmt)
12187 {
12188 tree_stmt_iterator i;
12189
12190 /* If the TRY block can fall through, the whole TRY_CATCH can
12191 fall through. */
12192 if (block_may_fallthru (TREE_OPERAND (stmt, 0)))
12193 return true;
12194
12195 i = tsi_start (TREE_OPERAND (stmt, 1));
12196 switch (TREE_CODE (tsi_stmt (i)))
12197 {
12198 case CATCH_EXPR:
12199 /* We expect to see a sequence of CATCH_EXPR trees, each with a
12200 catch expression and a body. The whole TRY_CATCH may fall
12201 through iff any of the catch bodies falls through. */
12202 for (; !tsi_end_p (i); tsi_next (&i))
12203 {
12204 if (block_may_fallthru (CATCH_BODY (tsi_stmt (i))))
12205 return true;
12206 }
12207 return false;
12208
12209 case EH_FILTER_EXPR:
12210 /* The exception filter expression only matters if there is an
12211 exception. If the exception does not match EH_FILTER_TYPES,
12212 we will execute EH_FILTER_FAILURE, and we will fall through
12213 if that falls through. If the exception does match
12214 EH_FILTER_TYPES, the stack unwinder will continue up the
12215 stack, so we will not fall through. We don't know whether we
12216 will throw an exception which matches EH_FILTER_TYPES or not,
12217 so we just ignore EH_FILTER_TYPES and assume that we might
12218 throw an exception which doesn't match. */
12219 return block_may_fallthru (EH_FILTER_FAILURE (tsi_stmt (i)));
12220
12221 default:
12222 /* This case represents statements to be executed when an
12223 exception occurs. Those statements are implicitly followed
12224 by a RESX statement to resume execution after the exception.
12225 So in this case the TRY_CATCH never falls through. */
12226 return false;
12227 }
12228 }
12229
12230 /* Try to determine if we can fall out of the bottom of BLOCK. This guess
12231 need not be 100% accurate; simply be conservative and return true if we
12232 don't know. This is used only to avoid stupidly generating extra code.
12233 If we're wrong, we'll just delete the extra code later. */
12234
12235 bool
block_may_fallthru(const_tree block)12236 block_may_fallthru (const_tree block)
12237 {
12238 /* This CONST_CAST is okay because expr_last returns its argument
12239 unmodified and we assign it to a const_tree. */
12240 const_tree stmt = expr_last (CONST_CAST_TREE (block));
12241
12242 switch (stmt ? TREE_CODE (stmt) : ERROR_MARK)
12243 {
12244 case GOTO_EXPR:
12245 case RETURN_EXPR:
12246 /* Easy cases. If the last statement of the block implies
12247 control transfer, then we can't fall through. */
12248 return false;
12249
12250 case SWITCH_EXPR:
12251 /* If SWITCH_LABELS is set, this is lowered, and represents a
12252 branch to a selected label and hence can not fall through.
12253 Otherwise SWITCH_BODY is set, and the switch can fall
12254 through. */
12255 return SWITCH_LABELS (stmt) == NULL_TREE;
12256
12257 case COND_EXPR:
12258 if (block_may_fallthru (COND_EXPR_THEN (stmt)))
12259 return true;
12260 return block_may_fallthru (COND_EXPR_ELSE (stmt));
12261
12262 case BIND_EXPR:
12263 return block_may_fallthru (BIND_EXPR_BODY (stmt));
12264
12265 case TRY_CATCH_EXPR:
12266 return try_catch_may_fallthru (stmt);
12267
12268 case TRY_FINALLY_EXPR:
12269 /* The finally clause is always executed after the try clause,
12270 so if it does not fall through, then the try-finally will not
12271 fall through. Otherwise, if the try clause does not fall
12272 through, then when the finally clause falls through it will
12273 resume execution wherever the try clause was going. So the
12274 whole try-finally will only fall through if both the try
12275 clause and the finally clause fall through. */
12276 return (block_may_fallthru (TREE_OPERAND (stmt, 0))
12277 && block_may_fallthru (TREE_OPERAND (stmt, 1)));
12278
12279 case MODIFY_EXPR:
12280 if (TREE_CODE (TREE_OPERAND (stmt, 1)) == CALL_EXPR)
12281 stmt = TREE_OPERAND (stmt, 1);
12282 else
12283 return true;
12284 /* FALLTHRU */
12285
12286 case CALL_EXPR:
12287 /* Functions that do not return do not fall through. */
12288 return (call_expr_flags (stmt) & ECF_NORETURN) == 0;
12289
12290 case CLEANUP_POINT_EXPR:
12291 return block_may_fallthru (TREE_OPERAND (stmt, 0));
12292
12293 case TARGET_EXPR:
12294 return block_may_fallthru (TREE_OPERAND (stmt, 1));
12295
12296 case ERROR_MARK:
12297 return true;
12298
12299 default:
12300 return lang_hooks.block_may_fallthru (stmt);
12301 }
12302 }
12303
12304 /* True if we are using EH to handle cleanups. */
12305 static bool using_eh_for_cleanups_flag = false;
12306
12307 /* This routine is called from front ends to indicate eh should be used for
12308 cleanups. */
12309 void
using_eh_for_cleanups(void)12310 using_eh_for_cleanups (void)
12311 {
12312 using_eh_for_cleanups_flag = true;
12313 }
12314
12315 /* Query whether EH is used for cleanups. */
12316 bool
using_eh_for_cleanups_p(void)12317 using_eh_for_cleanups_p (void)
12318 {
12319 return using_eh_for_cleanups_flag;
12320 }
12321
12322 /* Wrapper for tree_code_name to ensure that tree code is valid */
12323 const char *
get_tree_code_name(enum tree_code code)12324 get_tree_code_name (enum tree_code code)
12325 {
12326 const char *invalid = "<invalid tree code>";
12327
12328 if (code >= MAX_TREE_CODES)
12329 return invalid;
12330
12331 return tree_code_name[code];
12332 }
12333
12334 /* Drops the TREE_OVERFLOW flag from T. */
12335
12336 tree
drop_tree_overflow(tree t)12337 drop_tree_overflow (tree t)
12338 {
12339 gcc_checking_assert (TREE_OVERFLOW (t));
12340
12341 /* For tree codes with a sharing machinery re-build the result. */
12342 if (TREE_CODE (t) == INTEGER_CST)
12343 return build_int_cst_wide (TREE_TYPE (t),
12344 TREE_INT_CST_LOW (t), TREE_INT_CST_HIGH (t));
12345
12346 /* Otherwise, as all tcc_constants are possibly shared, copy the node
12347 and drop the flag. */
12348 t = copy_node (t);
12349 TREE_OVERFLOW (t) = 0;
12350 return t;
12351 }
12352
12353 /* Given a memory reference expression T, return its base address.
12354 The base address of a memory reference expression is the main
12355 object being referenced. For instance, the base address for
12356 'array[i].fld[j]' is 'array'. You can think of this as stripping
12357 away the offset part from a memory address.
12358
12359 This function calls handled_component_p to strip away all the inner
12360 parts of the memory reference until it reaches the base object. */
12361
12362 tree
get_base_address(tree t)12363 get_base_address (tree t)
12364 {
12365 while (handled_component_p (t))
12366 t = TREE_OPERAND (t, 0);
12367
12368 if ((TREE_CODE (t) == MEM_REF
12369 || TREE_CODE (t) == TARGET_MEM_REF)
12370 && TREE_CODE (TREE_OPERAND (t, 0)) == ADDR_EXPR)
12371 t = TREE_OPERAND (TREE_OPERAND (t, 0), 0);
12372
12373 /* ??? Either the alias oracle or all callers need to properly deal
12374 with WITH_SIZE_EXPRs before we can look through those. */
12375 if (TREE_CODE (t) == WITH_SIZE_EXPR)
12376 return NULL_TREE;
12377
12378 return t;
12379 }
12380
12381 #include "gt-tree.h"
12382