1 /* Language-independent node constructors for parse phase of GNU compiler.
2 Copyright (C) 1987-2014 Free Software Foundation, Inc.
4 This file is part of GCC.
6 GCC is free software; you can redistribute it and/or modify it under
7 the terms of the GNU General Public License as published by the Free
8 Software Foundation; either version 3, or (at your option) any later
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
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING3. If not see
18 <http://www.gnu.org/licenses/>. */
20 /* This file contains the low level primitives for operating on tree nodes,
21 including allocation, list operations, interning of identifiers,
22 construction of data type nodes and statement nodes,
23 and construction of type conversion nodes. It also contains
24 tables index by tree code that describe how to take apart
27 It is intended to be language-independent, but occasionally
28 calls language-dependent routines defined (for C) in typecheck.c. */
32 #include "coretypes.h"
37 #include "stor-layout.h"
44 #include "toplev.h" /* get_random_seed */
46 #include "filenames.h"
49 #include "common/common-target.h"
50 #include "langhooks.h"
51 #include "tree-inline.h"
52 #include "tree-iterator.h"
53 #include "basic-block.h"
55 #include "pointer-set.h"
56 #include "tree-ssa-alias.h"
57 #include "internal-fn.h"
58 #include "gimple-expr.h"
61 #include "gimple-iterator.h"
63 #include "gimple-ssa.h"
65 #include "tree-phinodes.h"
66 #include "stringpool.h"
67 #include "tree-ssanames.h"
71 #include "tree-pass.h"
72 #include "langhooks-def.h"
73 #include "diagnostic.h"
74 #include "tree-diagnostic.h"
75 #include "tree-pretty-print.h"
80 /* Tree code classes. */
82 #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) TYPE,
83 #define END_OF_BASE_TREE_CODES tcc_exceptional,
85 const enum tree_code_class tree_code_type
[] = {
86 #include "all-tree.def"
90 #undef END_OF_BASE_TREE_CODES
92 /* Table indexed by tree code giving number of expression
93 operands beyond the fixed part of the node structure.
94 Not used for types or decls. */
96 #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) LENGTH,
97 #define END_OF_BASE_TREE_CODES 0,
99 const unsigned char tree_code_length
[] = {
100 #include "all-tree.def"
104 #undef END_OF_BASE_TREE_CODES
106 /* Names of tree components.
107 Used for printing out the tree and error messages. */
108 #define DEFTREECODE(SYM, NAME, TYPE, LEN) NAME,
109 #define END_OF_BASE_TREE_CODES "@dummy",
111 static const char *const tree_code_name
[] = {
112 #include "all-tree.def"
116 #undef END_OF_BASE_TREE_CODES
118 /* Each tree code class has an associated string representation.
119 These must correspond to the tree_code_class entries. */
121 const char *const tree_code_class_strings
[] =
136 /* obstack.[ch] explicitly declined to prototype this. */
137 extern int _obstack_allocated_p (struct obstack
*h
, void *obj
);
139 /* Statistics-gathering stuff. */
141 static int tree_code_counts
[MAX_TREE_CODES
];
142 int tree_node_counts
[(int) all_kinds
];
143 int tree_node_sizes
[(int) all_kinds
];
145 /* Keep in sync with tree.h:enum tree_node_kind. */
146 static const char * const tree_node_kind_names
[] = {
165 /* Unique id for next decl created. */
166 static GTY(()) int next_decl_uid
;
167 /* Unique id for next type created. */
168 static GTY(()) int next_type_uid
= 1;
169 /* Unique id for next debug decl created. Use negative numbers,
170 to catch erroneous uses. */
171 static GTY(()) int next_debug_decl_uid
;
173 /* Since we cannot rehash a type after it is in the table, we have to
174 keep the hash code. */
176 struct GTY(()) type_hash
{
181 /* Initial size of the hash table (rounded to next prime). */
182 #define TYPE_HASH_INITIAL_SIZE 1000
184 /* Now here is the hash table. When recording a type, it is added to
185 the slot whose index is the hash code. Note that the hash table is
186 used for several kinds of types (function types, array types and
187 array index range types, for now). While all these live in the
188 same table, they are completely independent, and the hash code is
189 computed differently for each of these. */
191 static GTY ((if_marked ("type_hash_marked_p"), param_is (struct type_hash
)))
192 htab_t type_hash_table
;
195 /* Hash table and temporary node for larger integer const values. */
196 static GTY (()) tree int_cst_node
;
197 static GTY ((if_marked ("ggc_marked_p"), param_is (union tree_node
)))
198 htab_t int_cst_hash_table
;
200 /* Hash table for optimization flags and target option flags. Use the same
201 hash table for both sets of options. Nodes for building the current
202 optimization and target option nodes. The assumption is most of the time
203 the options created will already be in the hash table, so we avoid
204 allocating and freeing up a node repeatably. */
205 static GTY (()) tree cl_optimization_node
;
206 static GTY (()) tree cl_target_option_node
;
207 static GTY ((if_marked ("ggc_marked_p"), param_is (union tree_node
)))
208 htab_t cl_option_hash_table
;
210 /* General tree->tree mapping structure for use in hash tables. */
213 static GTY ((if_marked ("tree_decl_map_marked_p"), param_is (struct tree_decl_map
)))
214 htab_t debug_expr_for_decl
;
216 static GTY ((if_marked ("tree_decl_map_marked_p"), param_is (struct tree_decl_map
)))
217 htab_t value_expr_for_decl
;
219 static GTY ((if_marked ("tree_vec_map_marked_p"), param_is (struct tree_vec_map
)))
220 htab_t debug_args_for_decl
;
222 static GTY ((if_marked ("tree_priority_map_marked_p"),
223 param_is (struct tree_priority_map
)))
224 htab_t init_priority_for_decl
;
226 static void set_type_quals (tree
, int, tree
);
227 static int type_hash_eq (const void *, const void *);
228 static hashval_t
type_hash_hash (const void *);
229 static hashval_t
int_cst_hash_hash (const void *);
230 static int int_cst_hash_eq (const void *, const void *);
231 static hashval_t
cl_option_hash_hash (const void *);
232 static int cl_option_hash_eq (const void *, const void *);
233 static void print_type_hash_statistics (void);
234 static void print_debug_expr_statistics (void);
235 static void print_value_expr_statistics (void);
236 static int type_hash_marked_p (const void *);
237 static unsigned int type_hash_list (const_tree
, hashval_t
);
238 static unsigned int attribute_hash_list (const_tree
, hashval_t
);
239 static bool decls_same_for_odr (tree decl1
, tree decl2
);
241 tree global_trees
[TI_MAX
];
242 tree integer_types
[itk_none
];
244 unsigned char tree_contains_struct
[MAX_TREE_CODES
][64];
246 /* Number of operands for each OpenMP clause. */
247 unsigned const char omp_clause_num_ops
[] =
249 0, /* OMP_CLAUSE_ERROR */
250 1, /* OMP_CLAUSE_PRIVATE */
251 1, /* OMP_CLAUSE_SHARED */
252 1, /* OMP_CLAUSE_FIRSTPRIVATE */
253 2, /* OMP_CLAUSE_LASTPRIVATE */
254 4, /* OMP_CLAUSE_REDUCTION */
255 1, /* OMP_CLAUSE_COPYIN */
256 1, /* OMP_CLAUSE_COPYPRIVATE */
257 2, /* OMP_CLAUSE_LINEAR */
258 2, /* OMP_CLAUSE_ALIGNED */
259 1, /* OMP_CLAUSE_DEPEND */
260 1, /* OMP_CLAUSE_UNIFORM */
261 2, /* OMP_CLAUSE_FROM */
262 2, /* OMP_CLAUSE_TO */
263 2, /* OMP_CLAUSE_MAP */
264 1, /* OMP_CLAUSE__LOOPTEMP_ */
265 1, /* OMP_CLAUSE_IF */
266 1, /* OMP_CLAUSE_NUM_THREADS */
267 1, /* OMP_CLAUSE_SCHEDULE */
268 0, /* OMP_CLAUSE_NOWAIT */
269 0, /* OMP_CLAUSE_ORDERED */
270 0, /* OMP_CLAUSE_DEFAULT */
271 3, /* OMP_CLAUSE_COLLAPSE */
272 0, /* OMP_CLAUSE_UNTIED */
273 1, /* OMP_CLAUSE_FINAL */
274 0, /* OMP_CLAUSE_MERGEABLE */
275 1, /* OMP_CLAUSE_DEVICE */
276 1, /* OMP_CLAUSE_DIST_SCHEDULE */
277 0, /* OMP_CLAUSE_INBRANCH */
278 0, /* OMP_CLAUSE_NOTINBRANCH */
279 1, /* OMP_CLAUSE_NUM_TEAMS */
280 1, /* OMP_CLAUSE_THREAD_LIMIT */
281 0, /* OMP_CLAUSE_PROC_BIND */
282 1, /* OMP_CLAUSE_SAFELEN */
283 1, /* OMP_CLAUSE_SIMDLEN */
284 0, /* OMP_CLAUSE_FOR */
285 0, /* OMP_CLAUSE_PARALLEL */
286 0, /* OMP_CLAUSE_SECTIONS */
287 0, /* OMP_CLAUSE_TASKGROUP */
288 1, /* OMP_CLAUSE__SIMDUID_ */
291 const char * const omp_clause_code_name
[] =
336 /* Return the tree node structure used by tree code CODE. */
338 static inline enum tree_node_structure_enum
339 tree_node_structure_for_code (enum tree_code code
)
341 switch (TREE_CODE_CLASS (code
))
343 case tcc_declaration
:
348 return TS_FIELD_DECL
;
354 return TS_LABEL_DECL
;
356 return TS_RESULT_DECL
;
357 case DEBUG_EXPR_DECL
:
360 return TS_CONST_DECL
;
364 return TS_FUNCTION_DECL
;
365 case TRANSLATION_UNIT_DECL
:
366 return TS_TRANSLATION_UNIT_DECL
;
368 return TS_DECL_NON_COMMON
;
372 return TS_TYPE_NON_COMMON
;
381 default: /* tcc_constant and tcc_exceptional */
386 /* tcc_constant cases. */
387 case INTEGER_CST
: return TS_INT_CST
;
388 case REAL_CST
: return TS_REAL_CST
;
389 case FIXED_CST
: return TS_FIXED_CST
;
390 case COMPLEX_CST
: return TS_COMPLEX
;
391 case VECTOR_CST
: return TS_VECTOR
;
392 case STRING_CST
: return TS_STRING
;
393 /* tcc_exceptional cases. */
394 case ERROR_MARK
: return TS_COMMON
;
395 case IDENTIFIER_NODE
: return TS_IDENTIFIER
;
396 case TREE_LIST
: return TS_LIST
;
397 case TREE_VEC
: return TS_VEC
;
398 case SSA_NAME
: return TS_SSA_NAME
;
399 case PLACEHOLDER_EXPR
: return TS_COMMON
;
400 case STATEMENT_LIST
: return TS_STATEMENT_LIST
;
401 case BLOCK
: return TS_BLOCK
;
402 case CONSTRUCTOR
: return TS_CONSTRUCTOR
;
403 case TREE_BINFO
: return TS_BINFO
;
404 case OMP_CLAUSE
: return TS_OMP_CLAUSE
;
405 case OPTIMIZATION_NODE
: return TS_OPTIMIZATION
;
406 case TARGET_OPTION_NODE
: return TS_TARGET_OPTION
;
414 /* Initialize tree_contains_struct to describe the hierarchy of tree
418 initialize_tree_contains_struct (void)
422 for (i
= ERROR_MARK
; i
< LAST_AND_UNUSED_TREE_CODE
; i
++)
425 enum tree_node_structure_enum ts_code
;
427 code
= (enum tree_code
) i
;
428 ts_code
= tree_node_structure_for_code (code
);
430 /* Mark the TS structure itself. */
431 tree_contains_struct
[code
][ts_code
] = 1;
433 /* Mark all the structures that TS is derived from. */
451 case TS_STATEMENT_LIST
:
452 MARK_TS_TYPED (code
);
456 case TS_DECL_MINIMAL
:
462 case TS_OPTIMIZATION
:
463 case TS_TARGET_OPTION
:
464 MARK_TS_COMMON (code
);
467 case TS_TYPE_WITH_LANG_SPECIFIC
:
468 MARK_TS_TYPE_COMMON (code
);
471 case TS_TYPE_NON_COMMON
:
472 MARK_TS_TYPE_WITH_LANG_SPECIFIC (code
);
476 MARK_TS_DECL_MINIMAL (code
);
481 MARK_TS_DECL_COMMON (code
);
484 case TS_DECL_NON_COMMON
:
485 MARK_TS_DECL_WITH_VIS (code
);
488 case TS_DECL_WITH_VIS
:
492 MARK_TS_DECL_WRTL (code
);
496 MARK_TS_DECL_COMMON (code
);
500 MARK_TS_DECL_WITH_VIS (code
);
504 case TS_FUNCTION_DECL
:
505 MARK_TS_DECL_NON_COMMON (code
);
508 case TS_TRANSLATION_UNIT_DECL
:
509 MARK_TS_DECL_COMMON (code
);
517 /* Basic consistency checks for attributes used in fold. */
518 gcc_assert (tree_contains_struct
[FUNCTION_DECL
][TS_DECL_NON_COMMON
]);
519 gcc_assert (tree_contains_struct
[TYPE_DECL
][TS_DECL_NON_COMMON
]);
520 gcc_assert (tree_contains_struct
[CONST_DECL
][TS_DECL_COMMON
]);
521 gcc_assert (tree_contains_struct
[VAR_DECL
][TS_DECL_COMMON
]);
522 gcc_assert (tree_contains_struct
[PARM_DECL
][TS_DECL_COMMON
]);
523 gcc_assert (tree_contains_struct
[RESULT_DECL
][TS_DECL_COMMON
]);
524 gcc_assert (tree_contains_struct
[FUNCTION_DECL
][TS_DECL_COMMON
]);
525 gcc_assert (tree_contains_struct
[TYPE_DECL
][TS_DECL_COMMON
]);
526 gcc_assert (tree_contains_struct
[TRANSLATION_UNIT_DECL
][TS_DECL_COMMON
]);
527 gcc_assert (tree_contains_struct
[LABEL_DECL
][TS_DECL_COMMON
]);
528 gcc_assert (tree_contains_struct
[FIELD_DECL
][TS_DECL_COMMON
]);
529 gcc_assert (tree_contains_struct
[VAR_DECL
][TS_DECL_WRTL
]);
530 gcc_assert (tree_contains_struct
[PARM_DECL
][TS_DECL_WRTL
]);
531 gcc_assert (tree_contains_struct
[RESULT_DECL
][TS_DECL_WRTL
]);
532 gcc_assert (tree_contains_struct
[FUNCTION_DECL
][TS_DECL_WRTL
]);
533 gcc_assert (tree_contains_struct
[LABEL_DECL
][TS_DECL_WRTL
]);
534 gcc_assert (tree_contains_struct
[CONST_DECL
][TS_DECL_MINIMAL
]);
535 gcc_assert (tree_contains_struct
[VAR_DECL
][TS_DECL_MINIMAL
]);
536 gcc_assert (tree_contains_struct
[PARM_DECL
][TS_DECL_MINIMAL
]);
537 gcc_assert (tree_contains_struct
[RESULT_DECL
][TS_DECL_MINIMAL
]);
538 gcc_assert (tree_contains_struct
[FUNCTION_DECL
][TS_DECL_MINIMAL
]);
539 gcc_assert (tree_contains_struct
[TYPE_DECL
][TS_DECL_MINIMAL
]);
540 gcc_assert (tree_contains_struct
[TRANSLATION_UNIT_DECL
][TS_DECL_MINIMAL
]);
541 gcc_assert (tree_contains_struct
[LABEL_DECL
][TS_DECL_MINIMAL
]);
542 gcc_assert (tree_contains_struct
[FIELD_DECL
][TS_DECL_MINIMAL
]);
543 gcc_assert (tree_contains_struct
[VAR_DECL
][TS_DECL_WITH_VIS
]);
544 gcc_assert (tree_contains_struct
[FUNCTION_DECL
][TS_DECL_WITH_VIS
]);
545 gcc_assert (tree_contains_struct
[TYPE_DECL
][TS_DECL_WITH_VIS
]);
546 gcc_assert (tree_contains_struct
[VAR_DECL
][TS_VAR_DECL
]);
547 gcc_assert (tree_contains_struct
[FIELD_DECL
][TS_FIELD_DECL
]);
548 gcc_assert (tree_contains_struct
[PARM_DECL
][TS_PARM_DECL
]);
549 gcc_assert (tree_contains_struct
[LABEL_DECL
][TS_LABEL_DECL
]);
550 gcc_assert (tree_contains_struct
[RESULT_DECL
][TS_RESULT_DECL
]);
551 gcc_assert (tree_contains_struct
[CONST_DECL
][TS_CONST_DECL
]);
552 gcc_assert (tree_contains_struct
[TYPE_DECL
][TS_TYPE_DECL
]);
553 gcc_assert (tree_contains_struct
[FUNCTION_DECL
][TS_FUNCTION_DECL
]);
554 gcc_assert (tree_contains_struct
[IMPORTED_DECL
][TS_DECL_MINIMAL
]);
555 gcc_assert (tree_contains_struct
[IMPORTED_DECL
][TS_DECL_COMMON
]);
556 gcc_assert (tree_contains_struct
[NAMELIST_DECL
][TS_DECL_MINIMAL
]);
557 gcc_assert (tree_contains_struct
[NAMELIST_DECL
][TS_DECL_COMMON
]);
566 /* Initialize the hash table of types. */
567 type_hash_table
= htab_create_ggc (TYPE_HASH_INITIAL_SIZE
, type_hash_hash
,
570 /* Initialize hash table used to manage UPC blocking factors. */
571 upc_block_factor_lookup_init ();
573 debug_expr_for_decl
= htab_create_ggc (512, tree_decl_map_hash
,
574 tree_decl_map_eq
, 0);
576 value_expr_for_decl
= htab_create_ggc (512, tree_decl_map_hash
,
577 tree_decl_map_eq
, 0);
578 init_priority_for_decl
= htab_create_ggc (512, tree_priority_map_hash
,
579 tree_priority_map_eq
, 0);
581 int_cst_hash_table
= htab_create_ggc (1024, int_cst_hash_hash
,
582 int_cst_hash_eq
, NULL
);
584 int_cst_node
= make_node (INTEGER_CST
);
586 cl_option_hash_table
= htab_create_ggc (64, cl_option_hash_hash
,
587 cl_option_hash_eq
, NULL
);
589 cl_optimization_node
= make_node (OPTIMIZATION_NODE
);
590 cl_target_option_node
= make_node (TARGET_OPTION_NODE
);
592 /* Initialize the tree_contains_struct array. */
593 initialize_tree_contains_struct ();
594 lang_hooks
.init_ts ();
598 /* The name of the object as the assembler will see it (but before any
599 translations made by ASM_OUTPUT_LABELREF). Often this is the same
600 as DECL_NAME. It is an IDENTIFIER_NODE. */
602 decl_assembler_name (tree decl
)
604 if (!DECL_ASSEMBLER_NAME_SET_P (decl
))
605 lang_hooks
.set_decl_assembler_name (decl
);
606 return DECL_WITH_VIS_CHECK (decl
)->decl_with_vis
.assembler_name
;
609 /* Compute the number of bytes occupied by a tree with code CODE.
610 This function cannot be used for nodes that have variable sizes,
611 including TREE_VEC, STRING_CST, and CALL_EXPR. */
613 tree_code_size (enum tree_code code
)
615 switch (TREE_CODE_CLASS (code
))
617 case tcc_declaration
: /* A decl node */
622 return sizeof (struct tree_field_decl
);
624 return sizeof (struct tree_parm_decl
);
626 return sizeof (struct tree_var_decl
);
628 return sizeof (struct tree_label_decl
);
630 return sizeof (struct tree_result_decl
);
632 return sizeof (struct tree_const_decl
);
634 return sizeof (struct tree_type_decl
);
636 return sizeof (struct tree_function_decl
);
637 case DEBUG_EXPR_DECL
:
638 return sizeof (struct tree_decl_with_rtl
);
640 return sizeof (struct tree_decl_non_common
);
644 case tcc_type
: /* a type node */
645 return sizeof (struct tree_type_non_common
);
647 case tcc_reference
: /* a reference */
648 case tcc_expression
: /* an expression */
649 case tcc_statement
: /* an expression with side effects */
650 case tcc_comparison
: /* a comparison expression */
651 case tcc_unary
: /* a unary arithmetic expression */
652 case tcc_binary
: /* a binary arithmetic expression */
653 return (sizeof (struct tree_exp
)
654 + (TREE_CODE_LENGTH (code
) - 1) * sizeof (tree
));
656 case tcc_constant
: /* a constant */
659 case INTEGER_CST
: return sizeof (struct tree_int_cst
);
660 case REAL_CST
: return sizeof (struct tree_real_cst
);
661 case FIXED_CST
: return sizeof (struct tree_fixed_cst
);
662 case COMPLEX_CST
: return sizeof (struct tree_complex
);
663 case VECTOR_CST
: return sizeof (struct tree_vector
);
664 case STRING_CST
: gcc_unreachable ();
666 return lang_hooks
.tree_size (code
);
669 case tcc_exceptional
: /* something random, like an identifier. */
672 case IDENTIFIER_NODE
: return lang_hooks
.identifier_size
;
673 case TREE_LIST
: return sizeof (struct tree_list
);
676 case PLACEHOLDER_EXPR
: return sizeof (struct tree_common
);
679 case OMP_CLAUSE
: gcc_unreachable ();
681 case SSA_NAME
: return sizeof (struct tree_ssa_name
);
683 case STATEMENT_LIST
: return sizeof (struct tree_statement_list
);
684 case BLOCK
: return sizeof (struct tree_block
);
685 case CONSTRUCTOR
: return sizeof (struct tree_constructor
);
686 case OPTIMIZATION_NODE
: return sizeof (struct tree_optimization_option
);
687 case TARGET_OPTION_NODE
: return sizeof (struct tree_target_option
);
690 return lang_hooks
.tree_size (code
);
698 /* Compute the number of bytes occupied by NODE. This routine only
699 looks at TREE_CODE, except for those nodes that have variable sizes. */
701 tree_size (const_tree node
)
703 const enum tree_code code
= TREE_CODE (node
);
707 return (offsetof (struct tree_binfo
, base_binfos
)
709 ::embedded_size (BINFO_N_BASE_BINFOS (node
)));
712 return (sizeof (struct tree_vec
)
713 + (TREE_VEC_LENGTH (node
) - 1) * sizeof (tree
));
716 return (sizeof (struct tree_vector
)
717 + (TYPE_VECTOR_SUBPARTS (TREE_TYPE (node
)) - 1) * sizeof (tree
));
720 return TREE_STRING_LENGTH (node
) + offsetof (struct tree_string
, str
) + 1;
723 return (sizeof (struct tree_omp_clause
)
724 + (omp_clause_num_ops
[OMP_CLAUSE_CODE (node
)] - 1)
728 if (TREE_CODE_CLASS (code
) == tcc_vl_exp
)
729 return (sizeof (struct tree_exp
)
730 + (VL_EXP_OPERAND_LENGTH (node
) - 1) * sizeof (tree
));
732 return tree_code_size (code
);
736 /* Record interesting allocation statistics for a tree node with CODE
740 record_node_allocation_statistics (enum tree_code code ATTRIBUTE_UNUSED
,
741 size_t length ATTRIBUTE_UNUSED
)
743 enum tree_code_class type
= TREE_CODE_CLASS (code
);
746 if (!GATHER_STATISTICS
)
751 case tcc_declaration
: /* A decl node */
755 case tcc_type
: /* a type node */
759 case tcc_statement
: /* an expression with side effects */
763 case tcc_reference
: /* a reference */
767 case tcc_expression
: /* an expression */
768 case tcc_comparison
: /* a comparison expression */
769 case tcc_unary
: /* a unary arithmetic expression */
770 case tcc_binary
: /* a binary arithmetic expression */
774 case tcc_constant
: /* a constant */
778 case tcc_exceptional
: /* something random, like an identifier. */
781 case IDENTIFIER_NODE
:
794 kind
= ssa_name_kind
;
806 kind
= omp_clause_kind
;
823 tree_code_counts
[(int) code
]++;
824 tree_node_counts
[(int) kind
]++;
825 tree_node_sizes
[(int) kind
] += length
;
828 /* Allocate and return a new UID from the DECL_UID namespace. */
831 allocate_decl_uid (void)
833 return next_decl_uid
++;
836 /* Return a newly allocated node of code CODE. For decl and type
837 nodes, some other fields are initialized. The rest of the node is
838 initialized to zero. This function cannot be used for TREE_VEC or
839 OMP_CLAUSE nodes, which is enforced by asserts in tree_code_size.
841 Achoo! I got a code in the node. */
844 make_node_stat (enum tree_code code MEM_STAT_DECL
)
847 enum tree_code_class type
= TREE_CODE_CLASS (code
);
848 size_t length
= tree_code_size (code
);
850 record_node_allocation_statistics (code
, length
);
852 t
= ggc_alloc_cleared_tree_node_stat (length PASS_MEM_STAT
);
853 TREE_SET_CODE (t
, code
);
858 TREE_SIDE_EFFECTS (t
) = 1;
861 case tcc_declaration
:
862 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_COMMON
))
864 if (code
== FUNCTION_DECL
)
866 DECL_ALIGN (t
) = FUNCTION_BOUNDARY
;
867 DECL_MODE (t
) = FUNCTION_MODE
;
872 DECL_SOURCE_LOCATION (t
) = input_location
;
873 if (TREE_CODE (t
) == DEBUG_EXPR_DECL
)
874 DECL_UID (t
) = --next_debug_decl_uid
;
877 DECL_UID (t
) = allocate_decl_uid ();
878 SET_DECL_PT_UID (t
, -1);
880 if (TREE_CODE (t
) == LABEL_DECL
)
881 LABEL_DECL_UID (t
) = -1;
886 TYPE_UID (t
) = next_type_uid
++;
887 TYPE_ALIGN (t
) = BITS_PER_UNIT
;
888 TYPE_USER_ALIGN (t
) = 0;
889 TYPE_MAIN_VARIANT (t
) = t
;
890 TYPE_CANONICAL (t
) = t
;
892 /* Default to no attributes for type, but let target change that. */
893 TYPE_ATTRIBUTES (t
) = NULL_TREE
;
894 targetm
.set_default_type_attributes (t
);
896 /* We have not yet computed the alias set for this type. */
897 TYPE_ALIAS_SET (t
) = -1;
901 TREE_CONSTANT (t
) = 1;
910 case PREDECREMENT_EXPR
:
911 case PREINCREMENT_EXPR
:
912 case POSTDECREMENT_EXPR
:
913 case POSTINCREMENT_EXPR
:
914 /* All of these have side-effects, no matter what their
916 TREE_SIDE_EFFECTS (t
) = 1;
925 /* Other classes need no special treatment. */
932 /* Return a new node with the same contents as NODE except that its
933 TREE_CHAIN, if it has one, is zero and it has a fresh uid. */
936 copy_node_stat (tree node MEM_STAT_DECL
)
939 enum tree_code code
= TREE_CODE (node
);
942 gcc_assert (code
!= STATEMENT_LIST
);
944 length
= tree_size (node
);
945 record_node_allocation_statistics (code
, length
);
946 t
= ggc_alloc_tree_node_stat (length PASS_MEM_STAT
);
947 memcpy (t
, node
, length
);
949 if (CODE_CONTAINS_STRUCT (code
, TS_COMMON
))
951 TREE_ASM_WRITTEN (t
) = 0;
952 TREE_VISITED (t
) = 0;
954 if (TREE_CODE_CLASS (code
) == tcc_declaration
)
956 if (code
== DEBUG_EXPR_DECL
)
957 DECL_UID (t
) = --next_debug_decl_uid
;
960 DECL_UID (t
) = allocate_decl_uid ();
961 if (DECL_PT_UID_SET_P (node
))
962 SET_DECL_PT_UID (t
, DECL_PT_UID (node
));
964 if ((TREE_CODE (node
) == PARM_DECL
|| TREE_CODE (node
) == VAR_DECL
)
965 && DECL_HAS_VALUE_EXPR_P (node
))
967 SET_DECL_VALUE_EXPR (t
, DECL_VALUE_EXPR (node
));
968 DECL_HAS_VALUE_EXPR_P (t
) = 1;
970 /* DECL_DEBUG_EXPR is copied explicitely by callers. */
971 if (TREE_CODE (node
) == VAR_DECL
)
972 DECL_HAS_DEBUG_EXPR_P (t
) = 0;
973 if (TREE_CODE (node
) == VAR_DECL
&& DECL_HAS_INIT_PRIORITY_P (node
))
975 SET_DECL_INIT_PRIORITY (t
, DECL_INIT_PRIORITY (node
));
976 DECL_HAS_INIT_PRIORITY_P (t
) = 1;
978 if (TREE_CODE (node
) == FUNCTION_DECL
)
979 DECL_STRUCT_FUNCTION (t
) = NULL
;
981 else if (TREE_CODE_CLASS (code
) == tcc_type
)
983 TYPE_UID (t
) = next_type_uid
++;
984 /* The following is so that the debug code for
985 the copy is different from the original type.
986 The two statements usually duplicate each other
987 (because they clear fields of the same union),
988 but the optimizer should catch that. */
989 TYPE_SYMTAB_POINTER (t
) = 0;
990 TYPE_SYMTAB_ADDRESS (t
) = 0;
992 /* Do not copy the values cache. */
993 if (TYPE_CACHED_VALUES_P (t
))
995 TYPE_CACHED_VALUES_P (t
) = 0;
996 TYPE_CACHED_VALUES (t
) = NULL_TREE
;
999 if (TYPE_HAS_UPC_BLOCK_FACTOR (node
))
1000 SET_TYPE_UPC_BLOCK_FACTOR (t
, TYPE_UPC_BLOCK_FACTOR (node
));
1006 /* Return a copy of a chain of nodes, chained through the TREE_CHAIN field.
1007 For example, this can copy a list made of TREE_LIST nodes. */
1010 copy_list (tree list
)
1018 head
= prev
= copy_node (list
);
1019 next
= TREE_CHAIN (list
);
1022 TREE_CHAIN (prev
) = copy_node (next
);
1023 prev
= TREE_CHAIN (prev
);
1024 next
= TREE_CHAIN (next
);
1030 /* Create an INT_CST node with a LOW value sign extended to TYPE. */
1033 build_int_cst (tree type
, HOST_WIDE_INT low
)
1035 /* Support legacy code. */
1037 type
= integer_type_node
;
1039 return double_int_to_tree (type
, double_int::from_shwi (low
));
1042 /* Create an INT_CST node with a LOW value sign extended to TYPE. */
1045 build_int_cst_type (tree type
, HOST_WIDE_INT low
)
1049 return double_int_to_tree (type
, double_int::from_shwi (low
));
1052 /* Constructs tree in type TYPE from with value given by CST. Signedness
1053 of CST is assumed to be the same as the signedness of TYPE. */
1056 double_int_to_tree (tree type
, double_int cst
)
1058 bool sign_extended_type
= !TYPE_UNSIGNED (type
);
1060 cst
= cst
.ext (TYPE_PRECISION (type
), !sign_extended_type
);
1062 return build_int_cst_wide (type
, cst
.low
, cst
.high
);
1065 /* Returns true if CST fits into range of TYPE. Signedness of CST is assumed
1066 to be the same as the signedness of TYPE. */
1069 double_int_fits_to_tree_p (const_tree type
, double_int cst
)
1071 bool sign_extended_type
= !TYPE_UNSIGNED (type
);
1074 = cst
.ext (TYPE_PRECISION (type
), !sign_extended_type
);
1079 /* We force the double_int CST to the range of the type TYPE by sign or
1080 zero extending it. OVERFLOWABLE indicates if we are interested in
1081 overflow of the value, when >0 we are only interested in signed
1082 overflow, for <0 we are interested in any overflow. OVERFLOWED
1083 indicates whether overflow has already occurred. CONST_OVERFLOWED
1084 indicates whether constant overflow has already occurred. We force
1085 T's value to be within range of T's type (by setting to 0 or 1 all
1086 the bits outside the type's range). We set TREE_OVERFLOWED if,
1087 OVERFLOWED is nonzero,
1088 or OVERFLOWABLE is >0 and signed overflow occurs
1089 or OVERFLOWABLE is <0 and any overflow occurs
1090 We return a new tree node for the extended double_int. The node
1091 is shared if no overflow flags are set. */
1095 force_fit_type_double (tree type
, double_int cst
, int overflowable
,
1098 bool sign_extended_type
= !TYPE_UNSIGNED (type
);
1100 /* If we need to set overflow flags, return a new unshared node. */
1101 if (overflowed
|| !double_int_fits_to_tree_p (type
, cst
))
1105 || (overflowable
> 0 && sign_extended_type
))
1107 tree t
= make_node (INTEGER_CST
);
1109 = cst
.ext (TYPE_PRECISION (type
), !sign_extended_type
);
1110 TREE_TYPE (t
) = type
;
1111 TREE_OVERFLOW (t
) = 1;
1116 /* Else build a shared node. */
1117 return double_int_to_tree (type
, cst
);
1120 /* These are the hash table functions for the hash table of INTEGER_CST
1121 nodes of a sizetype. */
1123 /* Return the hash code code X, an INTEGER_CST. */
1126 int_cst_hash_hash (const void *x
)
1128 const_tree
const t
= (const_tree
) x
;
1130 return (TREE_INT_CST_HIGH (t
) ^ TREE_INT_CST_LOW (t
)
1131 ^ htab_hash_pointer (TREE_TYPE (t
)));
1134 /* Return nonzero if the value represented by *X (an INTEGER_CST tree node)
1135 is the same as that given by *Y, which is the same. */
1138 int_cst_hash_eq (const void *x
, const void *y
)
1140 const_tree
const xt
= (const_tree
) x
;
1141 const_tree
const yt
= (const_tree
) y
;
1143 return (TREE_TYPE (xt
) == TREE_TYPE (yt
)
1144 && TREE_INT_CST_HIGH (xt
) == TREE_INT_CST_HIGH (yt
)
1145 && TREE_INT_CST_LOW (xt
) == TREE_INT_CST_LOW (yt
));
1148 /* Create an INT_CST node of TYPE and value HI:LOW.
1149 The returned node is always shared. For small integers we use a
1150 per-type vector cache, for larger ones we use a single hash table. */
1153 build_int_cst_wide (tree type
, unsigned HOST_WIDE_INT low
, HOST_WIDE_INT hi
)
1161 switch (TREE_CODE (type
))
1164 gcc_assert (hi
== 0 && low
== 0);
1168 case REFERENCE_TYPE
:
1169 /* Cache NULL pointer. */
1178 /* Cache false or true. */
1186 if (TYPE_UNSIGNED (type
))
1189 limit
= INTEGER_SHARE_LIMIT
;
1190 if (!hi
&& low
< (unsigned HOST_WIDE_INT
)INTEGER_SHARE_LIMIT
)
1196 limit
= INTEGER_SHARE_LIMIT
+ 1;
1197 if (!hi
&& low
< (unsigned HOST_WIDE_INT
)INTEGER_SHARE_LIMIT
)
1199 else if (hi
== -1 && low
== -(unsigned HOST_WIDE_INT
)1)
1213 /* Look for it in the type's vector of small shared ints. */
1214 if (!TYPE_CACHED_VALUES_P (type
))
1216 TYPE_CACHED_VALUES_P (type
) = 1;
1217 TYPE_CACHED_VALUES (type
) = make_tree_vec (limit
);
1220 t
= TREE_VEC_ELT (TYPE_CACHED_VALUES (type
), ix
);
1223 /* Make sure no one is clobbering the shared constant. */
1224 gcc_assert (TREE_TYPE (t
) == type
);
1225 gcc_assert (TREE_INT_CST_LOW (t
) == low
);
1226 gcc_assert (TREE_INT_CST_HIGH (t
) == hi
);
1230 /* Create a new shared int. */
1231 t
= make_node (INTEGER_CST
);
1233 TREE_INT_CST_LOW (t
) = low
;
1234 TREE_INT_CST_HIGH (t
) = hi
;
1235 TREE_TYPE (t
) = type
;
1237 TREE_VEC_ELT (TYPE_CACHED_VALUES (type
), ix
) = t
;
1242 /* Use the cache of larger shared ints. */
1245 TREE_INT_CST_LOW (int_cst_node
) = low
;
1246 TREE_INT_CST_HIGH (int_cst_node
) = hi
;
1247 TREE_TYPE (int_cst_node
) = type
;
1249 slot
= htab_find_slot (int_cst_hash_table
, int_cst_node
, INSERT
);
1253 /* Insert this one into the hash table. */
1256 /* Make a new node for next time round. */
1257 int_cst_node
= make_node (INTEGER_CST
);
1265 cache_integer_cst (tree t
)
1267 tree type
= TREE_TYPE (t
);
1268 HOST_WIDE_INT hi
= TREE_INT_CST_HIGH (t
);
1269 unsigned HOST_WIDE_INT low
= TREE_INT_CST_LOW (t
);
1273 gcc_assert (!TREE_OVERFLOW (t
));
1275 switch (TREE_CODE (type
))
1278 gcc_assert (hi
== 0 && low
== 0);
1282 case REFERENCE_TYPE
:
1283 /* Cache NULL pointer. */
1292 /* Cache false or true. */
1300 if (TYPE_UNSIGNED (type
))
1303 limit
= INTEGER_SHARE_LIMIT
;
1304 if (!hi
&& low
< (unsigned HOST_WIDE_INT
)INTEGER_SHARE_LIMIT
)
1310 limit
= INTEGER_SHARE_LIMIT
+ 1;
1311 if (!hi
&& low
< (unsigned HOST_WIDE_INT
)INTEGER_SHARE_LIMIT
)
1313 else if (hi
== -1 && low
== -(unsigned HOST_WIDE_INT
)1)
1327 /* Look for it in the type's vector of small shared ints. */
1328 if (!TYPE_CACHED_VALUES_P (type
))
1330 TYPE_CACHED_VALUES_P (type
) = 1;
1331 TYPE_CACHED_VALUES (type
) = make_tree_vec (limit
);
1334 gcc_assert (TREE_VEC_ELT (TYPE_CACHED_VALUES (type
), ix
) == NULL_TREE
);
1335 TREE_VEC_ELT (TYPE_CACHED_VALUES (type
), ix
) = t
;
1339 /* Use the cache of larger shared ints. */
1342 slot
= htab_find_slot (int_cst_hash_table
, t
, INSERT
);
1343 /* If there is already an entry for the number verify it's the
1347 gcc_assert (TREE_INT_CST_LOW ((tree
)*slot
) == low
1348 && TREE_INT_CST_HIGH ((tree
)*slot
) == hi
);
1351 /* Otherwise insert this one into the hash table. */
1357 /* Builds an integer constant in TYPE such that lowest BITS bits are ones
1358 and the rest are zeros. */
1361 build_low_bits_mask (tree type
, unsigned bits
)
1365 gcc_assert (bits
<= TYPE_PRECISION (type
));
1367 if (bits
== TYPE_PRECISION (type
)
1368 && !TYPE_UNSIGNED (type
))
1369 /* Sign extended all-ones mask. */
1370 mask
= double_int_minus_one
;
1372 mask
= double_int::mask (bits
);
1374 return build_int_cst_wide (type
, mask
.low
, mask
.high
);
1377 /* Checks that X is integer constant that can be expressed in (unsigned)
1378 HOST_WIDE_INT without loss of precision. */
1381 cst_and_fits_in_hwi (const_tree x
)
1383 if (TREE_CODE (x
) != INTEGER_CST
)
1386 if (TYPE_PRECISION (TREE_TYPE (x
)) > HOST_BITS_PER_WIDE_INT
)
1389 return (TREE_INT_CST_HIGH (x
) == 0
1390 || TREE_INT_CST_HIGH (x
) == -1);
1393 /* Build a newly constructed TREE_VEC node of length LEN. */
1396 make_vector_stat (unsigned len MEM_STAT_DECL
)
1399 unsigned length
= (len
- 1) * sizeof (tree
) + sizeof (struct tree_vector
);
1401 record_node_allocation_statistics (VECTOR_CST
, length
);
1403 t
= ggc_alloc_cleared_tree_node_stat (length PASS_MEM_STAT
);
1405 TREE_SET_CODE (t
, VECTOR_CST
);
1406 TREE_CONSTANT (t
) = 1;
1411 /* Return a new VECTOR_CST node whose type is TYPE and whose values
1412 are in a list pointed to by VALS. */
1415 build_vector_stat (tree type
, tree
*vals MEM_STAT_DECL
)
1419 tree v
= make_vector (TYPE_VECTOR_SUBPARTS (type
));
1420 TREE_TYPE (v
) = type
;
1422 /* Iterate through elements and check for overflow. */
1423 for (cnt
= 0; cnt
< TYPE_VECTOR_SUBPARTS (type
); ++cnt
)
1425 tree value
= vals
[cnt
];
1427 VECTOR_CST_ELT (v
, cnt
) = value
;
1429 /* Don't crash if we get an address constant. */
1430 if (!CONSTANT_CLASS_P (value
))
1433 over
|= TREE_OVERFLOW (value
);
1436 TREE_OVERFLOW (v
) = over
;
1440 /* Return a new VECTOR_CST node whose type is TYPE and whose values
1441 are extracted from V, a vector of CONSTRUCTOR_ELT. */
1444 build_vector_from_ctor (tree type
, vec
<constructor_elt
, va_gc
> *v
)
1446 tree
*vec
= XALLOCAVEC (tree
, TYPE_VECTOR_SUBPARTS (type
));
1447 unsigned HOST_WIDE_INT idx
;
1450 FOR_EACH_CONSTRUCTOR_VALUE (v
, idx
, value
)
1452 for (; idx
< TYPE_VECTOR_SUBPARTS (type
); ++idx
)
1453 vec
[idx
] = build_zero_cst (TREE_TYPE (type
));
1455 return build_vector (type
, vec
);
1458 /* Build a vector of type VECTYPE where all the elements are SCs. */
1460 build_vector_from_val (tree vectype
, tree sc
)
1462 int i
, nunits
= TYPE_VECTOR_SUBPARTS (vectype
);
1464 if (sc
== error_mark_node
)
1467 /* Verify that the vector type is suitable for SC. Note that there
1468 is some inconsistency in the type-system with respect to restrict
1469 qualifications of pointers. Vector types always have a main-variant
1470 element type and the qualification is applied to the vector-type.
1471 So TREE_TYPE (vector-type) does not return a properly qualified
1472 vector element-type. */
1473 gcc_checking_assert (types_compatible_p (TYPE_MAIN_VARIANT (TREE_TYPE (sc
)),
1474 TREE_TYPE (vectype
)));
1476 if (CONSTANT_CLASS_P (sc
))
1478 tree
*v
= XALLOCAVEC (tree
, nunits
);
1479 for (i
= 0; i
< nunits
; ++i
)
1481 return build_vector (vectype
, v
);
1485 vec
<constructor_elt
, va_gc
> *v
;
1486 vec_alloc (v
, nunits
);
1487 for (i
= 0; i
< nunits
; ++i
)
1488 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, sc
);
1489 return build_constructor (vectype
, v
);
1493 /* Return a new CONSTRUCTOR node whose type is TYPE and whose values
1494 are in the vec pointed to by VALS. */
1496 build_constructor (tree type
, vec
<constructor_elt
, va_gc
> *vals
)
1498 tree c
= make_node (CONSTRUCTOR
);
1500 constructor_elt
*elt
;
1501 bool constant_p
= true;
1502 bool side_effects_p
= false;
1504 TREE_TYPE (c
) = type
;
1505 CONSTRUCTOR_ELTS (c
) = vals
;
1507 FOR_EACH_VEC_SAFE_ELT (vals
, i
, elt
)
1509 /* Mostly ctors will have elts that don't have side-effects, so
1510 the usual case is to scan all the elements. Hence a single
1511 loop for both const and side effects, rather than one loop
1512 each (with early outs). */
1513 if (!TREE_CONSTANT (elt
->value
))
1515 if (TREE_SIDE_EFFECTS (elt
->value
))
1516 side_effects_p
= true;
1519 TREE_SIDE_EFFECTS (c
) = side_effects_p
;
1520 TREE_CONSTANT (c
) = constant_p
;
1525 /* Build a CONSTRUCTOR node made of a single initializer, with the specified
1528 build_constructor_single (tree type
, tree index
, tree value
)
1530 vec
<constructor_elt
, va_gc
> *v
;
1531 constructor_elt elt
= {index
, value
};
1534 v
->quick_push (elt
);
1536 return build_constructor (type
, v
);
1540 /* Return a new CONSTRUCTOR node whose type is TYPE and whose values
1541 are in a list pointed to by VALS. */
1543 build_constructor_from_list (tree type
, tree vals
)
1546 vec
<constructor_elt
, va_gc
> *v
= NULL
;
1550 vec_alloc (v
, list_length (vals
));
1551 for (t
= vals
; t
; t
= TREE_CHAIN (t
))
1552 CONSTRUCTOR_APPEND_ELT (v
, TREE_PURPOSE (t
), TREE_VALUE (t
));
1555 return build_constructor (type
, v
);
1558 /* Return a new CONSTRUCTOR node whose type is TYPE. NELTS is the number
1559 of elements, provided as index/value pairs. */
1562 build_constructor_va (tree type
, int nelts
, ...)
1564 vec
<constructor_elt
, va_gc
> *v
= NULL
;
1567 va_start (p
, nelts
);
1568 vec_alloc (v
, nelts
);
1571 tree index
= va_arg (p
, tree
);
1572 tree value
= va_arg (p
, tree
);
1573 CONSTRUCTOR_APPEND_ELT (v
, index
, value
);
1576 return build_constructor (type
, v
);
1579 /* Return a new FIXED_CST node whose type is TYPE and value is F. */
1582 build_fixed (tree type
, FIXED_VALUE_TYPE f
)
1585 FIXED_VALUE_TYPE
*fp
;
1587 v
= make_node (FIXED_CST
);
1588 fp
= ggc_alloc_fixed_value ();
1589 memcpy (fp
, &f
, sizeof (FIXED_VALUE_TYPE
));
1591 TREE_TYPE (v
) = type
;
1592 TREE_FIXED_CST_PTR (v
) = fp
;
1596 /* Return a new REAL_CST node whose type is TYPE and value is D. */
1599 build_real (tree type
, REAL_VALUE_TYPE d
)
1602 REAL_VALUE_TYPE
*dp
;
1605 /* ??? Used to check for overflow here via CHECK_FLOAT_TYPE.
1606 Consider doing it via real_convert now. */
1608 v
= make_node (REAL_CST
);
1609 dp
= ggc_alloc_real_value ();
1610 memcpy (dp
, &d
, sizeof (REAL_VALUE_TYPE
));
1612 TREE_TYPE (v
) = type
;
1613 TREE_REAL_CST_PTR (v
) = dp
;
1614 TREE_OVERFLOW (v
) = overflow
;
1618 /* Return a new REAL_CST node whose type is TYPE
1619 and whose value is the integer value of the INTEGER_CST node I. */
1622 real_value_from_int_cst (const_tree type
, const_tree i
)
1626 /* Clear all bits of the real value type so that we can later do
1627 bitwise comparisons to see if two values are the same. */
1628 memset (&d
, 0, sizeof d
);
1630 real_from_integer (&d
, type
? TYPE_MODE (type
) : VOIDmode
,
1631 TREE_INT_CST_LOW (i
), TREE_INT_CST_HIGH (i
),
1632 TYPE_UNSIGNED (TREE_TYPE (i
)));
1636 /* Given a tree representing an integer constant I, return a tree
1637 representing the same value as a floating-point constant of type TYPE. */
1640 build_real_from_int_cst (tree type
, const_tree i
)
1643 int overflow
= TREE_OVERFLOW (i
);
1645 v
= build_real (type
, real_value_from_int_cst (type
, i
));
1647 TREE_OVERFLOW (v
) |= overflow
;
1651 /* Return a newly constructed STRING_CST node whose value is
1652 the LEN characters at STR.
1653 Note that for a C string literal, LEN should include the trailing NUL.
1654 The TREE_TYPE is not initialized. */
1657 build_string (int len
, const char *str
)
1662 /* Do not waste bytes provided by padding of struct tree_string. */
1663 length
= len
+ offsetof (struct tree_string
, str
) + 1;
1665 record_node_allocation_statistics (STRING_CST
, length
);
1667 s
= ggc_alloc_tree_node (length
);
1669 memset (s
, 0, sizeof (struct tree_typed
));
1670 TREE_SET_CODE (s
, STRING_CST
);
1671 TREE_CONSTANT (s
) = 1;
1672 TREE_STRING_LENGTH (s
) = len
;
1673 memcpy (s
->string
.str
, str
, len
);
1674 s
->string
.str
[len
] = '\0';
1679 /* Return a newly constructed COMPLEX_CST node whose value is
1680 specified by the real and imaginary parts REAL and IMAG.
1681 Both REAL and IMAG should be constant nodes. TYPE, if specified,
1682 will be the type of the COMPLEX_CST; otherwise a new type will be made. */
1685 build_complex (tree type
, tree real
, tree imag
)
1687 tree t
= make_node (COMPLEX_CST
);
1689 TREE_REALPART (t
) = real
;
1690 TREE_IMAGPART (t
) = imag
;
1691 TREE_TYPE (t
) = type
? type
: build_complex_type (TREE_TYPE (real
));
1692 TREE_OVERFLOW (t
) = TREE_OVERFLOW (real
) | TREE_OVERFLOW (imag
);
1696 /* Return a constant of arithmetic type TYPE which is the
1697 multiplicative identity of the set TYPE. */
1700 build_one_cst (tree type
)
1702 switch (TREE_CODE (type
))
1704 case INTEGER_TYPE
: case ENUMERAL_TYPE
: case BOOLEAN_TYPE
:
1705 case POINTER_TYPE
: case REFERENCE_TYPE
:
1707 return build_int_cst (type
, 1);
1710 return build_real (type
, dconst1
);
1712 case FIXED_POINT_TYPE
:
1713 /* We can only generate 1 for accum types. */
1714 gcc_assert (ALL_SCALAR_ACCUM_MODE_P (TYPE_MODE (type
)));
1715 return build_fixed (type
, FCONST1 (TYPE_MODE (type
)));
1719 tree scalar
= build_one_cst (TREE_TYPE (type
));
1721 return build_vector_from_val (type
, scalar
);
1725 return build_complex (type
,
1726 build_one_cst (TREE_TYPE (type
)),
1727 build_zero_cst (TREE_TYPE (type
)));
1734 /* Return an integer of type TYPE containing all 1's in as much precision as
1735 it contains, or a complex or vector whose subparts are such integers. */
1738 build_all_ones_cst (tree type
)
1740 if (TREE_CODE (type
) == COMPLEX_TYPE
)
1742 tree scalar
= build_all_ones_cst (TREE_TYPE (type
));
1743 return build_complex (type
, scalar
, scalar
);
1746 return build_minus_one_cst (type
);
1749 /* Return a constant of arithmetic type TYPE which is the
1750 opposite of the multiplicative identity of the set TYPE. */
1753 build_minus_one_cst (tree type
)
1755 switch (TREE_CODE (type
))
1757 case INTEGER_TYPE
: case ENUMERAL_TYPE
: case BOOLEAN_TYPE
:
1758 case POINTER_TYPE
: case REFERENCE_TYPE
:
1760 return build_int_cst (type
, -1);
1763 return build_real (type
, dconstm1
);
1765 case FIXED_POINT_TYPE
:
1766 /* We can only generate 1 for accum types. */
1767 gcc_assert (ALL_SCALAR_ACCUM_MODE_P (TYPE_MODE (type
)));
1768 return build_fixed (type
, fixed_from_double_int (double_int_minus_one
,
1773 tree scalar
= build_minus_one_cst (TREE_TYPE (type
));
1775 return build_vector_from_val (type
, scalar
);
1779 return build_complex (type
,
1780 build_minus_one_cst (TREE_TYPE (type
)),
1781 build_zero_cst (TREE_TYPE (type
)));
1788 /* Build 0 constant of type TYPE. This is used by constructor folding
1789 and thus the constant should be represented in memory by
1793 build_zero_cst (tree type
)
1795 switch (TREE_CODE (type
))
1797 case INTEGER_TYPE
: case ENUMERAL_TYPE
: case BOOLEAN_TYPE
:
1798 case POINTER_TYPE
: case REFERENCE_TYPE
:
1799 case OFFSET_TYPE
: case NULLPTR_TYPE
:
1800 return build_int_cst (type
, 0);
1803 return build_real (type
, dconst0
);
1805 case FIXED_POINT_TYPE
:
1806 return build_fixed (type
, FCONST0 (TYPE_MODE (type
)));
1810 tree scalar
= build_zero_cst (TREE_TYPE (type
));
1812 return build_vector_from_val (type
, scalar
);
1817 tree zero
= build_zero_cst (TREE_TYPE (type
));
1819 return build_complex (type
, zero
, zero
);
1823 if (!AGGREGATE_TYPE_P (type
))
1824 return fold_convert (type
, integer_zero_node
);
1825 return build_constructor (type
, NULL
);
1830 /* Build a BINFO with LEN language slots. */
1833 make_tree_binfo_stat (unsigned base_binfos MEM_STAT_DECL
)
1836 size_t length
= (offsetof (struct tree_binfo
, base_binfos
)
1837 + vec
<tree
, va_gc
>::embedded_size (base_binfos
));
1839 record_node_allocation_statistics (TREE_BINFO
, length
);
1841 t
= ggc_alloc_tree_node_stat (length PASS_MEM_STAT
);
1843 memset (t
, 0, offsetof (struct tree_binfo
, base_binfos
));
1845 TREE_SET_CODE (t
, TREE_BINFO
);
1847 BINFO_BASE_BINFOS (t
)->embedded_init (base_binfos
);
1852 /* Create a CASE_LABEL_EXPR tree node and return it. */
1855 build_case_label (tree low_value
, tree high_value
, tree label_decl
)
1857 tree t
= make_node (CASE_LABEL_EXPR
);
1859 TREE_TYPE (t
) = void_type_node
;
1860 SET_EXPR_LOCATION (t
, DECL_SOURCE_LOCATION (label_decl
));
1862 CASE_LOW (t
) = low_value
;
1863 CASE_HIGH (t
) = high_value
;
1864 CASE_LABEL (t
) = label_decl
;
1865 CASE_CHAIN (t
) = NULL_TREE
;
1870 /* Build a newly constructed TREE_VEC node of length LEN. */
1873 make_tree_vec_stat (int len MEM_STAT_DECL
)
1876 int length
= (len
- 1) * sizeof (tree
) + sizeof (struct tree_vec
);
1878 record_node_allocation_statistics (TREE_VEC
, length
);
1880 t
= ggc_alloc_cleared_tree_node_stat (length PASS_MEM_STAT
);
1882 TREE_SET_CODE (t
, TREE_VEC
);
1883 TREE_VEC_LENGTH (t
) = len
;
1888 /* Grow a TREE_VEC node to new length LEN. */
1891 grow_tree_vec_stat (tree v
, int len MEM_STAT_DECL
)
1893 gcc_assert (TREE_CODE (v
) == TREE_VEC
);
1895 int oldlen
= TREE_VEC_LENGTH (v
);
1896 gcc_assert (len
> oldlen
);
1898 int oldlength
= (oldlen
- 1) * sizeof (tree
) + sizeof (struct tree_vec
);
1899 int length
= (len
- 1) * sizeof (tree
) + sizeof (struct tree_vec
);
1901 record_node_allocation_statistics (TREE_VEC
, length
- oldlength
);
1903 v
= (tree
) ggc_realloc_stat (v
, length PASS_MEM_STAT
);
1905 TREE_VEC_LENGTH (v
) = len
;
1910 /* Return 1 if EXPR is the integer constant zero or a complex constant
1914 integer_zerop (const_tree expr
)
1918 switch (TREE_CODE (expr
))
1921 return (TREE_INT_CST_LOW (expr
) == 0
1922 && TREE_INT_CST_HIGH (expr
) == 0);
1924 return (integer_zerop (TREE_REALPART (expr
))
1925 && integer_zerop (TREE_IMAGPART (expr
)));
1929 for (i
= 0; i
< VECTOR_CST_NELTS (expr
); ++i
)
1930 if (!integer_zerop (VECTOR_CST_ELT (expr
, i
)))
1939 /* Return 1 if EXPR is the integer constant one or the corresponding
1940 complex constant. */
1943 integer_onep (const_tree expr
)
1947 switch (TREE_CODE (expr
))
1950 return (TREE_INT_CST_LOW (expr
) == 1
1951 && TREE_INT_CST_HIGH (expr
) == 0);
1953 return (integer_onep (TREE_REALPART (expr
))
1954 && integer_zerop (TREE_IMAGPART (expr
)));
1958 for (i
= 0; i
< VECTOR_CST_NELTS (expr
); ++i
)
1959 if (!integer_onep (VECTOR_CST_ELT (expr
, i
)))
1968 /* Return 1 if EXPR is an integer containing all 1's in as much precision as
1969 it contains, or a complex or vector whose subparts are such integers. */
1972 integer_all_onesp (const_tree expr
)
1979 if (TREE_CODE (expr
) == COMPLEX_CST
1980 && integer_all_onesp (TREE_REALPART (expr
))
1981 && integer_all_onesp (TREE_IMAGPART (expr
)))
1984 else if (TREE_CODE (expr
) == VECTOR_CST
)
1987 for (i
= 0; i
< VECTOR_CST_NELTS (expr
); ++i
)
1988 if (!integer_all_onesp (VECTOR_CST_ELT (expr
, i
)))
1993 else if (TREE_CODE (expr
) != INTEGER_CST
)
1996 uns
= TYPE_UNSIGNED (TREE_TYPE (expr
));
1997 if (TREE_INT_CST_LOW (expr
) == ~(unsigned HOST_WIDE_INT
) 0
1998 && TREE_INT_CST_HIGH (expr
) == -1)
2003 prec
= TYPE_PRECISION (TREE_TYPE (expr
));
2004 if (prec
>= HOST_BITS_PER_WIDE_INT
)
2006 HOST_WIDE_INT high_value
;
2009 shift_amount
= prec
- HOST_BITS_PER_WIDE_INT
;
2011 /* Can not handle precisions greater than twice the host int size. */
2012 gcc_assert (shift_amount
<= HOST_BITS_PER_WIDE_INT
);
2013 if (shift_amount
== HOST_BITS_PER_WIDE_INT
)
2014 /* Shifting by the host word size is undefined according to the ANSI
2015 standard, so we must handle this as a special case. */
2018 high_value
= ((HOST_WIDE_INT
) 1 << shift_amount
) - 1;
2020 return (TREE_INT_CST_LOW (expr
) == ~(unsigned HOST_WIDE_INT
) 0
2021 && TREE_INT_CST_HIGH (expr
) == high_value
);
2024 return TREE_INT_CST_LOW (expr
) == ((unsigned HOST_WIDE_INT
) 1 << prec
) - 1;
2027 /* Return 1 if EXPR is the integer constant minus one. */
2030 integer_minus_onep (const_tree expr
)
2034 if (TREE_CODE (expr
) == COMPLEX_CST
)
2035 return (integer_all_onesp (TREE_REALPART (expr
))
2036 && integer_zerop (TREE_IMAGPART (expr
)));
2038 return integer_all_onesp (expr
);
2041 /* Return 1 if EXPR is an integer constant that is a power of 2 (i.e., has only
2045 integer_pow2p (const_tree expr
)
2048 unsigned HOST_WIDE_INT high
, low
;
2052 if (TREE_CODE (expr
) == COMPLEX_CST
2053 && integer_pow2p (TREE_REALPART (expr
))
2054 && integer_zerop (TREE_IMAGPART (expr
)))
2057 if (TREE_CODE (expr
) != INTEGER_CST
)
2060 prec
= TYPE_PRECISION (TREE_TYPE (expr
));
2061 high
= TREE_INT_CST_HIGH (expr
);
2062 low
= TREE_INT_CST_LOW (expr
);
2064 /* First clear all bits that are beyond the type's precision in case
2065 we've been sign extended. */
2067 if (prec
== HOST_BITS_PER_DOUBLE_INT
)
2069 else if (prec
> HOST_BITS_PER_WIDE_INT
)
2070 high
&= ~(HOST_WIDE_INT_M1U
<< (prec
- HOST_BITS_PER_WIDE_INT
));
2074 if (prec
< HOST_BITS_PER_WIDE_INT
)
2075 low
&= ~(HOST_WIDE_INT_M1U
<< prec
);
2078 if (high
== 0 && low
== 0)
2081 return ((high
== 0 && (low
& (low
- 1)) == 0)
2082 || (low
== 0 && (high
& (high
- 1)) == 0));
2085 /* Return 1 if EXPR is an integer constant other than zero or a
2086 complex constant other than zero. */
2089 integer_nonzerop (const_tree expr
)
2093 return ((TREE_CODE (expr
) == INTEGER_CST
2094 && (TREE_INT_CST_LOW (expr
) != 0
2095 || TREE_INT_CST_HIGH (expr
) != 0))
2096 || (TREE_CODE (expr
) == COMPLEX_CST
2097 && (integer_nonzerop (TREE_REALPART (expr
))
2098 || integer_nonzerop (TREE_IMAGPART (expr
)))));
2101 /* Return 1 if EXPR is the fixed-point constant zero. */
2104 fixed_zerop (const_tree expr
)
2106 return (TREE_CODE (expr
) == FIXED_CST
2107 && TREE_FIXED_CST (expr
).data
.is_zero ());
2110 /* Return the power of two represented by a tree node known to be a
2114 tree_log2 (const_tree expr
)
2117 HOST_WIDE_INT high
, low
;
2121 if (TREE_CODE (expr
) == COMPLEX_CST
)
2122 return tree_log2 (TREE_REALPART (expr
));
2124 prec
= TYPE_PRECISION (TREE_TYPE (expr
));
2125 high
= TREE_INT_CST_HIGH (expr
);
2126 low
= TREE_INT_CST_LOW (expr
);
2128 /* First clear all bits that are beyond the type's precision in case
2129 we've been sign extended. */
2131 if (prec
== HOST_BITS_PER_DOUBLE_INT
)
2133 else if (prec
> HOST_BITS_PER_WIDE_INT
)
2134 high
&= ~(HOST_WIDE_INT_M1U
<< (prec
- HOST_BITS_PER_WIDE_INT
));
2138 if (prec
< HOST_BITS_PER_WIDE_INT
)
2139 low
&= ~(HOST_WIDE_INT_M1U
<< prec
);
2142 return (high
!= 0 ? HOST_BITS_PER_WIDE_INT
+ exact_log2 (high
)
2143 : exact_log2 (low
));
2146 /* Similar, but return the largest integer Y such that 2 ** Y is less
2147 than or equal to EXPR. */
2150 tree_floor_log2 (const_tree expr
)
2153 HOST_WIDE_INT high
, low
;
2157 if (TREE_CODE (expr
) == COMPLEX_CST
)
2158 return tree_log2 (TREE_REALPART (expr
));
2160 prec
= TYPE_PRECISION (TREE_TYPE (expr
));
2161 high
= TREE_INT_CST_HIGH (expr
);
2162 low
= TREE_INT_CST_LOW (expr
);
2164 /* First clear all bits that are beyond the type's precision in case
2165 we've been sign extended. Ignore if type's precision hasn't been set
2166 since what we are doing is setting it. */
2168 if (prec
== HOST_BITS_PER_DOUBLE_INT
|| prec
== 0)
2170 else if (prec
> HOST_BITS_PER_WIDE_INT
)
2171 high
&= ~(HOST_WIDE_INT_M1U
<< (prec
- HOST_BITS_PER_WIDE_INT
));
2175 if (prec
< HOST_BITS_PER_WIDE_INT
)
2176 low
&= ~(HOST_WIDE_INT_M1U
<< prec
);
2179 return (high
!= 0 ? HOST_BITS_PER_WIDE_INT
+ floor_log2 (high
)
2180 : floor_log2 (low
));
2183 /* Return number of known trailing zero bits in EXPR, or, if the value of
2184 EXPR is known to be zero, the precision of it's type. */
2187 tree_ctz (const_tree expr
)
2189 if (!INTEGRAL_TYPE_P (TREE_TYPE (expr
))
2190 && !POINTER_TYPE_P (TREE_TYPE (expr
)))
2193 unsigned int ret1
, ret2
, prec
= TYPE_PRECISION (TREE_TYPE (expr
));
2194 switch (TREE_CODE (expr
))
2197 ret1
= tree_to_double_int (expr
).trailing_zeros ();
2198 return MIN (ret1
, prec
);
2200 ret1
= get_nonzero_bits (expr
).trailing_zeros ();
2201 return MIN (ret1
, prec
);
2208 ret1
= tree_ctz (TREE_OPERAND (expr
, 0));
2211 ret2
= tree_ctz (TREE_OPERAND (expr
, 1));
2212 return MIN (ret1
, ret2
);
2213 case POINTER_PLUS_EXPR
:
2214 ret1
= tree_ctz (TREE_OPERAND (expr
, 0));
2215 ret2
= tree_ctz (TREE_OPERAND (expr
, 1));
2216 /* Second operand is sizetype, which could be in theory
2217 wider than pointer's precision. Make sure we never
2218 return more than prec. */
2219 ret2
= MIN (ret2
, prec
);
2220 return MIN (ret1
, ret2
);
2222 ret1
= tree_ctz (TREE_OPERAND (expr
, 0));
2223 ret2
= tree_ctz (TREE_OPERAND (expr
, 1));
2224 return MAX (ret1
, ret2
);
2226 ret1
= tree_ctz (TREE_OPERAND (expr
, 0));
2227 ret2
= tree_ctz (TREE_OPERAND (expr
, 1));
2228 return MIN (ret1
+ ret2
, prec
);
2230 ret1
= tree_ctz (TREE_OPERAND (expr
, 0));
2231 if (tree_fits_uhwi_p (TREE_OPERAND (expr
, 1))
2232 && (tree_to_uhwi (TREE_OPERAND (expr
, 1)) < prec
))
2234 ret2
= tree_to_uhwi (TREE_OPERAND (expr
, 1));
2235 return MIN (ret1
+ ret2
, prec
);
2239 if (tree_fits_uhwi_p (TREE_OPERAND (expr
, 1))
2240 && (tree_to_uhwi (TREE_OPERAND (expr
, 1)) < prec
))
2242 ret1
= tree_ctz (TREE_OPERAND (expr
, 0));
2243 ret2
= tree_to_uhwi (TREE_OPERAND (expr
, 1));
2248 case TRUNC_DIV_EXPR
:
2250 case FLOOR_DIV_EXPR
:
2251 case ROUND_DIV_EXPR
:
2252 case EXACT_DIV_EXPR
:
2253 if (TREE_CODE (TREE_OPERAND (expr
, 1)) == INTEGER_CST
2254 && tree_int_cst_sgn (TREE_OPERAND (expr
, 1)) == 1)
2256 int l
= tree_log2 (TREE_OPERAND (expr
, 1));
2259 ret1
= tree_ctz (TREE_OPERAND (expr
, 0));
2267 ret1
= tree_ctz (TREE_OPERAND (expr
, 0));
2268 if (ret1
&& ret1
== TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (expr
, 0))))
2270 return MIN (ret1
, prec
);
2272 return tree_ctz (TREE_OPERAND (expr
, 0));
2274 ret1
= tree_ctz (TREE_OPERAND (expr
, 1));
2277 ret2
= tree_ctz (TREE_OPERAND (expr
, 2));
2278 return MIN (ret1
, ret2
);
2280 return tree_ctz (TREE_OPERAND (expr
, 1));
2282 ret1
= get_pointer_alignment (CONST_CAST_TREE (expr
));
2283 if (ret1
> BITS_PER_UNIT
)
2285 ret1
= ctz_hwi (ret1
/ BITS_PER_UNIT
);
2286 return MIN (ret1
, prec
);
2294 /* Return 1 if EXPR is the real constant zero. Trailing zeroes matter for
2295 decimal float constants, so don't return 1 for them. */
2298 real_zerop (const_tree expr
)
2302 switch (TREE_CODE (expr
))
2305 return REAL_VALUES_EQUAL (TREE_REAL_CST (expr
), dconst0
)
2306 && !(DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (expr
))));
2308 return real_zerop (TREE_REALPART (expr
))
2309 && real_zerop (TREE_IMAGPART (expr
));
2313 for (i
= 0; i
< VECTOR_CST_NELTS (expr
); ++i
)
2314 if (!real_zerop (VECTOR_CST_ELT (expr
, i
)))
2323 /* Return 1 if EXPR is the real constant one in real or complex form.
2324 Trailing zeroes matter for decimal float constants, so don't return
2328 real_onep (const_tree expr
)
2332 switch (TREE_CODE (expr
))
2335 return REAL_VALUES_EQUAL (TREE_REAL_CST (expr
), dconst1
)
2336 && !(DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (expr
))));
2338 return real_onep (TREE_REALPART (expr
))
2339 && real_zerop (TREE_IMAGPART (expr
));
2343 for (i
= 0; i
< VECTOR_CST_NELTS (expr
); ++i
)
2344 if (!real_onep (VECTOR_CST_ELT (expr
, i
)))
2353 /* Return 1 if EXPR is the real constant minus one. Trailing zeroes
2354 matter for decimal float constants, so don't return 1 for them. */
2357 real_minus_onep (const_tree expr
)
2361 switch (TREE_CODE (expr
))
2364 return REAL_VALUES_EQUAL (TREE_REAL_CST (expr
), dconstm1
)
2365 && !(DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (expr
))));
2367 return real_minus_onep (TREE_REALPART (expr
))
2368 && real_zerop (TREE_IMAGPART (expr
));
2372 for (i
= 0; i
< VECTOR_CST_NELTS (expr
); ++i
)
2373 if (!real_minus_onep (VECTOR_CST_ELT (expr
, i
)))
2382 /* Nonzero if EXP is a constant or a cast of a constant. */
2385 really_constant_p (const_tree exp
)
2387 /* This is not quite the same as STRIP_NOPS. It does more. */
2388 while (CONVERT_EXPR_P (exp
)
2389 || TREE_CODE (exp
) == NON_LVALUE_EXPR
)
2390 exp
= TREE_OPERAND (exp
, 0);
2391 return TREE_CONSTANT (exp
);
2394 /* Return first list element whose TREE_VALUE is ELEM.
2395 Return 0 if ELEM is not in LIST. */
2398 value_member (tree elem
, tree list
)
2402 if (elem
== TREE_VALUE (list
))
2404 list
= TREE_CHAIN (list
);
2409 /* Return first list element whose TREE_PURPOSE is ELEM.
2410 Return 0 if ELEM is not in LIST. */
2413 purpose_member (const_tree elem
, tree list
)
2417 if (elem
== TREE_PURPOSE (list
))
2419 list
= TREE_CHAIN (list
);
2424 /* Return true if ELEM is in V. */
2427 vec_member (const_tree elem
, vec
<tree
, va_gc
> *v
)
2431 FOR_EACH_VEC_SAFE_ELT (v
, ix
, t
)
2437 /* Returns element number IDX (zero-origin) of chain CHAIN, or
2441 chain_index (int idx
, tree chain
)
2443 for (; chain
&& idx
> 0; --idx
)
2444 chain
= TREE_CHAIN (chain
);
2448 /* Return nonzero if ELEM is part of the chain CHAIN. */
2451 chain_member (const_tree elem
, const_tree chain
)
2457 chain
= DECL_CHAIN (chain
);
2463 /* Return the length of a chain of nodes chained through TREE_CHAIN.
2464 We expect a null pointer to mark the end of the chain.
2465 This is the Lisp primitive `length'. */
2468 list_length (const_tree t
)
2471 #ifdef ENABLE_TREE_CHECKING
2479 #ifdef ENABLE_TREE_CHECKING
2482 gcc_assert (p
!= q
);
2490 /* Returns the first FIELD_DECL in the TYPE_FIELDS of the RECORD_TYPE or
2491 UNION_TYPE TYPE, or NULL_TREE if none. */
2494 first_field (const_tree type
)
2496 tree t
= TYPE_FIELDS (type
);
2497 while (t
&& TREE_CODE (t
) != FIELD_DECL
)
2502 /* Concatenate two chains of nodes (chained through TREE_CHAIN)
2503 by modifying the last node in chain 1 to point to chain 2.
2504 This is the Lisp primitive `nconc'. */
2507 chainon (tree op1
, tree op2
)
2516 for (t1
= op1
; TREE_CHAIN (t1
); t1
= TREE_CHAIN (t1
))
2518 TREE_CHAIN (t1
) = op2
;
2520 #ifdef ENABLE_TREE_CHECKING
2523 for (t2
= op2
; t2
; t2
= TREE_CHAIN (t2
))
2524 gcc_assert (t2
!= t1
);
2531 /* Return the last node in a chain of nodes (chained through TREE_CHAIN). */
2534 tree_last (tree chain
)
2538 while ((next
= TREE_CHAIN (chain
)))
2543 /* Reverse the order of elements in the chain T,
2544 and return the new head of the chain (old last element). */
2549 tree prev
= 0, decl
, next
;
2550 for (decl
= t
; decl
; decl
= next
)
2552 /* We shouldn't be using this function to reverse BLOCK chains; we
2553 have blocks_nreverse for that. */
2554 gcc_checking_assert (TREE_CODE (decl
) != BLOCK
);
2555 next
= TREE_CHAIN (decl
);
2556 TREE_CHAIN (decl
) = prev
;
2562 /* Return a newly created TREE_LIST node whose
2563 purpose and value fields are PARM and VALUE. */
2566 build_tree_list_stat (tree parm
, tree value MEM_STAT_DECL
)
2568 tree t
= make_node_stat (TREE_LIST PASS_MEM_STAT
);
2569 TREE_PURPOSE (t
) = parm
;
2570 TREE_VALUE (t
) = value
;
2574 /* Build a chain of TREE_LIST nodes from a vector. */
2577 build_tree_list_vec_stat (const vec
<tree
, va_gc
> *vec MEM_STAT_DECL
)
2579 tree ret
= NULL_TREE
;
2583 FOR_EACH_VEC_SAFE_ELT (vec
, i
, t
)
2585 *pp
= build_tree_list_stat (NULL
, t PASS_MEM_STAT
);
2586 pp
= &TREE_CHAIN (*pp
);
2591 /* Return a newly created TREE_LIST node whose
2592 purpose and value fields are PURPOSE and VALUE
2593 and whose TREE_CHAIN is CHAIN. */
2596 tree_cons_stat (tree purpose
, tree value
, tree chain MEM_STAT_DECL
)
2600 node
= ggc_alloc_tree_node_stat (sizeof (struct tree_list
) PASS_MEM_STAT
);
2601 memset (node
, 0, sizeof (struct tree_common
));
2603 record_node_allocation_statistics (TREE_LIST
, sizeof (struct tree_list
));
2605 TREE_SET_CODE (node
, TREE_LIST
);
2606 TREE_CHAIN (node
) = chain
;
2607 TREE_PURPOSE (node
) = purpose
;
2608 TREE_VALUE (node
) = value
;
2612 /* Return the values of the elements of a CONSTRUCTOR as a vector of
2616 ctor_to_vec (tree ctor
)
2618 vec
<tree
, va_gc
> *vec
;
2619 vec_alloc (vec
, CONSTRUCTOR_NELTS (ctor
));
2623 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (ctor
), ix
, val
)
2624 vec
->quick_push (val
);
2629 /* Return the size nominally occupied by an object of type TYPE
2630 when it resides in memory. The value is measured in units of bytes,
2631 and its data type is that normally used for type sizes
2632 (which is the first type created by make_signed_type or
2633 make_unsigned_type). */
2636 size_in_bytes (const_tree type
)
2640 if (type
== error_mark_node
)
2641 return integer_zero_node
;
2643 type
= TYPE_MAIN_VARIANT (type
);
2644 t
= TYPE_SIZE_UNIT (type
);
2648 lang_hooks
.types
.incomplete_type_error (NULL_TREE
, type
);
2649 return size_zero_node
;
2655 /* Returns a tree for the size of EXP in bytes. */
2658 tree_expr_size (const_tree exp
)
2661 && DECL_SIZE_UNIT (exp
) != 0)
2662 return DECL_SIZE_UNIT (exp
);
2664 return size_in_bytes (TREE_TYPE (exp
));
2667 /* Return the size of TYPE (in bytes) as a wide integer
2668 or return -1 if the size can vary or is larger than an integer. */
2671 int_size_in_bytes (const_tree type
)
2675 if (type
== error_mark_node
)
2678 type
= TYPE_MAIN_VARIANT (type
);
2679 t
= TYPE_SIZE_UNIT (type
);
2681 || TREE_CODE (t
) != INTEGER_CST
2682 || TREE_INT_CST_HIGH (t
) != 0
2683 /* If the result would appear negative, it's too big to represent. */
2684 || (HOST_WIDE_INT
) TREE_INT_CST_LOW (t
) < 0)
2687 return TREE_INT_CST_LOW (t
);
2690 /* Return the maximum size of TYPE (in bytes) as a wide integer
2691 or return -1 if the size can vary or is larger than an integer. */
2694 max_int_size_in_bytes (const_tree type
)
2696 HOST_WIDE_INT size
= -1;
2699 /* If this is an array type, check for a possible MAX_SIZE attached. */
2701 if (TREE_CODE (type
) == ARRAY_TYPE
)
2703 size_tree
= TYPE_ARRAY_MAX_SIZE (type
);
2705 if (size_tree
&& tree_fits_uhwi_p (size_tree
))
2706 size
= tree_to_uhwi (size_tree
);
2709 /* If we still haven't been able to get a size, see if the language
2710 can compute a maximum size. */
2714 size_tree
= lang_hooks
.types
.max_size (type
);
2716 if (size_tree
&& tree_fits_uhwi_p (size_tree
))
2717 size
= tree_to_uhwi (size_tree
);
2723 /* Return the bit position of FIELD, in bits from the start of the record.
2724 This is a tree of type bitsizetype. */
2727 bit_position (const_tree field
)
2729 return bit_from_pos (DECL_FIELD_OFFSET (field
),
2730 DECL_FIELD_BIT_OFFSET (field
));
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. */
2738 int_bit_position (const_tree field
)
2740 return tree_to_shwi (bit_position (field
));
2743 /* Return the byte position of FIELD, in bytes from the start of the record.
2744 This is a tree of type sizetype. */
2747 byte_position (const_tree field
)
2749 return byte_from_pos (DECL_FIELD_OFFSET (field
),
2750 DECL_FIELD_BIT_OFFSET (field
));
2753 /* Likewise, but return as an integer. It must be representable in
2754 that way (since it could be a signed value, we don't have the
2755 option of returning -1 like int_size_in_byte can. */
2758 int_byte_position (const_tree field
)
2760 return tree_to_shwi (byte_position (field
));
2763 /* Return the strictest alignment, in bits, that T is known to have. */
2766 expr_align (const_tree t
)
2768 unsigned int align0
, align1
;
2770 switch (TREE_CODE (t
))
2772 CASE_CONVERT
: case NON_LVALUE_EXPR
:
2773 /* If we have conversions, we know that the alignment of the
2774 object must meet each of the alignments of the types. */
2775 align0
= expr_align (TREE_OPERAND (t
, 0));
2776 align1
= TYPE_ALIGN (TREE_TYPE (t
));
2777 return MAX (align0
, align1
);
2779 case SAVE_EXPR
: case COMPOUND_EXPR
: case MODIFY_EXPR
:
2780 case INIT_EXPR
: case TARGET_EXPR
: case WITH_CLEANUP_EXPR
:
2781 case CLEANUP_POINT_EXPR
:
2782 /* These don't change the alignment of an object. */
2783 return expr_align (TREE_OPERAND (t
, 0));
2786 /* The best we can do is say that the alignment is the least aligned
2788 align0
= expr_align (TREE_OPERAND (t
, 1));
2789 align1
= expr_align (TREE_OPERAND (t
, 2));
2790 return MIN (align0
, align1
);
2792 /* FIXME: LABEL_DECL and CONST_DECL never have DECL_ALIGN set
2793 meaningfully, it's always 1. */
2794 case LABEL_DECL
: case CONST_DECL
:
2795 case VAR_DECL
: case PARM_DECL
: case RESULT_DECL
:
2797 gcc_assert (DECL_ALIGN (t
) != 0);
2798 return DECL_ALIGN (t
);
2804 /* Otherwise take the alignment from that of the type. */
2805 return TYPE_ALIGN (TREE_TYPE (t
));
2808 /* Return, as a tree node, the number of elements for TYPE (which is an
2809 ARRAY_TYPE) minus one. This counts only elements of the top array. */
2812 array_type_nelts (const_tree type
)
2814 tree index_type
, min
, max
;
2816 /* If they did it with unspecified bounds, then we should have already
2817 given an error about it before we got here. */
2818 if (! TYPE_DOMAIN (type
))
2819 return error_mark_node
;
2821 index_type
= TYPE_DOMAIN (type
);
2822 min
= TYPE_MIN_VALUE (index_type
);
2823 max
= TYPE_MAX_VALUE (index_type
);
2825 /* TYPE_MAX_VALUE may not be set if the array has unknown length. */
2827 return error_mark_node
;
2829 return (integer_zerop (min
)
2831 : fold_build2 (MINUS_EXPR
, TREE_TYPE (max
), max
, min
));
2834 /* If arg is static -- a reference to an object in static storage -- then
2835 return the object. This is not the same as the C meaning of `static'.
2836 If arg isn't static, return NULL. */
2841 switch (TREE_CODE (arg
))
2844 /* Nested functions are static, even though taking their address will
2845 involve a trampoline as we unnest the nested function and create
2846 the trampoline on the tree level. */
2850 return ((TREE_STATIC (arg
) || DECL_EXTERNAL (arg
))
2851 && ! DECL_THREAD_LOCAL_P (arg
)
2852 && ! DECL_DLLIMPORT_P (arg
)
2856 return ((TREE_STATIC (arg
) || DECL_EXTERNAL (arg
))
2860 return TREE_STATIC (arg
) ? arg
: NULL
;
2867 /* If the thing being referenced is not a field, then it is
2868 something language specific. */
2869 gcc_assert (TREE_CODE (TREE_OPERAND (arg
, 1)) == FIELD_DECL
);
2871 /* If we are referencing a bitfield, we can't evaluate an
2872 ADDR_EXPR at compile time and so it isn't a constant. */
2873 if (DECL_BIT_FIELD (TREE_OPERAND (arg
, 1)))
2876 return staticp (TREE_OPERAND (arg
, 0));
2882 return TREE_CONSTANT (TREE_OPERAND (arg
, 0)) ? arg
: NULL
;
2885 case ARRAY_RANGE_REF
:
2886 if (TREE_CODE (TYPE_SIZE (TREE_TYPE (arg
))) == INTEGER_CST
2887 && TREE_CODE (TREE_OPERAND (arg
, 1)) == INTEGER_CST
)
2888 return staticp (TREE_OPERAND (arg
, 0));
2892 case COMPOUND_LITERAL_EXPR
:
2893 return TREE_STATIC (COMPOUND_LITERAL_EXPR_DECL (arg
)) ? arg
: NULL
;
2903 /* Return whether OP is a DECL whose address is function-invariant. */
2906 decl_address_invariant_p (const_tree op
)
2908 /* The conditions below are slightly less strict than the one in
2911 switch (TREE_CODE (op
))
2920 if ((TREE_STATIC (op
) || DECL_EXTERNAL (op
))
2921 || DECL_THREAD_LOCAL_P (op
)
2922 || DECL_CONTEXT (op
) == current_function_decl
2923 || decl_function_context (op
) == current_function_decl
)
2928 if ((TREE_STATIC (op
) || DECL_EXTERNAL (op
))
2929 || decl_function_context (op
) == current_function_decl
)
2940 /* Return whether OP is a DECL whose address is interprocedural-invariant. */
2943 decl_address_ip_invariant_p (const_tree op
)
2945 /* The conditions below are slightly less strict than the one in
2948 switch (TREE_CODE (op
))
2956 if (((TREE_STATIC (op
) || DECL_EXTERNAL (op
))
2957 && !DECL_DLLIMPORT_P (op
))
2958 || DECL_THREAD_LOCAL_P (op
))
2963 if ((TREE_STATIC (op
) || DECL_EXTERNAL (op
)))
2975 /* Return true if T is function-invariant (internal function, does
2976 not handle arithmetic; that's handled in skip_simple_arithmetic and
2977 tree_invariant_p). */
2979 static bool tree_invariant_p (tree t
);
2982 tree_invariant_p_1 (tree t
)
2986 if (TREE_CONSTANT (t
)
2987 || (TREE_READONLY (t
) && !TREE_SIDE_EFFECTS (t
)))
2990 switch (TREE_CODE (t
))
2996 op
= TREE_OPERAND (t
, 0);
2997 while (handled_component_p (op
))
2999 switch (TREE_CODE (op
))
3002 case ARRAY_RANGE_REF
:
3003 if (!tree_invariant_p (TREE_OPERAND (op
, 1))
3004 || TREE_OPERAND (op
, 2) != NULL_TREE
3005 || TREE_OPERAND (op
, 3) != NULL_TREE
)
3010 if (TREE_OPERAND (op
, 2) != NULL_TREE
)
3016 op
= TREE_OPERAND (op
, 0);
3019 return CONSTANT_CLASS_P (op
) || decl_address_invariant_p (op
);
3028 /* Return true if T is function-invariant. */
3031 tree_invariant_p (tree t
)
3033 tree inner
= skip_simple_arithmetic (t
);
3034 return tree_invariant_p_1 (inner
);
3037 /* Wrap a SAVE_EXPR around EXPR, if appropriate.
3038 Do this to any expression which may be used in more than one place,
3039 but must be evaluated only once.
3041 Normally, expand_expr would reevaluate the expression each time.
3042 Calling save_expr produces something that is evaluated and recorded
3043 the first time expand_expr is called on it. Subsequent calls to
3044 expand_expr just reuse the recorded value.
3046 The call to expand_expr that generates code that actually computes
3047 the value is the first call *at compile time*. Subsequent calls
3048 *at compile time* generate code to use the saved value.
3049 This produces correct result provided that *at run time* control
3050 always flows through the insns made by the first expand_expr
3051 before reaching the other places where the save_expr was evaluated.
3052 You, the caller of save_expr, must make sure this is so.
3054 Constants, and certain read-only nodes, are returned with no
3055 SAVE_EXPR because that is safe. Expressions containing placeholders
3056 are not touched; see tree.def for an explanation of what these
3060 save_expr (tree expr
)
3062 tree t
= fold (expr
);
3065 /* If the tree evaluates to a constant, then we don't want to hide that
3066 fact (i.e. this allows further folding, and direct checks for constants).
3067 However, a read-only object that has side effects cannot be bypassed.
3068 Since it is no problem to reevaluate literals, we just return the
3070 inner
= skip_simple_arithmetic (t
);
3071 if (TREE_CODE (inner
) == ERROR_MARK
)
3074 if (tree_invariant_p_1 (inner
))
3077 /* If INNER contains a PLACEHOLDER_EXPR, we must evaluate it each time, since
3078 it means that the size or offset of some field of an object depends on
3079 the value within another field.
3081 Note that it must not be the case that T contains both a PLACEHOLDER_EXPR
3082 and some variable since it would then need to be both evaluated once and
3083 evaluated more than once. Front-ends must assure this case cannot
3084 happen by surrounding any such subexpressions in their own SAVE_EXPR
3085 and forcing evaluation at the proper time. */
3086 if (contains_placeholder_p (inner
))
3089 t
= build1 (SAVE_EXPR
, TREE_TYPE (expr
), t
);
3090 SET_EXPR_LOCATION (t
, EXPR_LOCATION (expr
));
3092 /* This expression might be placed ahead of a jump to ensure that the
3093 value was computed on both sides of the jump. So make sure it isn't
3094 eliminated as dead. */
3095 TREE_SIDE_EFFECTS (t
) = 1;
3099 /* Look inside EXPR into any simple arithmetic operations. Return the
3100 outermost non-arithmetic or non-invariant node. */
3103 skip_simple_arithmetic (tree expr
)
3105 /* We don't care about whether this can be used as an lvalue in this
3107 while (TREE_CODE (expr
) == NON_LVALUE_EXPR
)
3108 expr
= TREE_OPERAND (expr
, 0);
3110 /* If we have simple operations applied to a SAVE_EXPR or to a SAVE_EXPR and
3111 a constant, it will be more efficient to not make another SAVE_EXPR since
3112 it will allow better simplification and GCSE will be able to merge the
3113 computations if they actually occur. */
3116 if (UNARY_CLASS_P (expr
))
3117 expr
= TREE_OPERAND (expr
, 0);
3118 else if (BINARY_CLASS_P (expr
))
3120 if (tree_invariant_p (TREE_OPERAND (expr
, 1)))
3121 expr
= TREE_OPERAND (expr
, 0);
3122 else if (tree_invariant_p (TREE_OPERAND (expr
, 0)))
3123 expr
= TREE_OPERAND (expr
, 1);
3134 /* Look inside EXPR into simple arithmetic operations involving constants.
3135 Return the outermost non-arithmetic or non-constant node. */
3138 skip_simple_constant_arithmetic (tree expr
)
3140 while (TREE_CODE (expr
) == NON_LVALUE_EXPR
)
3141 expr
= TREE_OPERAND (expr
, 0);
3145 if (UNARY_CLASS_P (expr
))
3146 expr
= TREE_OPERAND (expr
, 0);
3147 else if (BINARY_CLASS_P (expr
))
3149 if (TREE_CONSTANT (TREE_OPERAND (expr
, 1)))
3150 expr
= TREE_OPERAND (expr
, 0);
3151 else if (TREE_CONSTANT (TREE_OPERAND (expr
, 0)))
3152 expr
= TREE_OPERAND (expr
, 1);
3163 /* Return which tree structure is used by T. */
3165 enum tree_node_structure_enum
3166 tree_node_structure (const_tree t
)
3168 const enum tree_code code
= TREE_CODE (t
);
3169 return tree_node_structure_for_code (code
);
3172 /* Set various status flags when building a CALL_EXPR object T. */
3175 process_call_operands (tree t
)
3177 bool side_effects
= TREE_SIDE_EFFECTS (t
);
3178 bool read_only
= false;
3179 int i
= call_expr_flags (t
);
3181 /* Calls have side-effects, except those to const or pure functions. */
3182 if ((i
& ECF_LOOPING_CONST_OR_PURE
) || !(i
& (ECF_CONST
| ECF_PURE
)))
3183 side_effects
= true;
3184 /* Propagate TREE_READONLY of arguments for const functions. */
3188 if (!side_effects
|| read_only
)
3189 for (i
= 1; i
< TREE_OPERAND_LENGTH (t
); i
++)
3191 tree op
= TREE_OPERAND (t
, i
);
3192 if (op
&& TREE_SIDE_EFFECTS (op
))
3193 side_effects
= true;
3194 if (op
&& !TREE_READONLY (op
) && !CONSTANT_CLASS_P (op
))
3198 TREE_SIDE_EFFECTS (t
) = side_effects
;
3199 TREE_READONLY (t
) = read_only
;
3202 /* Return true if EXP contains a PLACEHOLDER_EXPR, i.e. if it represents a
3203 size or offset that depends on a field within a record. */
3206 contains_placeholder_p (const_tree exp
)
3208 enum tree_code code
;
3213 code
= TREE_CODE (exp
);
3214 if (code
== PLACEHOLDER_EXPR
)
3217 switch (TREE_CODE_CLASS (code
))
3220 /* Don't look at any PLACEHOLDER_EXPRs that might be in index or bit
3221 position computations since they will be converted into a
3222 WITH_RECORD_EXPR involving the reference, which will assume
3223 here will be valid. */
3224 return CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp
, 0));
3226 case tcc_exceptional
:
3227 if (code
== TREE_LIST
)
3228 return (CONTAINS_PLACEHOLDER_P (TREE_VALUE (exp
))
3229 || CONTAINS_PLACEHOLDER_P (TREE_CHAIN (exp
)));
3234 case tcc_comparison
:
3235 case tcc_expression
:
3239 /* Ignoring the first operand isn't quite right, but works best. */
3240 return CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp
, 1));
3243 return (CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp
, 0))
3244 || CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp
, 1))
3245 || CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp
, 2)));
3248 /* The save_expr function never wraps anything containing
3249 a PLACEHOLDER_EXPR. */
3256 switch (TREE_CODE_LENGTH (code
))
3259 return CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp
, 0));
3261 return (CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp
, 0))
3262 || CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp
, 1)));
3273 const_call_expr_arg_iterator iter
;
3274 FOR_EACH_CONST_CALL_EXPR_ARG (arg
, iter
, exp
)
3275 if (CONTAINS_PLACEHOLDER_P (arg
))
3289 /* Return true if any part of the structure of TYPE involves a PLACEHOLDER_EXPR
3290 directly. This includes size, bounds, qualifiers (for QUAL_UNION_TYPE) and
3294 type_contains_placeholder_1 (const_tree type
)
3296 /* If the size contains a placeholder or the parent type (component type in
3297 the case of arrays) type involves a placeholder, this type does. */
3298 if (CONTAINS_PLACEHOLDER_P (TYPE_SIZE (type
))
3299 || CONTAINS_PLACEHOLDER_P (TYPE_SIZE_UNIT (type
))
3300 || (!POINTER_TYPE_P (type
)
3302 && type_contains_placeholder_p (TREE_TYPE (type
))))
3305 /* Now do type-specific checks. Note that the last part of the check above
3306 greatly limits what we have to do below. */
3307 switch (TREE_CODE (type
))
3315 case REFERENCE_TYPE
:
3324 case FIXED_POINT_TYPE
:
3325 /* Here we just check the bounds. */
3326 return (CONTAINS_PLACEHOLDER_P (TYPE_MIN_VALUE (type
))
3327 || CONTAINS_PLACEHOLDER_P (TYPE_MAX_VALUE (type
)));
3330 /* We have already checked the component type above, so just check the
3332 return type_contains_placeholder_p (TYPE_DOMAIN (type
));
3336 case QUAL_UNION_TYPE
:
3340 for (field
= TYPE_FIELDS (type
); field
; field
= DECL_CHAIN (field
))
3341 if (TREE_CODE (field
) == FIELD_DECL
3342 && (CONTAINS_PLACEHOLDER_P (DECL_FIELD_OFFSET (field
))
3343 || (TREE_CODE (type
) == QUAL_UNION_TYPE
3344 && CONTAINS_PLACEHOLDER_P (DECL_QUALIFIER (field
)))
3345 || type_contains_placeholder_p (TREE_TYPE (field
))))
3356 /* Wrapper around above function used to cache its result. */
3359 type_contains_placeholder_p (tree type
)
3363 /* If the contains_placeholder_bits field has been initialized,
3364 then we know the answer. */
3365 if (TYPE_CONTAINS_PLACEHOLDER_INTERNAL (type
) > 0)
3366 return TYPE_CONTAINS_PLACEHOLDER_INTERNAL (type
) - 1;
3368 /* Indicate that we've seen this type node, and the answer is false.
3369 This is what we want to return if we run into recursion via fields. */
3370 TYPE_CONTAINS_PLACEHOLDER_INTERNAL (type
) = 1;
3372 /* Compute the real value. */
3373 result
= type_contains_placeholder_1 (type
);
3375 /* Store the real value. */
3376 TYPE_CONTAINS_PLACEHOLDER_INTERNAL (type
) = result
+ 1;
3381 /* Push tree EXP onto vector QUEUE if it is not already present. */
3384 push_without_duplicates (tree exp
, vec
<tree
> *queue
)
3389 FOR_EACH_VEC_ELT (*queue
, i
, iter
)
3390 if (simple_cst_equal (iter
, exp
) == 1)
3394 queue
->safe_push (exp
);
3397 /* Given a tree EXP, find all occurrences of references to fields
3398 in a PLACEHOLDER_EXPR and place them in vector REFS without
3399 duplicates. Also record VAR_DECLs and CONST_DECLs. Note that
3400 we assume here that EXP contains only arithmetic expressions
3401 or CALL_EXPRs with PLACEHOLDER_EXPRs occurring only in their
3405 find_placeholder_in_expr (tree exp
, vec
<tree
> *refs
)
3407 enum tree_code code
= TREE_CODE (exp
);
3411 /* We handle TREE_LIST and COMPONENT_REF separately. */
3412 if (code
== TREE_LIST
)
3414 FIND_PLACEHOLDER_IN_EXPR (TREE_CHAIN (exp
), refs
);
3415 FIND_PLACEHOLDER_IN_EXPR (TREE_VALUE (exp
), refs
);
3417 else if (code
== COMPONENT_REF
)
3419 for (inner
= TREE_OPERAND (exp
, 0);
3420 REFERENCE_CLASS_P (inner
);
3421 inner
= TREE_OPERAND (inner
, 0))
3424 if (TREE_CODE (inner
) == PLACEHOLDER_EXPR
)
3425 push_without_duplicates (exp
, refs
);
3427 FIND_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp
, 0), refs
);
3430 switch (TREE_CODE_CLASS (code
))
3435 case tcc_declaration
:
3436 /* Variables allocated to static storage can stay. */
3437 if (!TREE_STATIC (exp
))
3438 push_without_duplicates (exp
, refs
);
3441 case tcc_expression
:
3442 /* This is the pattern built in ada/make_aligning_type. */
3443 if (code
== ADDR_EXPR
3444 && TREE_CODE (TREE_OPERAND (exp
, 0)) == PLACEHOLDER_EXPR
)
3446 push_without_duplicates (exp
, refs
);
3450 /* Fall through... */
3452 case tcc_exceptional
:
3455 case tcc_comparison
:
3457 for (i
= 0; i
< TREE_CODE_LENGTH (code
); i
++)
3458 FIND_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp
, i
), refs
);
3462 for (i
= 1; i
< TREE_OPERAND_LENGTH (exp
); i
++)
3463 FIND_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp
, i
), refs
);
3471 /* Given a tree EXP, a FIELD_DECL F, and a replacement value R,
3472 return a tree with all occurrences of references to F in a
3473 PLACEHOLDER_EXPR replaced by R. Also handle VAR_DECLs and
3474 CONST_DECLs. Note that we assume here that EXP contains only
3475 arithmetic expressions or CALL_EXPRs with PLACEHOLDER_EXPRs
3476 occurring only in their argument list. */
3479 substitute_in_expr (tree exp
, tree f
, tree r
)
3481 enum tree_code code
= TREE_CODE (exp
);
3482 tree op0
, op1
, op2
, op3
;
3485 /* We handle TREE_LIST and COMPONENT_REF separately. */
3486 if (code
== TREE_LIST
)
3488 op0
= SUBSTITUTE_IN_EXPR (TREE_CHAIN (exp
), f
, r
);
3489 op1
= SUBSTITUTE_IN_EXPR (TREE_VALUE (exp
), f
, r
);
3490 if (op0
== TREE_CHAIN (exp
) && op1
== TREE_VALUE (exp
))
3493 return tree_cons (TREE_PURPOSE (exp
), op1
, op0
);
3495 else if (code
== COMPONENT_REF
)
3499 /* If this expression is getting a value from a PLACEHOLDER_EXPR
3500 and it is the right field, replace it with R. */
3501 for (inner
= TREE_OPERAND (exp
, 0);
3502 REFERENCE_CLASS_P (inner
);
3503 inner
= TREE_OPERAND (inner
, 0))
3507 op1
= TREE_OPERAND (exp
, 1);
3509 if (TREE_CODE (inner
) == PLACEHOLDER_EXPR
&& op1
== f
)
3512 /* If this expression hasn't been completed let, leave it alone. */
3513 if (TREE_CODE (inner
) == PLACEHOLDER_EXPR
&& !TREE_TYPE (inner
))
3516 op0
= SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp
, 0), f
, r
);
3517 if (op0
== TREE_OPERAND (exp
, 0))
3521 = fold_build3 (COMPONENT_REF
, TREE_TYPE (exp
), op0
, op1
, NULL_TREE
);
3524 switch (TREE_CODE_CLASS (code
))
3529 case tcc_declaration
:
3535 case tcc_expression
:
3539 /* Fall through... */
3541 case tcc_exceptional
:
3544 case tcc_comparison
:
3546 switch (TREE_CODE_LENGTH (code
))
3552 op0
= SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp
, 0), f
, r
);
3553 if (op0
== TREE_OPERAND (exp
, 0))
3556 new_tree
= fold_build1 (code
, TREE_TYPE (exp
), op0
);
3560 op0
= SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp
, 0), f
, r
);
3561 op1
= SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp
, 1), f
, r
);
3563 if (op0
== TREE_OPERAND (exp
, 0) && op1
== TREE_OPERAND (exp
, 1))
3566 new_tree
= fold_build2 (code
, TREE_TYPE (exp
), op0
, op1
);
3570 op0
= SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp
, 0), f
, r
);
3571 op1
= SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp
, 1), f
, r
);
3572 op2
= SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp
, 2), f
, r
);
3574 if (op0
== TREE_OPERAND (exp
, 0) && op1
== TREE_OPERAND (exp
, 1)
3575 && op2
== TREE_OPERAND (exp
, 2))
3578 new_tree
= fold_build3 (code
, TREE_TYPE (exp
), op0
, op1
, op2
);
3582 op0
= SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp
, 0), f
, r
);
3583 op1
= SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp
, 1), f
, r
);
3584 op2
= SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp
, 2), f
, r
);
3585 op3
= SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp
, 3), f
, r
);
3587 if (op0
== TREE_OPERAND (exp
, 0) && op1
== TREE_OPERAND (exp
, 1)
3588 && op2
== TREE_OPERAND (exp
, 2)
3589 && op3
== TREE_OPERAND (exp
, 3))
3593 = fold (build4 (code
, TREE_TYPE (exp
), op0
, op1
, op2
, op3
));
3605 new_tree
= NULL_TREE
;
3607 /* If we are trying to replace F with a constant, inline back
3608 functions which do nothing else than computing a value from
3609 the arguments they are passed. This makes it possible to
3610 fold partially or entirely the replacement expression. */
3611 if (CONSTANT_CLASS_P (r
) && code
== CALL_EXPR
)
3613 tree t
= maybe_inline_call_in_expr (exp
);
3615 return SUBSTITUTE_IN_EXPR (t
, f
, r
);
3618 for (i
= 1; i
< TREE_OPERAND_LENGTH (exp
); i
++)
3620 tree op
= TREE_OPERAND (exp
, i
);
3621 tree new_op
= SUBSTITUTE_IN_EXPR (op
, f
, r
);
3625 new_tree
= copy_node (exp
);
3626 TREE_OPERAND (new_tree
, i
) = new_op
;
3632 new_tree
= fold (new_tree
);
3633 if (TREE_CODE (new_tree
) == CALL_EXPR
)
3634 process_call_operands (new_tree
);
3645 TREE_READONLY (new_tree
) |= TREE_READONLY (exp
);
3647 if (code
== INDIRECT_REF
|| code
== ARRAY_REF
|| code
== ARRAY_RANGE_REF
)
3648 TREE_THIS_NOTRAP (new_tree
) |= TREE_THIS_NOTRAP (exp
);
3653 /* Similar, but look for a PLACEHOLDER_EXPR in EXP and find a replacement
3654 for it within OBJ, a tree that is an object or a chain of references. */
3657 substitute_placeholder_in_expr (tree exp
, tree obj
)
3659 enum tree_code code
= TREE_CODE (exp
);
3660 tree op0
, op1
, op2
, op3
;
3663 /* If this is a PLACEHOLDER_EXPR, see if we find a corresponding type
3664 in the chain of OBJ. */
3665 if (code
== PLACEHOLDER_EXPR
)
3667 tree need_type
= TYPE_MAIN_VARIANT (TREE_TYPE (exp
));
3670 for (elt
= obj
; elt
!= 0;
3671 elt
= ((TREE_CODE (elt
) == COMPOUND_EXPR
3672 || TREE_CODE (elt
) == COND_EXPR
)
3673 ? TREE_OPERAND (elt
, 1)
3674 : (REFERENCE_CLASS_P (elt
)
3675 || UNARY_CLASS_P (elt
)
3676 || BINARY_CLASS_P (elt
)
3677 || VL_EXP_CLASS_P (elt
)
3678 || EXPRESSION_CLASS_P (elt
))
3679 ? TREE_OPERAND (elt
, 0) : 0))
3680 if (TYPE_MAIN_VARIANT (TREE_TYPE (elt
)) == need_type
)
3683 for (elt
= obj
; elt
!= 0;
3684 elt
= ((TREE_CODE (elt
) == COMPOUND_EXPR
3685 || TREE_CODE (elt
) == COND_EXPR
)
3686 ? TREE_OPERAND (elt
, 1)
3687 : (REFERENCE_CLASS_P (elt
)
3688 || UNARY_CLASS_P (elt
)
3689 || BINARY_CLASS_P (elt
)
3690 || VL_EXP_CLASS_P (elt
)
3691 || EXPRESSION_CLASS_P (elt
))
3692 ? TREE_OPERAND (elt
, 0) : 0))
3693 if (POINTER_TYPE_P (TREE_TYPE (elt
))
3694 && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (elt
)))
3696 return fold_build1 (INDIRECT_REF
, need_type
, elt
);
3698 /* If we didn't find it, return the original PLACEHOLDER_EXPR. If it
3699 survives until RTL generation, there will be an error. */
3703 /* TREE_LIST is special because we need to look at TREE_VALUE
3704 and TREE_CHAIN, not TREE_OPERANDS. */
3705 else if (code
== TREE_LIST
)
3707 op0
= SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_CHAIN (exp
), obj
);
3708 op1
= SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_VALUE (exp
), obj
);
3709 if (op0
== TREE_CHAIN (exp
) && op1
== TREE_VALUE (exp
))
3712 return tree_cons (TREE_PURPOSE (exp
), op1
, op0
);
3715 switch (TREE_CODE_CLASS (code
))
3718 case tcc_declaration
:
3721 case tcc_exceptional
:
3724 case tcc_comparison
:
3725 case tcc_expression
:
3728 switch (TREE_CODE_LENGTH (code
))
3734 op0
= SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp
, 0), obj
);
3735 if (op0
== TREE_OPERAND (exp
, 0))
3738 new_tree
= fold_build1 (code
, TREE_TYPE (exp
), op0
);
3742 op0
= SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp
, 0), obj
);
3743 op1
= SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp
, 1), obj
);
3745 if (op0
== TREE_OPERAND (exp
, 0) && op1
== TREE_OPERAND (exp
, 1))
3748 new_tree
= fold_build2 (code
, TREE_TYPE (exp
), op0
, op1
);
3752 op0
= SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp
, 0), obj
);
3753 op1
= SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp
, 1), obj
);
3754 op2
= SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp
, 2), obj
);
3756 if (op0
== TREE_OPERAND (exp
, 0) && op1
== TREE_OPERAND (exp
, 1)
3757 && op2
== TREE_OPERAND (exp
, 2))
3760 new_tree
= fold_build3 (code
, TREE_TYPE (exp
), op0
, op1
, op2
);
3764 op0
= SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp
, 0), obj
);
3765 op1
= SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp
, 1), obj
);
3766 op2
= SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp
, 2), obj
);
3767 op3
= SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp
, 3), obj
);
3769 if (op0
== TREE_OPERAND (exp
, 0) && op1
== TREE_OPERAND (exp
, 1)
3770 && op2
== TREE_OPERAND (exp
, 2)
3771 && op3
== TREE_OPERAND (exp
, 3))
3775 = fold (build4 (code
, TREE_TYPE (exp
), op0
, op1
, op2
, op3
));
3787 new_tree
= NULL_TREE
;
3789 for (i
= 1; i
< TREE_OPERAND_LENGTH (exp
); i
++)
3791 tree op
= TREE_OPERAND (exp
, i
);
3792 tree new_op
= SUBSTITUTE_PLACEHOLDER_IN_EXPR (op
, obj
);
3796 new_tree
= copy_node (exp
);
3797 TREE_OPERAND (new_tree
, i
) = new_op
;
3803 new_tree
= fold (new_tree
);
3804 if (TREE_CODE (new_tree
) == CALL_EXPR
)
3805 process_call_operands (new_tree
);
3816 TREE_READONLY (new_tree
) |= TREE_READONLY (exp
);
3818 if (code
== INDIRECT_REF
|| code
== ARRAY_REF
|| code
== ARRAY_RANGE_REF
)
3819 TREE_THIS_NOTRAP (new_tree
) |= TREE_THIS_NOTRAP (exp
);
3825 /* Subroutine of stabilize_reference; this is called for subtrees of
3826 references. Any expression with side-effects must be put in a SAVE_EXPR
3827 to ensure that it is only evaluated once.
3829 We don't put SAVE_EXPR nodes around everything, because assigning very
3830 simple expressions to temporaries causes us to miss good opportunities
3831 for optimizations. Among other things, the opportunity to fold in the
3832 addition of a constant into an addressing mode often gets lost, e.g.
3833 "y[i+1] += x;". In general, we take the approach that we should not make
3834 an assignment unless we are forced into it - i.e., that any non-side effect
3835 operator should be allowed, and that cse should take care of coalescing
3836 multiple utterances of the same expression should that prove fruitful. */
3839 stabilize_reference_1 (tree e
)
3842 enum tree_code code
= TREE_CODE (e
);
3844 /* We cannot ignore const expressions because it might be a reference
3845 to a const array but whose index contains side-effects. But we can
3846 ignore things that are actual constant or that already have been
3847 handled by this function. */
3849 if (tree_invariant_p (e
))
3852 switch (TREE_CODE_CLASS (code
))
3854 case tcc_exceptional
:
3856 case tcc_declaration
:
3857 case tcc_comparison
:
3859 case tcc_expression
:
3862 /* If the expression has side-effects, then encase it in a SAVE_EXPR
3863 so that it will only be evaluated once. */
3864 /* The reference (r) and comparison (<) classes could be handled as
3865 below, but it is generally faster to only evaluate them once. */
3866 if (TREE_SIDE_EFFECTS (e
))
3867 return save_expr (e
);
3871 /* Constants need no processing. In fact, we should never reach
3876 /* Division is slow and tends to be compiled with jumps,
3877 especially the division by powers of 2 that is often
3878 found inside of an array reference. So do it just once. */
3879 if (code
== TRUNC_DIV_EXPR
|| code
== TRUNC_MOD_EXPR
3880 || code
== FLOOR_DIV_EXPR
|| code
== FLOOR_MOD_EXPR
3881 || code
== CEIL_DIV_EXPR
|| code
== CEIL_MOD_EXPR
3882 || code
== ROUND_DIV_EXPR
|| code
== ROUND_MOD_EXPR
)
3883 return save_expr (e
);
3884 /* Recursively stabilize each operand. */
3885 result
= build_nt (code
, stabilize_reference_1 (TREE_OPERAND (e
, 0)),
3886 stabilize_reference_1 (TREE_OPERAND (e
, 1)));
3890 /* Recursively stabilize each operand. */
3891 result
= build_nt (code
, stabilize_reference_1 (TREE_OPERAND (e
, 0)));
3898 TREE_TYPE (result
) = TREE_TYPE (e
);
3899 TREE_READONLY (result
) = TREE_READONLY (e
);
3900 TREE_SIDE_EFFECTS (result
) = TREE_SIDE_EFFECTS (e
);
3901 TREE_THIS_VOLATILE (result
) = TREE_THIS_VOLATILE (e
);
3902 TREE_SHARED (result
) = TREE_SHARED (e
);
3903 TREE_STRICT (result
) = TREE_STRICT (e
);
3904 TREE_RELAXED (result
) = TREE_RELAXED (e
);
3909 /* Stabilize a reference so that we can use it any number of times
3910 without causing its operands to be evaluated more than once.
3911 Returns the stabilized reference. This works by means of save_expr,
3912 so see the caveats in the comments about save_expr.
3914 Also allows conversion expressions whose operands are references.
3915 Any other kind of expression is returned unchanged. */
3918 stabilize_reference (tree ref
)
3921 enum tree_code code
= TREE_CODE (ref
);
3928 /* No action is needed in this case. */
3933 case FIX_TRUNC_EXPR
:
3934 result
= build_nt (code
, stabilize_reference (TREE_OPERAND (ref
, 0)));
3938 result
= build_nt (INDIRECT_REF
,
3939 stabilize_reference_1 (TREE_OPERAND (ref
, 0)));
3943 result
= build_nt (COMPONENT_REF
,
3944 stabilize_reference (TREE_OPERAND (ref
, 0)),
3945 TREE_OPERAND (ref
, 1), NULL_TREE
);
3949 result
= build_nt (BIT_FIELD_REF
,
3950 stabilize_reference (TREE_OPERAND (ref
, 0)),
3951 TREE_OPERAND (ref
, 1), TREE_OPERAND (ref
, 2));
3955 result
= build_nt (ARRAY_REF
,
3956 stabilize_reference (TREE_OPERAND (ref
, 0)),
3957 stabilize_reference_1 (TREE_OPERAND (ref
, 1)),
3958 TREE_OPERAND (ref
, 2), TREE_OPERAND (ref
, 3));
3961 case ARRAY_RANGE_REF
:
3962 result
= build_nt (ARRAY_RANGE_REF
,
3963 stabilize_reference (TREE_OPERAND (ref
, 0)),
3964 stabilize_reference_1 (TREE_OPERAND (ref
, 1)),
3965 TREE_OPERAND (ref
, 2), TREE_OPERAND (ref
, 3));
3969 /* We cannot wrap the first expression in a SAVE_EXPR, as then
3970 it wouldn't be ignored. This matters when dealing with
3972 return stabilize_reference_1 (ref
);
3974 /* If arg isn't a kind of lvalue we recognize, make no change.
3975 Caller should recognize the error for an invalid lvalue. */
3980 return error_mark_node
;
3983 TREE_TYPE (result
) = TREE_TYPE (ref
);
3984 TREE_READONLY (result
) = TREE_READONLY (ref
);
3985 TREE_SIDE_EFFECTS (result
) = TREE_SIDE_EFFECTS (ref
);
3986 TREE_THIS_VOLATILE (result
) = TREE_THIS_VOLATILE (ref
);
3987 TREE_SHARED (result
) = TREE_SHARED (ref
);
3988 TREE_STRICT (result
) = TREE_STRICT (ref
);
3989 TREE_RELAXED (result
) = TREE_RELAXED (ref
);
3995 /* Low-level constructors for expressions. */
3997 /* A helper function for build1 and constant folders. Set TREE_CONSTANT,
3998 and TREE_SIDE_EFFECTS for an ADDR_EXPR. */
4001 recompute_tree_invariant_for_addr_expr (tree t
)
4004 bool tc
= true, se
= false;
4006 /* We started out assuming this address is both invariant and constant, but
4007 does not have side effects. Now go down any handled components and see if
4008 any of them involve offsets that are either non-constant or non-invariant.
4009 Also check for side-effects.
4011 ??? Note that this code makes no attempt to deal with the case where
4012 taking the address of something causes a copy due to misalignment. */
4014 #define UPDATE_FLAGS(NODE) \
4015 do { tree _node = (NODE); \
4016 if (_node && !TREE_CONSTANT (_node)) tc = false; \
4017 if (_node && TREE_SIDE_EFFECTS (_node)) se = true; } while (0)
4019 for (node
= TREE_OPERAND (t
, 0); handled_component_p (node
);
4020 node
= TREE_OPERAND (node
, 0))
4022 /* If the first operand doesn't have an ARRAY_TYPE, this is a bogus
4023 array reference (probably made temporarily by the G++ front end),
4024 so ignore all the operands. */
4025 if ((TREE_CODE (node
) == ARRAY_REF
4026 || TREE_CODE (node
) == ARRAY_RANGE_REF
)
4027 && TREE_CODE (TREE_TYPE (TREE_OPERAND (node
, 0))) == ARRAY_TYPE
)
4029 UPDATE_FLAGS (TREE_OPERAND (node
, 1));
4030 if (TREE_OPERAND (node
, 2))
4031 UPDATE_FLAGS (TREE_OPERAND (node
, 2));
4032 if (TREE_OPERAND (node
, 3))
4033 UPDATE_FLAGS (TREE_OPERAND (node
, 3));
4035 /* Likewise, just because this is a COMPONENT_REF doesn't mean we have a
4036 FIELD_DECL, apparently. The G++ front end can put something else
4037 there, at least temporarily. */
4038 else if (TREE_CODE (node
) == COMPONENT_REF
4039 && TREE_CODE (TREE_OPERAND (node
, 1)) == FIELD_DECL
)
4041 if (TREE_OPERAND (node
, 2))
4042 UPDATE_FLAGS (TREE_OPERAND (node
, 2));
4046 node
= lang_hooks
.expr_to_decl (node
, &tc
, &se
);
4048 /* Now see what's inside. If it's an INDIRECT_REF, copy our properties from
4049 the address, since &(*a)->b is a form of addition. If it's a constant, the
4050 address is constant too. If it's a decl, its address is constant if the
4051 decl is static. Everything else is not constant and, furthermore,
4052 taking the address of a volatile variable is not volatile. */
4053 if (TREE_CODE (node
) == INDIRECT_REF
4054 || TREE_CODE (node
) == MEM_REF
)
4055 UPDATE_FLAGS (TREE_OPERAND (node
, 0));
4056 else if (CONSTANT_CLASS_P (node
))
4058 else if (DECL_P (node
))
4059 tc
&= (staticp (node
) != NULL_TREE
);
4063 se
|= TREE_SIDE_EFFECTS (node
);
4067 TREE_CONSTANT (t
) = tc
;
4068 TREE_SIDE_EFFECTS (t
) = se
;
4072 /* Build an expression of code CODE, data type TYPE, and operands as
4073 specified. Expressions and reference nodes can be created this way.
4074 Constants, decls, types and misc nodes cannot be.
4076 We define 5 non-variadic functions, from 0 to 4 arguments. This is
4077 enough for all extant tree codes. */
4080 build0_stat (enum tree_code code
, tree tt MEM_STAT_DECL
)
4084 gcc_assert (TREE_CODE_LENGTH (code
) == 0);
4086 t
= make_node_stat (code PASS_MEM_STAT
);
4093 build1_stat (enum tree_code code
, tree type
, tree node MEM_STAT_DECL
)
4095 int length
= sizeof (struct tree_exp
);
4098 record_node_allocation_statistics (code
, length
);
4100 gcc_assert (TREE_CODE_LENGTH (code
) == 1);
4102 t
= ggc_alloc_tree_node_stat (length PASS_MEM_STAT
);
4104 memset (t
, 0, sizeof (struct tree_common
));
4106 TREE_SET_CODE (t
, code
);
4108 TREE_TYPE (t
) = type
;
4109 SET_EXPR_LOCATION (t
, UNKNOWN_LOCATION
);
4110 TREE_OPERAND (t
, 0) = node
;
4111 if (node
&& !TYPE_P (node
))
4113 TREE_SIDE_EFFECTS (t
) = TREE_SIDE_EFFECTS (node
);
4114 TREE_READONLY (t
) = TREE_READONLY (node
);
4117 if (TREE_CODE_CLASS (code
) == tcc_statement
)
4118 TREE_SIDE_EFFECTS (t
) = 1;
4122 /* All of these have side-effects, no matter what their
4124 TREE_SIDE_EFFECTS (t
) = 1;
4125 TREE_READONLY (t
) = 0;
4129 /* Whether a dereference is readonly has nothing to do with whether
4130 its operand is readonly. */
4131 TREE_READONLY (t
) = 0;
4132 TREE_SHARED (t
) = upc_shared_type_p (type
);
4137 recompute_tree_invariant_for_addr_expr (t
);
4141 if ((TREE_CODE_CLASS (code
) == tcc_unary
|| code
== VIEW_CONVERT_EXPR
)
4142 && node
&& !TYPE_P (node
)
4143 && TREE_CONSTANT (node
))
4144 TREE_CONSTANT (t
) = 1;
4145 if (TREE_CODE_CLASS (code
) == tcc_reference
4146 && node
&& TREE_THIS_VOLATILE (node
))
4147 TREE_THIS_VOLATILE (t
) = 1;
4148 /* Drop the UPC "shared" type qualifier for
4149 expressions involving UPC shared objects. */
4150 if (TREE_CODE_CLASS (code
) == tcc_unary
4151 && node
&& !TYPE_P (node
)
4152 && upc_shared_type_p (type
))
4153 TREE_TYPE (t
) = build_upc_unshared_type (type
);
4160 #define PROCESS_ARG(N) \
4162 TREE_OPERAND (t, N) = arg##N; \
4163 if (arg##N &&!TYPE_P (arg##N)) \
4165 if (TREE_SIDE_EFFECTS (arg##N)) \
4167 if (!TREE_READONLY (arg##N) \
4168 && !CONSTANT_CLASS_P (arg##N)) \
4169 (void) (read_only = 0); \
4170 if (!TREE_CONSTANT (arg##N)) \
4171 (void) (constant = 0); \
4176 build2_stat (enum tree_code code
, tree tt
, tree arg0
, tree arg1 MEM_STAT_DECL
)
4178 bool constant
, read_only
, side_effects
;
4181 gcc_assert (TREE_CODE_LENGTH (code
) == 2);
4183 if ((code
== MINUS_EXPR
|| code
== PLUS_EXPR
|| code
== MULT_EXPR
)
4184 && arg0
&& arg1
&& tt
&& POINTER_TYPE_P (tt
)
4185 /* When sizetype precision doesn't match that of pointers
4186 we need to be able to build explicit extensions or truncations
4187 of the offset argument. */
4188 && TYPE_PRECISION (sizetype
) == TYPE_PRECISION (tt
))
4189 gcc_assert (TREE_CODE (arg0
) == INTEGER_CST
4190 && TREE_CODE (arg1
) == INTEGER_CST
);
4192 if (code
== POINTER_PLUS_EXPR
&& arg0
&& arg1
&& tt
)
4193 gcc_assert (POINTER_TYPE_P (tt
) && POINTER_TYPE_P (TREE_TYPE (arg0
))
4194 && ptrofftype_p (TREE_TYPE (arg1
)));
4196 t
= make_node_stat (code PASS_MEM_STAT
);
4198 /* Remove UPC shared type qualifiers from the result type. */
4199 if (upc_shared_type_p (tt
))
4200 tt
= build_upc_unshared_type (tt
);
4203 /* Below, we automatically set TREE_SIDE_EFFECTS and TREE_READONLY for the
4204 result based on those same flags for the arguments. But if the
4205 arguments aren't really even `tree' expressions, we shouldn't be trying
4208 /* Expressions without side effects may be constant if their
4209 arguments are as well. */
4210 constant
= (TREE_CODE_CLASS (code
) == tcc_comparison
4211 || TREE_CODE_CLASS (code
) == tcc_binary
);
4213 side_effects
= TREE_SIDE_EFFECTS (t
);
4218 TREE_READONLY (t
) = read_only
;
4219 TREE_CONSTANT (t
) = constant
;
4220 TREE_SIDE_EFFECTS (t
) = side_effects
;
4221 TREE_THIS_VOLATILE (t
)
4222 = (TREE_CODE_CLASS (code
) == tcc_reference
4223 && arg0
&& TREE_THIS_VOLATILE (arg0
));
4230 build3_stat (enum tree_code code
, tree tt
, tree arg0
, tree arg1
,
4231 tree arg2 MEM_STAT_DECL
)
4233 bool constant
, read_only
, side_effects
;
4236 gcc_assert (TREE_CODE_LENGTH (code
) == 3);
4237 gcc_assert (TREE_CODE_CLASS (code
) != tcc_vl_exp
);
4239 t
= make_node_stat (code PASS_MEM_STAT
);
4244 /* As a special exception, if COND_EXPR has NULL branches, we
4245 assume that it is a gimple statement and always consider
4246 it to have side effects. */
4247 if (code
== COND_EXPR
4248 && tt
== void_type_node
4249 && arg1
== NULL_TREE
4250 && arg2
== NULL_TREE
)
4251 side_effects
= true;
4253 side_effects
= TREE_SIDE_EFFECTS (t
);
4259 if (code
== COND_EXPR
)
4260 TREE_READONLY (t
) = read_only
;
4262 TREE_SIDE_EFFECTS (t
) = side_effects
;
4263 TREE_THIS_VOLATILE (t
)
4264 = (TREE_CODE_CLASS (code
) == tcc_reference
4265 && arg0
&& TREE_THIS_VOLATILE (arg0
));
4267 = (TREE_CODE_CLASS (code
) == tcc_reference
4268 && arg0
&& TREE_SHARED (arg0
));
4269 if (TREE_SHARED (t
))
4271 TREE_STRICT (t
) = TREE_STRICT (arg0
);
4272 TREE_RELAXED (t
) = TREE_RELAXED (arg0
);
4279 build4_stat (enum tree_code code
, tree tt
, tree arg0
, tree arg1
,
4280 tree arg2
, tree arg3 MEM_STAT_DECL
)
4282 bool constant
, read_only
, side_effects
;
4285 gcc_assert (TREE_CODE_LENGTH (code
) == 4);
4287 t
= make_node_stat (code PASS_MEM_STAT
);
4290 side_effects
= TREE_SIDE_EFFECTS (t
);
4297 TREE_SIDE_EFFECTS (t
) = side_effects
;
4298 TREE_THIS_VOLATILE (t
)
4299 = (TREE_CODE_CLASS (code
) == tcc_reference
4300 && arg0
&& TREE_THIS_VOLATILE (arg0
));
4306 build5_stat (enum tree_code code
, tree tt
, tree arg0
, tree arg1
,
4307 tree arg2
, tree arg3
, tree arg4 MEM_STAT_DECL
)
4309 bool constant
, read_only
, side_effects
;
4312 gcc_assert (TREE_CODE_LENGTH (code
) == 5);
4314 t
= make_node_stat (code PASS_MEM_STAT
);
4317 side_effects
= TREE_SIDE_EFFECTS (t
);
4325 TREE_SIDE_EFFECTS (t
) = side_effects
;
4326 TREE_THIS_VOLATILE (t
)
4327 = (TREE_CODE_CLASS (code
) == tcc_reference
4328 && arg0
&& TREE_THIS_VOLATILE (arg0
));
4333 /* Build a simple MEM_REF tree with the sematics of a plain INDIRECT_REF
4334 on the pointer PTR. */
4337 build_simple_mem_ref_loc (location_t loc
, tree ptr
)
4339 HOST_WIDE_INT offset
= 0;
4340 tree ptype
= TREE_TYPE (ptr
);
4342 /* For convenience allow addresses that collapse to a simple base
4344 if (TREE_CODE (ptr
) == ADDR_EXPR
4345 && (handled_component_p (TREE_OPERAND (ptr
, 0))
4346 || TREE_CODE (TREE_OPERAND (ptr
, 0)) == MEM_REF
))
4348 ptr
= get_addr_base_and_unit_offset (TREE_OPERAND (ptr
, 0), &offset
);
4350 ptr
= build_fold_addr_expr (ptr
);
4351 gcc_assert (is_gimple_reg (ptr
) || is_gimple_min_invariant (ptr
));
4353 tem
= build2 (MEM_REF
, TREE_TYPE (ptype
),
4354 ptr
, build_int_cst (ptype
, offset
));
4355 SET_EXPR_LOCATION (tem
, loc
);
4359 /* Return the constant offset of a MEM_REF or TARGET_MEM_REF tree T. */
4362 mem_ref_offset (const_tree t
)
4364 tree toff
= TREE_OPERAND (t
, 1);
4365 return tree_to_double_int (toff
).sext (TYPE_PRECISION (TREE_TYPE (toff
)));
4368 /* Return an invariant ADDR_EXPR of type TYPE taking the address of BASE
4369 offsetted by OFFSET units. */
4372 build_invariant_address (tree type
, tree base
, HOST_WIDE_INT offset
)
4374 tree ref
= fold_build2 (MEM_REF
, TREE_TYPE (type
),
4375 build_fold_addr_expr (base
),
4376 build_int_cst (ptr_type_node
, offset
));
4377 tree addr
= build1 (ADDR_EXPR
, type
, ref
);
4378 recompute_tree_invariant_for_addr_expr (addr
);
4382 /* Similar except don't specify the TREE_TYPE
4383 and leave the TREE_SIDE_EFFECTS as 0.
4384 It is permissible for arguments to be null,
4385 or even garbage if their values do not matter. */
4388 build_nt (enum tree_code code
, ...)
4395 gcc_assert (TREE_CODE_CLASS (code
) != tcc_vl_exp
);
4399 t
= make_node (code
);
4400 length
= TREE_CODE_LENGTH (code
);
4402 for (i
= 0; i
< length
; i
++)
4403 TREE_OPERAND (t
, i
) = va_arg (p
, tree
);
4409 /* Similar to build_nt, but for creating a CALL_EXPR object with a
4413 build_nt_call_vec (tree fn
, vec
<tree
, va_gc
> *args
)
4418 ret
= build_vl_exp (CALL_EXPR
, vec_safe_length (args
) + 3);
4419 CALL_EXPR_FN (ret
) = fn
;
4420 CALL_EXPR_STATIC_CHAIN (ret
) = NULL_TREE
;
4421 FOR_EACH_VEC_SAFE_ELT (args
, ix
, t
)
4422 CALL_EXPR_ARG (ret
, ix
) = t
;
4426 /* Create a DECL_... node of code CODE, name NAME and data type TYPE.
4427 We do NOT enter this node in any sort of symbol table.
4429 LOC is the location of the decl.
4431 layout_decl is used to set up the decl's storage layout.
4432 Other slots are initialized to 0 or null pointers. */
4435 build_decl_stat (location_t loc
, enum tree_code code
, tree name
,
4436 tree type MEM_STAT_DECL
)
4440 t
= make_node_stat (code PASS_MEM_STAT
);
4441 DECL_SOURCE_LOCATION (t
) = loc
;
4443 /* if (type == error_mark_node)
4444 type = integer_type_node; */
4445 /* That is not done, deliberately, so that having error_mark_node
4446 as the type can suppress useless errors in the use of this variable. */
4448 DECL_NAME (t
) = name
;
4449 TREE_TYPE (t
) = type
;
4451 if (code
== VAR_DECL
|| code
== PARM_DECL
|| code
== RESULT_DECL
)
4457 /* Builds and returns function declaration with NAME and TYPE. */
4460 build_fn_decl (const char *name
, tree type
)
4462 tree id
= get_identifier (name
);
4463 tree decl
= build_decl (input_location
, FUNCTION_DECL
, id
, type
);
4465 DECL_EXTERNAL (decl
) = 1;
4466 TREE_PUBLIC (decl
) = 1;
4467 DECL_ARTIFICIAL (decl
) = 1;
4468 TREE_NOTHROW (decl
) = 1;
4473 vec
<tree
, va_gc
> *all_translation_units
;
4475 /* Builds a new translation-unit decl with name NAME, queues it in the
4476 global list of translation-unit decls and returns it. */
4479 build_translation_unit_decl (tree name
)
4481 tree tu
= build_decl (UNKNOWN_LOCATION
, TRANSLATION_UNIT_DECL
,
4483 TRANSLATION_UNIT_LANGUAGE (tu
) = lang_hooks
.name
;
4484 vec_safe_push (all_translation_units
, tu
);
4489 /* BLOCK nodes are used to represent the structure of binding contours
4490 and declarations, once those contours have been exited and their contents
4491 compiled. This information is used for outputting debugging info. */
4494 build_block (tree vars
, tree subblocks
, tree supercontext
, tree chain
)
4496 tree block
= make_node (BLOCK
);
4498 BLOCK_VARS (block
) = vars
;
4499 BLOCK_SUBBLOCKS (block
) = subblocks
;
4500 BLOCK_SUPERCONTEXT (block
) = supercontext
;
4501 BLOCK_CHAIN (block
) = chain
;
4506 /* Like SET_EXPR_LOCATION, but make sure the tree can have a location.
4508 LOC is the location to use in tree T. */
4511 protected_set_expr_location (tree t
, location_t loc
)
4513 if (t
&& CAN_HAVE_LOCATION_P (t
))
4514 SET_EXPR_LOCATION (t
, loc
);
4517 /* Return a declaration like DDECL except that its DECL_ATTRIBUTES
4521 build_decl_attribute_variant (tree ddecl
, tree attribute
)
4523 DECL_ATTRIBUTES (ddecl
) = attribute
;
4527 /* Borrowed from hashtab.c iterative_hash implementation. */
4528 #define mix(a,b,c) \
4530 a -= b; a -= c; a ^= (c>>13); \
4531 b -= c; b -= a; b ^= (a<< 8); \
4532 c -= a; c -= b; c ^= ((b&0xffffffff)>>13); \
4533 a -= b; a -= c; a ^= ((c&0xffffffff)>>12); \
4534 b -= c; b -= a; b = (b ^ (a<<16)) & 0xffffffff; \
4535 c -= a; c -= b; c = (c ^ (b>> 5)) & 0xffffffff; \
4536 a -= b; a -= c; a = (a ^ (c>> 3)) & 0xffffffff; \
4537 b -= c; b -= a; b = (b ^ (a<<10)) & 0xffffffff; \
4538 c -= a; c -= b; c = (c ^ (b>>15)) & 0xffffffff; \
4542 /* Produce good hash value combining VAL and VAL2. */
4544 iterative_hash_hashval_t (hashval_t val
, hashval_t val2
)
4546 /* the golden ratio; an arbitrary value. */
4547 hashval_t a
= 0x9e3779b9;
4553 /* Produce good hash value combining VAL and VAL2. */
4555 iterative_hash_host_wide_int (HOST_WIDE_INT val
, hashval_t val2
)
4557 if (sizeof (HOST_WIDE_INT
) == sizeof (hashval_t
))
4558 return iterative_hash_hashval_t (val
, val2
);
4561 hashval_t a
= (hashval_t
) val
;
4562 /* Avoid warnings about shifting of more than the width of the type on
4563 hosts that won't execute this path. */
4565 hashval_t b
= (hashval_t
) (val
>> (sizeof (hashval_t
) * 8 + zero
));
4567 if (sizeof (HOST_WIDE_INT
) > 2 * sizeof (hashval_t
))
4569 hashval_t a
= (hashval_t
) (val
>> (sizeof (hashval_t
) * 16 + zero
));
4570 hashval_t b
= (hashval_t
) (val
>> (sizeof (hashval_t
) * 24 + zero
));
4577 /* Return a type like TTYPE except that its TYPE_ATTRIBUTE
4578 is ATTRIBUTE and its qualifiers are QUALS.
4580 Record such modified types already made so we don't make duplicates. */
4583 build_type_attribute_qual_variant (tree ttype
, tree attribute
, int quals
)
4585 if (! attribute_list_equal (TYPE_ATTRIBUTES (ttype
), attribute
))
4587 hashval_t hashcode
= 0;
4589 enum tree_code code
= TREE_CODE (ttype
);
4591 /* Building a distinct copy of a tagged type is inappropriate; it
4592 causes breakage in code that expects there to be a one-to-one
4593 relationship between a struct and its fields.
4594 build_duplicate_type is another solution (as used in
4595 handle_transparent_union_attribute), but that doesn't play well
4596 with the stronger C++ type identity model. */
4597 if (TREE_CODE (ttype
) == RECORD_TYPE
4598 || TREE_CODE (ttype
) == UNION_TYPE
4599 || TREE_CODE (ttype
) == QUAL_UNION_TYPE
4600 || TREE_CODE (ttype
) == ENUMERAL_TYPE
)
4602 warning (OPT_Wattributes
,
4603 "ignoring attributes applied to %qT after definition",
4604 TYPE_MAIN_VARIANT (ttype
));
4605 return build_qualified_type (ttype
, quals
);
4608 ttype
= build_qualified_type (ttype
, TYPE_UNQUALIFIED
);
4609 ntype
= build_distinct_type_copy (ttype
);
4611 TYPE_ATTRIBUTES (ntype
) = attribute
;
4613 hashcode
= iterative_hash_object (code
, hashcode
);
4614 if (TREE_TYPE (ntype
))
4615 hashcode
= iterative_hash_object (TYPE_HASH (TREE_TYPE (ntype
)),
4617 hashcode
= attribute_hash_list (attribute
, hashcode
);
4619 switch (TREE_CODE (ntype
))
4622 hashcode
= type_hash_list (TYPE_ARG_TYPES (ntype
), hashcode
);
4625 if (TYPE_DOMAIN (ntype
))
4626 hashcode
= iterative_hash_object (TYPE_HASH (TYPE_DOMAIN (ntype
)),
4630 hashcode
= iterative_hash_object
4631 (TREE_INT_CST_LOW (TYPE_MAX_VALUE (ntype
)), hashcode
);
4632 hashcode
= iterative_hash_object
4633 (TREE_INT_CST_HIGH (TYPE_MAX_VALUE (ntype
)), hashcode
);
4636 case FIXED_POINT_TYPE
:
4638 unsigned int precision
= TYPE_PRECISION (ntype
);
4639 hashcode
= iterative_hash_object (precision
, hashcode
);
4646 ntype
= type_hash_canon (hashcode
, ntype
);
4648 /* If the target-dependent attributes make NTYPE different from
4649 its canonical type, we will need to use structural equality
4650 checks for this type. */
4651 if (TYPE_STRUCTURAL_EQUALITY_P (ttype
)
4652 || !comp_type_attributes (ntype
, ttype
))
4653 SET_TYPE_STRUCTURAL_EQUALITY (ntype
);
4654 else if (TYPE_CANONICAL (ntype
) == ntype
)
4655 TYPE_CANONICAL (ntype
) = TYPE_CANONICAL (ttype
);
4657 ttype
= build_qualified_type (ntype
, quals
);
4659 else if (TYPE_QUALS (ttype
) != quals
)
4660 ttype
= build_qualified_type (ttype
, quals
);
4665 /* Check if "omp declare simd" attribute arguments, CLAUSES1 and CLAUSES2, are
4669 omp_declare_simd_clauses_equal (tree clauses1
, tree clauses2
)
4672 for (cl1
= clauses1
, cl2
= clauses2
;
4674 cl1
= OMP_CLAUSE_CHAIN (cl1
), cl2
= OMP_CLAUSE_CHAIN (cl2
))
4676 if (OMP_CLAUSE_CODE (cl1
) != OMP_CLAUSE_CODE (cl2
))
4678 if (OMP_CLAUSE_CODE (cl1
) != OMP_CLAUSE_SIMDLEN
)
4680 if (simple_cst_equal (OMP_CLAUSE_DECL (cl1
),
4681 OMP_CLAUSE_DECL (cl2
)) != 1)
4684 switch (OMP_CLAUSE_CODE (cl1
))
4686 case OMP_CLAUSE_ALIGNED
:
4687 if (simple_cst_equal (OMP_CLAUSE_ALIGNED_ALIGNMENT (cl1
),
4688 OMP_CLAUSE_ALIGNED_ALIGNMENT (cl2
)) != 1)
4691 case OMP_CLAUSE_LINEAR
:
4692 if (simple_cst_equal (OMP_CLAUSE_LINEAR_STEP (cl1
),
4693 OMP_CLAUSE_LINEAR_STEP (cl2
)) != 1)
4696 case OMP_CLAUSE_SIMDLEN
:
4697 if (simple_cst_equal (OMP_CLAUSE_SIMDLEN_EXPR (cl1
),
4698 OMP_CLAUSE_SIMDLEN_EXPR (cl2
)) != 1)
4707 /* Compare two constructor-element-type constants. Return 1 if the lists
4708 are known to be equal; otherwise return 0. */
4711 simple_cst_list_equal (const_tree l1
, const_tree l2
)
4713 while (l1
!= NULL_TREE
&& l2
!= NULL_TREE
)
4715 if (simple_cst_equal (TREE_VALUE (l1
), TREE_VALUE (l2
)) != 1)
4718 l1
= TREE_CHAIN (l1
);
4719 l2
= TREE_CHAIN (l2
);
4725 /* Compare two attributes for their value identity. Return true if the
4726 attribute values are known to be equal; otherwise return false.
4730 attribute_value_equal (const_tree attr1
, const_tree attr2
)
4732 if (TREE_VALUE (attr1
) == TREE_VALUE (attr2
))
4735 if (TREE_VALUE (attr1
) != NULL_TREE
4736 && TREE_CODE (TREE_VALUE (attr1
)) == TREE_LIST
4737 && TREE_VALUE (attr2
) != NULL
4738 && TREE_CODE (TREE_VALUE (attr2
)) == TREE_LIST
)
4739 return (simple_cst_list_equal (TREE_VALUE (attr1
),
4740 TREE_VALUE (attr2
)) == 1);
4742 if ((flag_openmp
|| flag_openmp_simd
)
4743 && TREE_VALUE (attr1
) && TREE_VALUE (attr2
)
4744 && TREE_CODE (TREE_VALUE (attr1
)) == OMP_CLAUSE
4745 && TREE_CODE (TREE_VALUE (attr2
)) == OMP_CLAUSE
)
4746 return omp_declare_simd_clauses_equal (TREE_VALUE (attr1
),
4747 TREE_VALUE (attr2
));
4749 return (simple_cst_equal (TREE_VALUE (attr1
), TREE_VALUE (attr2
)) == 1);
4752 /* Return 0 if the attributes for two types are incompatible, 1 if they
4753 are compatible, and 2 if they are nearly compatible (which causes a
4754 warning to be generated). */
4756 comp_type_attributes (const_tree type1
, const_tree type2
)
4758 const_tree a1
= TYPE_ATTRIBUTES (type1
);
4759 const_tree a2
= TYPE_ATTRIBUTES (type2
);
4764 for (a
= a1
; a
!= NULL_TREE
; a
= TREE_CHAIN (a
))
4766 const struct attribute_spec
*as
;
4769 as
= lookup_attribute_spec (get_attribute_name (a
));
4770 if (!as
|| as
->affects_type_identity
== false)
4773 attr
= lookup_attribute (as
->name
, CONST_CAST_TREE (a2
));
4774 if (!attr
|| !attribute_value_equal (a
, attr
))
4779 for (a
= a2
; a
!= NULL_TREE
; a
= TREE_CHAIN (a
))
4781 const struct attribute_spec
*as
;
4783 as
= lookup_attribute_spec (get_attribute_name (a
));
4784 if (!as
|| as
->affects_type_identity
== false)
4787 if (!lookup_attribute (as
->name
, CONST_CAST_TREE (a1
)))
4789 /* We don't need to compare trees again, as we did this
4790 already in first loop. */
4792 /* All types - affecting identity - are equal, so
4793 there is no need to call target hook for comparison. */
4797 /* As some type combinations - like default calling-convention - might
4798 be compatible, we have to call the target hook to get the final result. */
4799 return targetm
.comp_type_attributes (type1
, type2
);
4802 /* Return a type like TTYPE except that its TYPE_ATTRIBUTE
4805 Record such modified types already made so we don't make duplicates. */
4808 build_type_attribute_variant (tree ttype
, tree attribute
)
4810 return build_type_attribute_qual_variant (ttype
, attribute
,
4811 TYPE_QUALS (ttype
));
4815 /* Reset the expression *EXPR_P, a size or position.
4817 ??? We could reset all non-constant sizes or positions. But it's cheap
4818 enough to not do so and refrain from adding workarounds to dwarf2out.c.
4820 We need to reset self-referential sizes or positions because they cannot
4821 be gimplified and thus can contain a CALL_EXPR after the gimplification
4822 is finished, which will run afoul of LTO streaming. And they need to be
4823 reset to something essentially dummy but not constant, so as to preserve
4824 the properties of the object they are attached to. */
4827 free_lang_data_in_one_sizepos (tree
*expr_p
)
4829 tree expr
= *expr_p
;
4830 if (CONTAINS_PLACEHOLDER_P (expr
))
4831 *expr_p
= build0 (PLACEHOLDER_EXPR
, TREE_TYPE (expr
));
4835 /* Reset all the fields in a binfo node BINFO. We only keep
4836 BINFO_VTABLE, which is used by gimple_fold_obj_type_ref. */
4839 free_lang_data_in_binfo (tree binfo
)
4844 gcc_assert (TREE_CODE (binfo
) == TREE_BINFO
);
4846 BINFO_VIRTUALS (binfo
) = NULL_TREE
;
4847 BINFO_BASE_ACCESSES (binfo
) = NULL
;
4848 BINFO_INHERITANCE_CHAIN (binfo
) = NULL_TREE
;
4849 BINFO_SUBVTT_INDEX (binfo
) = NULL_TREE
;
4851 FOR_EACH_VEC_ELT (*BINFO_BASE_BINFOS (binfo
), i
, t
)
4852 free_lang_data_in_binfo (t
);
4856 /* Reset all language specific information still present in TYPE. */
4859 free_lang_data_in_type (tree type
)
4861 gcc_assert (TYPE_P (type
));
4863 /* Give the FE a chance to remove its own data first. */
4864 lang_hooks
.free_lang_data (type
);
4866 TREE_LANG_FLAG_0 (type
) = 0;
4867 TREE_LANG_FLAG_1 (type
) = 0;
4868 TREE_LANG_FLAG_2 (type
) = 0;
4869 TREE_LANG_FLAG_3 (type
) = 0;
4870 TREE_LANG_FLAG_4 (type
) = 0;
4871 TREE_LANG_FLAG_5 (type
) = 0;
4872 TREE_LANG_FLAG_6 (type
) = 0;
4874 if (TREE_CODE (type
) == FUNCTION_TYPE
)
4876 /* Remove the const and volatile qualifiers from arguments. The
4877 C++ front end removes them, but the C front end does not,
4878 leading to false ODR violation errors when merging two
4879 instances of the same function signature compiled by
4880 different front ends. */
4883 for (p
= TYPE_ARG_TYPES (type
); p
; p
= TREE_CHAIN (p
))
4885 tree arg_type
= TREE_VALUE (p
);
4887 if (TYPE_READONLY (arg_type
) || TYPE_VOLATILE (arg_type
))
4889 int quals
= TYPE_QUALS (arg_type
)
4891 & ~TYPE_QUAL_VOLATILE
;
4892 TREE_VALUE (p
) = build_qualified_type (arg_type
, quals
);
4893 free_lang_data_in_type (TREE_VALUE (p
));
4898 /* Remove members that are not actually FIELD_DECLs from the field
4899 list of an aggregate. These occur in C++. */
4900 if (RECORD_OR_UNION_TYPE_P (type
))
4904 /* Note that TYPE_FIELDS can be shared across distinct
4905 TREE_TYPEs. Therefore, if the first field of TYPE_FIELDS is
4906 to be removed, we cannot set its TREE_CHAIN to NULL.
4907 Otherwise, we would not be able to find all the other fields
4908 in the other instances of this TREE_TYPE.
4910 This was causing an ICE in testsuite/g++.dg/lto/20080915.C. */
4912 member
= TYPE_FIELDS (type
);
4915 if (TREE_CODE (member
) == FIELD_DECL
4916 || TREE_CODE (member
) == TYPE_DECL
)
4919 TREE_CHAIN (prev
) = member
;
4921 TYPE_FIELDS (type
) = member
;
4925 member
= TREE_CHAIN (member
);
4929 TREE_CHAIN (prev
) = NULL_TREE
;
4931 TYPE_FIELDS (type
) = NULL_TREE
;
4933 TYPE_METHODS (type
) = NULL_TREE
;
4934 if (TYPE_BINFO (type
))
4935 free_lang_data_in_binfo (TYPE_BINFO (type
));
4939 /* For non-aggregate types, clear out the language slot (which
4940 overloads TYPE_BINFO). */
4941 TYPE_LANG_SLOT_1 (type
) = NULL_TREE
;
4943 if (INTEGRAL_TYPE_P (type
)
4944 || SCALAR_FLOAT_TYPE_P (type
)
4945 || FIXED_POINT_TYPE_P (type
))
4947 free_lang_data_in_one_sizepos (&TYPE_MIN_VALUE (type
));
4948 free_lang_data_in_one_sizepos (&TYPE_MAX_VALUE (type
));
4952 free_lang_data_in_one_sizepos (&TYPE_SIZE (type
));
4953 free_lang_data_in_one_sizepos (&TYPE_SIZE_UNIT (type
));
4955 if (TYPE_CONTEXT (type
)
4956 && TREE_CODE (TYPE_CONTEXT (type
)) == BLOCK
)
4958 tree ctx
= TYPE_CONTEXT (type
);
4961 ctx
= BLOCK_SUPERCONTEXT (ctx
);
4963 while (ctx
&& TREE_CODE (ctx
) == BLOCK
);
4964 TYPE_CONTEXT (type
) = ctx
;
4969 /* Return true if DECL may need an assembler name to be set. */
4972 need_assembler_name_p (tree decl
)
4974 /* Only FUNCTION_DECLs and VAR_DECLs are considered. */
4975 if (TREE_CODE (decl
) != FUNCTION_DECL
4976 && TREE_CODE (decl
) != VAR_DECL
)
4979 /* If DECL already has its assembler name set, it does not need a
4981 if (!HAS_DECL_ASSEMBLER_NAME_P (decl
)
4982 || DECL_ASSEMBLER_NAME_SET_P (decl
))
4985 /* Abstract decls do not need an assembler name. */
4986 if (DECL_ABSTRACT (decl
))
4989 /* For VAR_DECLs, only static, public and external symbols need an
4991 if (TREE_CODE (decl
) == VAR_DECL
4992 && !TREE_STATIC (decl
)
4993 && !TREE_PUBLIC (decl
)
4994 && !DECL_EXTERNAL (decl
))
4997 if (TREE_CODE (decl
) == FUNCTION_DECL
)
4999 /* Do not set assembler name on builtins. Allow RTL expansion to
5000 decide whether to expand inline or via a regular call. */
5001 if (DECL_BUILT_IN (decl
)
5002 && DECL_BUILT_IN_CLASS (decl
) != BUILT_IN_FRONTEND
)
5005 /* Functions represented in the callgraph need an assembler name. */
5006 if (cgraph_get_node (decl
) != NULL
)
5009 /* Unused and not public functions don't need an assembler name. */
5010 if (!TREE_USED (decl
) && !TREE_PUBLIC (decl
))
5018 /* Reset all language specific information still present in symbol
5022 free_lang_data_in_decl (tree decl
)
5024 gcc_assert (DECL_P (decl
));
5026 /* Give the FE a chance to remove its own data first. */
5027 lang_hooks
.free_lang_data (decl
);
5029 TREE_LANG_FLAG_0 (decl
) = 0;
5030 TREE_LANG_FLAG_1 (decl
) = 0;
5031 TREE_LANG_FLAG_2 (decl
) = 0;
5032 TREE_LANG_FLAG_3 (decl
) = 0;
5033 TREE_LANG_FLAG_4 (decl
) = 0;
5034 TREE_LANG_FLAG_5 (decl
) = 0;
5035 TREE_LANG_FLAG_6 (decl
) = 0;
5037 free_lang_data_in_one_sizepos (&DECL_SIZE (decl
));
5038 free_lang_data_in_one_sizepos (&DECL_SIZE_UNIT (decl
));
5039 if (TREE_CODE (decl
) == FIELD_DECL
)
5041 free_lang_data_in_one_sizepos (&DECL_FIELD_OFFSET (decl
));
5042 if (TREE_CODE (DECL_CONTEXT (decl
)) == QUAL_UNION_TYPE
)
5043 DECL_QUALIFIER (decl
) = NULL_TREE
;
5046 if (TREE_CODE (decl
) == FUNCTION_DECL
)
5048 struct cgraph_node
*node
;
5049 if (!(node
= cgraph_get_node (decl
))
5050 || (!node
->definition
&& !node
->clones
))
5053 cgraph_release_function_body (node
);
5056 release_function_body (decl
);
5057 DECL_ARGUMENTS (decl
) = NULL
;
5058 DECL_RESULT (decl
) = NULL
;
5059 DECL_INITIAL (decl
) = error_mark_node
;
5062 if (gimple_has_body_p (decl
))
5066 /* If DECL has a gimple body, then the context for its
5067 arguments must be DECL. Otherwise, it doesn't really
5068 matter, as we will not be emitting any code for DECL. In
5069 general, there may be other instances of DECL created by
5070 the front end and since PARM_DECLs are generally shared,
5071 their DECL_CONTEXT changes as the replicas of DECL are
5072 created. The only time where DECL_CONTEXT is important
5073 is for the FUNCTION_DECLs that have a gimple body (since
5074 the PARM_DECL will be used in the function's body). */
5075 for (t
= DECL_ARGUMENTS (decl
); t
; t
= TREE_CHAIN (t
))
5076 DECL_CONTEXT (t
) = decl
;
5079 /* DECL_SAVED_TREE holds the GENERIC representation for DECL.
5080 At this point, it is not needed anymore. */
5081 DECL_SAVED_TREE (decl
) = NULL_TREE
;
5083 /* Clear the abstract origin if it refers to a method. Otherwise
5084 dwarf2out.c will ICE as we clear TYPE_METHODS and thus the
5085 origin will not be output correctly. */
5086 if (DECL_ABSTRACT_ORIGIN (decl
)
5087 && DECL_CONTEXT (DECL_ABSTRACT_ORIGIN (decl
))
5088 && RECORD_OR_UNION_TYPE_P
5089 (DECL_CONTEXT (DECL_ABSTRACT_ORIGIN (decl
))))
5090 DECL_ABSTRACT_ORIGIN (decl
) = NULL_TREE
;
5092 /* Sometimes the C++ frontend doesn't manage to transform a temporary
5093 DECL_VINDEX referring to itself into a vtable slot number as it
5094 should. Happens with functions that are copied and then forgotten
5095 about. Just clear it, it won't matter anymore. */
5096 if (DECL_VINDEX (decl
) && !tree_fits_shwi_p (DECL_VINDEX (decl
)))
5097 DECL_VINDEX (decl
) = NULL_TREE
;
5099 else if (TREE_CODE (decl
) == VAR_DECL
)
5101 if ((DECL_EXTERNAL (decl
)
5102 && (!TREE_STATIC (decl
) || !TREE_READONLY (decl
)))
5103 || (decl_function_context (decl
) && !TREE_STATIC (decl
)))
5104 DECL_INITIAL (decl
) = NULL_TREE
;
5106 else if (TREE_CODE (decl
) == TYPE_DECL
5107 || TREE_CODE (decl
) == FIELD_DECL
)
5108 DECL_INITIAL (decl
) = NULL_TREE
;
5109 else if (TREE_CODE (decl
) == TRANSLATION_UNIT_DECL
5110 && DECL_INITIAL (decl
)
5111 && TREE_CODE (DECL_INITIAL (decl
)) == BLOCK
)
5113 /* Strip builtins from the translation-unit BLOCK. We still have targets
5114 without builtin_decl_explicit support and also builtins are shared
5115 nodes and thus we can't use TREE_CHAIN in multiple lists. */
5116 tree
*nextp
= &BLOCK_VARS (DECL_INITIAL (decl
));
5120 if (TREE_CODE (var
) == FUNCTION_DECL
5121 && DECL_BUILT_IN (var
))
5122 *nextp
= TREE_CHAIN (var
);
5124 nextp
= &TREE_CHAIN (var
);
5130 /* Data used when collecting DECLs and TYPEs for language data removal. */
5132 struct free_lang_data_d
5134 /* Worklist to avoid excessive recursion. */
5137 /* Set of traversed objects. Used to avoid duplicate visits. */
5138 struct pointer_set_t
*pset
;
5140 /* Array of symbols to process with free_lang_data_in_decl. */
5143 /* Array of types to process with free_lang_data_in_type. */
5148 /* Save all language fields needed to generate proper debug information
5149 for DECL. This saves most fields cleared out by free_lang_data_in_decl. */
5152 save_debug_info_for_decl (tree t
)
5154 /*struct saved_debug_info_d *sdi;*/
5156 gcc_assert (debug_info_level
> DINFO_LEVEL_TERSE
&& t
&& DECL_P (t
));
5158 /* FIXME. Partial implementation for saving debug info removed. */
5162 /* Save all language fields needed to generate proper debug information
5163 for TYPE. This saves most fields cleared out by free_lang_data_in_type. */
5166 save_debug_info_for_type (tree t
)
5168 /*struct saved_debug_info_d *sdi;*/
5170 gcc_assert (debug_info_level
> DINFO_LEVEL_TERSE
&& t
&& TYPE_P (t
));
5172 /* FIXME. Partial implementation for saving debug info removed. */
5176 /* Add type or decl T to one of the list of tree nodes that need their
5177 language data removed. The lists are held inside FLD. */
5180 add_tree_to_fld_list (tree t
, struct free_lang_data_d
*fld
)
5184 fld
->decls
.safe_push (t
);
5185 if (debug_info_level
> DINFO_LEVEL_TERSE
)
5186 save_debug_info_for_decl (t
);
5188 else if (TYPE_P (t
))
5190 fld
->types
.safe_push (t
);
5191 if (debug_info_level
> DINFO_LEVEL_TERSE
)
5192 save_debug_info_for_type (t
);
5198 /* Push tree node T into FLD->WORKLIST. */
5201 fld_worklist_push (tree t
, struct free_lang_data_d
*fld
)
5203 if (t
&& !is_lang_specific (t
) && !pointer_set_contains (fld
->pset
, t
))
5204 fld
->worklist
.safe_push ((t
));
5208 /* Operand callback helper for free_lang_data_in_node. *TP is the
5209 subtree operand being considered. */
5212 find_decls_types_r (tree
*tp
, int *ws
, void *data
)
5215 struct free_lang_data_d
*fld
= (struct free_lang_data_d
*) data
;
5217 if (TREE_CODE (t
) == TREE_LIST
)
5220 /* Language specific nodes will be removed, so there is no need
5221 to gather anything under them. */
5222 if (is_lang_specific (t
))
5230 /* Note that walk_tree does not traverse every possible field in
5231 decls, so we have to do our own traversals here. */
5232 add_tree_to_fld_list (t
, fld
);
5234 fld_worklist_push (DECL_NAME (t
), fld
);
5235 fld_worklist_push (DECL_CONTEXT (t
), fld
);
5236 fld_worklist_push (DECL_SIZE (t
), fld
);
5237 fld_worklist_push (DECL_SIZE_UNIT (t
), fld
);
5239 /* We are going to remove everything under DECL_INITIAL for
5240 TYPE_DECLs. No point walking them. */
5241 if (TREE_CODE (t
) != TYPE_DECL
)
5242 fld_worklist_push (DECL_INITIAL (t
), fld
);
5244 fld_worklist_push (DECL_ATTRIBUTES (t
), fld
);
5245 fld_worklist_push (DECL_ABSTRACT_ORIGIN (t
), fld
);
5247 if (TREE_CODE (t
) == FUNCTION_DECL
)
5249 fld_worklist_push (DECL_ARGUMENTS (t
), fld
);
5250 fld_worklist_push (DECL_RESULT (t
), fld
);
5252 else if (TREE_CODE (t
) == TYPE_DECL
)
5254 fld_worklist_push (DECL_ARGUMENT_FLD (t
), fld
);
5255 fld_worklist_push (DECL_VINDEX (t
), fld
);
5256 fld_worklist_push (DECL_ORIGINAL_TYPE (t
), fld
);
5258 else if (TREE_CODE (t
) == FIELD_DECL
)
5260 fld_worklist_push (DECL_FIELD_OFFSET (t
), fld
);
5261 fld_worklist_push (DECL_BIT_FIELD_TYPE (t
), fld
);
5262 fld_worklist_push (DECL_FIELD_BIT_OFFSET (t
), fld
);
5263 fld_worklist_push (DECL_FCONTEXT (t
), fld
);
5265 else if (TREE_CODE (t
) == VAR_DECL
)
5267 fld_worklist_push (DECL_SECTION_NAME (t
), fld
);
5268 fld_worklist_push (DECL_COMDAT_GROUP (t
), fld
);
5271 if ((TREE_CODE (t
) == VAR_DECL
|| TREE_CODE (t
) == PARM_DECL
)
5272 && DECL_HAS_VALUE_EXPR_P (t
))
5273 fld_worklist_push (DECL_VALUE_EXPR (t
), fld
);
5275 if (TREE_CODE (t
) != FIELD_DECL
5276 && TREE_CODE (t
) != TYPE_DECL
)
5277 fld_worklist_push (TREE_CHAIN (t
), fld
);
5280 else if (TYPE_P (t
))
5282 /* Note that walk_tree does not traverse every possible field in
5283 types, so we have to do our own traversals here. */
5284 add_tree_to_fld_list (t
, fld
);
5286 if (!RECORD_OR_UNION_TYPE_P (t
))
5287 fld_worklist_push (TYPE_CACHED_VALUES (t
), fld
);
5288 fld_worklist_push (TYPE_SIZE (t
), fld
);
5289 fld_worklist_push (TYPE_SIZE_UNIT (t
), fld
);
5290 fld_worklist_push (TYPE_ATTRIBUTES (t
), fld
);
5291 fld_worklist_push (TYPE_POINTER_TO (t
), fld
);
5292 fld_worklist_push (TYPE_REFERENCE_TO (t
), fld
);
5293 fld_worklist_push (TYPE_NAME (t
), fld
);
5294 /* Do not walk TYPE_NEXT_PTR_TO or TYPE_NEXT_REF_TO. We do not stream
5295 them and thus do not and want not to reach unused pointer types
5297 if (!POINTER_TYPE_P (t
))
5298 fld_worklist_push (TYPE_MINVAL (t
), fld
);
5299 if (!RECORD_OR_UNION_TYPE_P (t
))
5300 fld_worklist_push (TYPE_MAXVAL (t
), fld
);
5301 fld_worklist_push (TYPE_MAIN_VARIANT (t
), fld
);
5302 /* Do not walk TYPE_NEXT_VARIANT. We do not stream it and thus
5303 do not and want not to reach unused variants this way. */
5304 if (TYPE_CONTEXT (t
))
5306 tree ctx
= TYPE_CONTEXT (t
);
5307 /* We adjust BLOCK TYPE_CONTEXTs to the innermost non-BLOCK one.
5308 So push that instead. */
5309 while (ctx
&& TREE_CODE (ctx
) == BLOCK
)
5310 ctx
= BLOCK_SUPERCONTEXT (ctx
);
5311 fld_worklist_push (ctx
, fld
);
5313 /* Do not walk TYPE_CANONICAL. We do not stream it and thus do not
5314 and want not to reach unused types this way. */
5316 if (RECORD_OR_UNION_TYPE_P (t
) && TYPE_BINFO (t
))
5320 FOR_EACH_VEC_ELT (*BINFO_BASE_BINFOS (TYPE_BINFO (t
)), i
, tem
)
5321 fld_worklist_push (TREE_TYPE (tem
), fld
);
5322 tem
= BINFO_VIRTUALS (TYPE_BINFO (t
));
5324 /* The Java FE overloads BINFO_VIRTUALS for its own purpose. */
5325 && TREE_CODE (tem
) == TREE_LIST
)
5328 fld_worklist_push (TREE_VALUE (tem
), fld
);
5329 tem
= TREE_CHAIN (tem
);
5333 if (RECORD_OR_UNION_TYPE_P (t
))
5336 /* Push all TYPE_FIELDS - there can be interleaving interesting
5337 and non-interesting things. */
5338 tem
= TYPE_FIELDS (t
);
5341 if (TREE_CODE (tem
) == FIELD_DECL
5342 || TREE_CODE (tem
) == TYPE_DECL
)
5343 fld_worklist_push (tem
, fld
);
5344 tem
= TREE_CHAIN (tem
);
5348 fld_worklist_push (TYPE_STUB_DECL (t
), fld
);
5351 else if (TREE_CODE (t
) == BLOCK
)
5354 for (tem
= BLOCK_VARS (t
); tem
; tem
= TREE_CHAIN (tem
))
5355 fld_worklist_push (tem
, fld
);
5356 for (tem
= BLOCK_SUBBLOCKS (t
); tem
; tem
= BLOCK_CHAIN (tem
))
5357 fld_worklist_push (tem
, fld
);
5358 fld_worklist_push (BLOCK_ABSTRACT_ORIGIN (t
), fld
);
5361 if (TREE_CODE (t
) != IDENTIFIER_NODE
5362 && CODE_CONTAINS_STRUCT (TREE_CODE (t
), TS_TYPED
))
5363 fld_worklist_push (TREE_TYPE (t
), fld
);
5369 /* Find decls and types in T. */
5372 find_decls_types (tree t
, struct free_lang_data_d
*fld
)
5376 if (!pointer_set_contains (fld
->pset
, t
))
5377 walk_tree (&t
, find_decls_types_r
, fld
, fld
->pset
);
5378 if (fld
->worklist
.is_empty ())
5380 t
= fld
->worklist
.pop ();
5384 /* Translate all the types in LIST with the corresponding runtime
5388 get_eh_types_for_runtime (tree list
)
5392 if (list
== NULL_TREE
)
5395 head
= build_tree_list (0, lookup_type_for_runtime (TREE_VALUE (list
)));
5397 list
= TREE_CHAIN (list
);
5400 tree n
= build_tree_list (0, lookup_type_for_runtime (TREE_VALUE (list
)));
5401 TREE_CHAIN (prev
) = n
;
5402 prev
= TREE_CHAIN (prev
);
5403 list
= TREE_CHAIN (list
);
5410 /* Find decls and types referenced in EH region R and store them in
5411 FLD->DECLS and FLD->TYPES. */
5414 find_decls_types_in_eh_region (eh_region r
, struct free_lang_data_d
*fld
)
5425 /* The types referenced in each catch must first be changed to the
5426 EH types used at runtime. This removes references to FE types
5428 for (c
= r
->u
.eh_try
.first_catch
; c
; c
= c
->next_catch
)
5430 c
->type_list
= get_eh_types_for_runtime (c
->type_list
);
5431 walk_tree (&c
->type_list
, find_decls_types_r
, fld
, fld
->pset
);
5436 case ERT_ALLOWED_EXCEPTIONS
:
5437 r
->u
.allowed
.type_list
5438 = get_eh_types_for_runtime (r
->u
.allowed
.type_list
);
5439 walk_tree (&r
->u
.allowed
.type_list
, find_decls_types_r
, fld
, fld
->pset
);
5442 case ERT_MUST_NOT_THROW
:
5443 walk_tree (&r
->u
.must_not_throw
.failure_decl
,
5444 find_decls_types_r
, fld
, fld
->pset
);
5450 /* Find decls and types referenced in cgraph node N and store them in
5451 FLD->DECLS and FLD->TYPES. Unlike pass_referenced_vars, this will
5452 look for *every* kind of DECL and TYPE node reachable from N,
5453 including those embedded inside types and decls (i.e,, TYPE_DECLs,
5454 NAMESPACE_DECLs, etc). */
5457 find_decls_types_in_node (struct cgraph_node
*n
, struct free_lang_data_d
*fld
)
5460 struct function
*fn
;
5464 find_decls_types (n
->decl
, fld
);
5466 if (!gimple_has_body_p (n
->decl
))
5469 gcc_assert (current_function_decl
== NULL_TREE
&& cfun
== NULL
);
5471 fn
= DECL_STRUCT_FUNCTION (n
->decl
);
5473 /* Traverse locals. */
5474 FOR_EACH_LOCAL_DECL (fn
, ix
, t
)
5475 find_decls_types (t
, fld
);
5477 /* Traverse EH regions in FN. */
5480 FOR_ALL_EH_REGION_FN (r
, fn
)
5481 find_decls_types_in_eh_region (r
, fld
);
5484 /* Traverse every statement in FN. */
5485 FOR_EACH_BB_FN (bb
, fn
)
5487 gimple_stmt_iterator si
;
5490 for (si
= gsi_start_phis (bb
); !gsi_end_p (si
); gsi_next (&si
))
5492 gimple phi
= gsi_stmt (si
);
5494 for (i
= 0; i
< gimple_phi_num_args (phi
); i
++)
5496 tree
*arg_p
= gimple_phi_arg_def_ptr (phi
, i
);
5497 find_decls_types (*arg_p
, fld
);
5501 for (si
= gsi_start_bb (bb
); !gsi_end_p (si
); gsi_next (&si
))
5503 gimple stmt
= gsi_stmt (si
);
5505 if (is_gimple_call (stmt
))
5506 find_decls_types (gimple_call_fntype (stmt
), fld
);
5508 for (i
= 0; i
< gimple_num_ops (stmt
); i
++)
5510 tree arg
= gimple_op (stmt
, i
);
5511 find_decls_types (arg
, fld
);
5518 /* Find decls and types referenced in varpool node N and store them in
5519 FLD->DECLS and FLD->TYPES. Unlike pass_referenced_vars, this will
5520 look for *every* kind of DECL and TYPE node reachable from N,
5521 including those embedded inside types and decls (i.e,, TYPE_DECLs,
5522 NAMESPACE_DECLs, etc). */
5525 find_decls_types_in_var (varpool_node
*v
, struct free_lang_data_d
*fld
)
5527 find_decls_types (v
->decl
, fld
);
5530 /* If T needs an assembler name, have one created for it. */
5533 assign_assembler_name_if_neeeded (tree t
)
5535 if (need_assembler_name_p (t
))
5537 /* When setting DECL_ASSEMBLER_NAME, the C++ mangler may emit
5538 diagnostics that use input_location to show locus
5539 information. The problem here is that, at this point,
5540 input_location is generally anchored to the end of the file
5541 (since the parser is long gone), so we don't have a good
5542 position to pin it to.
5544 To alleviate this problem, this uses the location of T's
5545 declaration. Examples of this are
5546 testsuite/g++.dg/template/cond2.C and
5547 testsuite/g++.dg/template/pr35240.C. */
5548 location_t saved_location
= input_location
;
5549 input_location
= DECL_SOURCE_LOCATION (t
);
5551 decl_assembler_name (t
);
5553 input_location
= saved_location
;
5558 /* Free language specific information for every operand and expression
5559 in every node of the call graph. This process operates in three stages:
5561 1- Every callgraph node and varpool node is traversed looking for
5562 decls and types embedded in them. This is a more exhaustive
5563 search than that done by find_referenced_vars, because it will
5564 also collect individual fields, decls embedded in types, etc.
5566 2- All the decls found are sent to free_lang_data_in_decl.
5568 3- All the types found are sent to free_lang_data_in_type.
5570 The ordering between decls and types is important because
5571 free_lang_data_in_decl sets assembler names, which includes
5572 mangling. So types cannot be freed up until assembler names have
5576 free_lang_data_in_cgraph (void)
5578 struct cgraph_node
*n
;
5580 struct free_lang_data_d fld
;
5585 /* Initialize sets and arrays to store referenced decls and types. */
5586 fld
.pset
= pointer_set_create ();
5587 fld
.worklist
.create (0);
5588 fld
.decls
.create (100);
5589 fld
.types
.create (100);
5591 /* Find decls and types in the body of every function in the callgraph. */
5592 FOR_EACH_FUNCTION (n
)
5593 find_decls_types_in_node (n
, &fld
);
5595 FOR_EACH_VEC_SAFE_ELT (alias_pairs
, i
, p
)
5596 find_decls_types (p
->decl
, &fld
);
5598 /* Find decls and types in every varpool symbol. */
5599 FOR_EACH_VARIABLE (v
)
5600 find_decls_types_in_var (v
, &fld
);
5602 /* Set the assembler name on every decl found. We need to do this
5603 now because free_lang_data_in_decl will invalidate data needed
5604 for mangling. This breaks mangling on interdependent decls. */
5605 FOR_EACH_VEC_ELT (fld
.decls
, i
, t
)
5606 assign_assembler_name_if_neeeded (t
);
5608 /* Traverse every decl found freeing its language data. */
5609 FOR_EACH_VEC_ELT (fld
.decls
, i
, t
)
5610 free_lang_data_in_decl (t
);
5612 /* Traverse every type found freeing its language data. */
5613 FOR_EACH_VEC_ELT (fld
.types
, i
, t
)
5614 free_lang_data_in_type (t
);
5616 pointer_set_destroy (fld
.pset
);
5617 fld
.worklist
.release ();
5618 fld
.decls
.release ();
5619 fld
.types
.release ();
5623 /* Free resources that are used by FE but are not needed once they are done. */
5626 free_lang_data (void)
5630 /* If we are the LTO frontend we have freed lang-specific data already. */
5632 || !flag_generate_lto
)
5635 /* Allocate and assign alias sets to the standard integer types
5636 while the slots are still in the way the frontends generated them. */
5637 for (i
= 0; i
< itk_none
; ++i
)
5638 if (integer_types
[i
])
5639 TYPE_ALIAS_SET (integer_types
[i
]) = get_alias_set (integer_types
[i
]);
5641 /* Traverse the IL resetting language specific information for
5642 operands, expressions, etc. */
5643 free_lang_data_in_cgraph ();
5645 /* Create gimple variants for common types. */
5646 ptrdiff_type_node
= integer_type_node
;
5647 fileptr_type_node
= ptr_type_node
;
5649 /* Reset some langhooks. Do not reset types_compatible_p, it may
5650 still be used indirectly via the get_alias_set langhook. */
5651 lang_hooks
.dwarf_name
= lhd_dwarf_name
;
5652 lang_hooks
.decl_printable_name
= gimple_decl_printable_name
;
5653 /* We do not want the default decl_assembler_name implementation,
5654 rather if we have fixed everything we want a wrapper around it
5655 asserting that all non-local symbols already got their assembler
5656 name and only produce assembler names for local symbols. Or rather
5657 make sure we never call decl_assembler_name on local symbols and
5658 devise a separate, middle-end private scheme for it. */
5660 /* Reset diagnostic machinery. */
5661 tree_diagnostics_defaults (global_dc
);
5669 const pass_data pass_data_ipa_free_lang_data
=
5671 SIMPLE_IPA_PASS
, /* type */
5672 "*free_lang_data", /* name */
5673 OPTGROUP_NONE
, /* optinfo_flags */
5674 true, /* has_execute */
5675 TV_IPA_FREE_LANG_DATA
, /* tv_id */
5676 0, /* properties_required */
5677 0, /* properties_provided */
5678 0, /* properties_destroyed */
5679 0, /* todo_flags_start */
5680 0, /* todo_flags_finish */
5683 class pass_ipa_free_lang_data
: public simple_ipa_opt_pass
5686 pass_ipa_free_lang_data (gcc::context
*ctxt
)
5687 : simple_ipa_opt_pass (pass_data_ipa_free_lang_data
, ctxt
)
5690 /* opt_pass methods: */
5691 virtual unsigned int execute (function
*) { return free_lang_data (); }
5693 }; // class pass_ipa_free_lang_data
5697 simple_ipa_opt_pass
*
5698 make_pass_ipa_free_lang_data (gcc::context
*ctxt
)
5700 return new pass_ipa_free_lang_data (ctxt
);
5703 /* The backbone of is_attribute_p(). ATTR_LEN is the string length of
5704 ATTR_NAME. Also used internally by remove_attribute(). */
5706 private_is_attribute_p (const char *attr_name
, size_t attr_len
, const_tree ident
)
5708 size_t ident_len
= IDENTIFIER_LENGTH (ident
);
5710 if (ident_len
== attr_len
)
5712 if (strcmp (attr_name
, IDENTIFIER_POINTER (ident
)) == 0)
5715 else if (ident_len
== attr_len
+ 4)
5717 /* There is the possibility that ATTR is 'text' and IDENT is
5719 const char *p
= IDENTIFIER_POINTER (ident
);
5720 if (p
[0] == '_' && p
[1] == '_'
5721 && p
[ident_len
- 2] == '_' && p
[ident_len
- 1] == '_'
5722 && strncmp (attr_name
, p
+ 2, attr_len
) == 0)
5729 /* The backbone of lookup_attribute(). ATTR_LEN is the string length
5730 of ATTR_NAME, and LIST is not NULL_TREE. */
5732 private_lookup_attribute (const char *attr_name
, size_t attr_len
, tree list
)
5736 size_t ident_len
= IDENTIFIER_LENGTH (get_attribute_name (list
));
5738 if (ident_len
== attr_len
)
5740 if (!strcmp (attr_name
,
5741 IDENTIFIER_POINTER (get_attribute_name (list
))))
5744 /* TODO: If we made sure that attributes were stored in the
5745 canonical form without '__...__' (ie, as in 'text' as opposed
5746 to '__text__') then we could avoid the following case. */
5747 else if (ident_len
== attr_len
+ 4)
5749 const char *p
= IDENTIFIER_POINTER (get_attribute_name (list
));
5750 if (p
[0] == '_' && p
[1] == '_'
5751 && p
[ident_len
- 2] == '_' && p
[ident_len
- 1] == '_'
5752 && strncmp (attr_name
, p
+ 2, attr_len
) == 0)
5755 list
= TREE_CHAIN (list
);
5761 /* A variant of lookup_attribute() that can be used with an identifier
5762 as the first argument, and where the identifier can be either
5763 'text' or '__text__'.
5765 Given an attribute ATTR_IDENTIFIER, and a list of attributes LIST,
5766 return a pointer to the attribute's list element if the attribute
5767 is part of the list, or NULL_TREE if not found. If the attribute
5768 appears more than once, this only returns the first occurrence; the
5769 TREE_CHAIN of the return value should be passed back in if further
5770 occurrences are wanted. ATTR_IDENTIFIER must be an identifier but
5771 can be in the form 'text' or '__text__'. */
5773 lookup_ident_attribute (tree attr_identifier
, tree list
)
5775 gcc_checking_assert (TREE_CODE (attr_identifier
) == IDENTIFIER_NODE
);
5779 gcc_checking_assert (TREE_CODE (get_attribute_name (list
))
5780 == IDENTIFIER_NODE
);
5782 /* Identifiers can be compared directly for equality. */
5783 if (attr_identifier
== get_attribute_name (list
))
5786 /* If they are not equal, they may still be one in the form
5787 'text' while the other one is in the form '__text__'. TODO:
5788 If we were storing attributes in normalized 'text' form, then
5789 this could all go away and we could take full advantage of
5790 the fact that we're comparing identifiers. :-) */
5792 size_t attr_len
= IDENTIFIER_LENGTH (attr_identifier
);
5793 size_t ident_len
= IDENTIFIER_LENGTH (get_attribute_name (list
));
5795 if (ident_len
== attr_len
+ 4)
5797 const char *p
= IDENTIFIER_POINTER (get_attribute_name (list
));
5798 const char *q
= IDENTIFIER_POINTER (attr_identifier
);
5799 if (p
[0] == '_' && p
[1] == '_'
5800 && p
[ident_len
- 2] == '_' && p
[ident_len
- 1] == '_'
5801 && strncmp (q
, p
+ 2, attr_len
) == 0)
5804 else if (ident_len
+ 4 == attr_len
)
5806 const char *p
= IDENTIFIER_POINTER (get_attribute_name (list
));
5807 const char *q
= IDENTIFIER_POINTER (attr_identifier
);
5808 if (q
[0] == '_' && q
[1] == '_'
5809 && q
[attr_len
- 2] == '_' && q
[attr_len
- 1] == '_'
5810 && strncmp (q
+ 2, p
, ident_len
) == 0)
5814 list
= TREE_CHAIN (list
);
5820 /* Remove any instances of attribute ATTR_NAME in LIST and return the
5824 remove_attribute (const char *attr_name
, tree list
)
5827 size_t attr_len
= strlen (attr_name
);
5829 gcc_checking_assert (attr_name
[0] != '_');
5831 for (p
= &list
; *p
; )
5834 /* TODO: If we were storing attributes in normalized form, here
5835 we could use a simple strcmp(). */
5836 if (private_is_attribute_p (attr_name
, attr_len
, get_attribute_name (l
)))
5837 *p
= TREE_CHAIN (l
);
5839 p
= &TREE_CHAIN (l
);
5845 /* Return an attribute list that is the union of a1 and a2. */
5848 merge_attributes (tree a1
, tree a2
)
5852 /* Either one unset? Take the set one. */
5854 if ((attributes
= a1
) == 0)
5857 /* One that completely contains the other? Take it. */
5859 else if (a2
!= 0 && ! attribute_list_contained (a1
, a2
))
5861 if (attribute_list_contained (a2
, a1
))
5865 /* Pick the longest list, and hang on the other list. */
5867 if (list_length (a1
) < list_length (a2
))
5868 attributes
= a2
, a2
= a1
;
5870 for (; a2
!= 0; a2
= TREE_CHAIN (a2
))
5873 for (a
= lookup_ident_attribute (get_attribute_name (a2
),
5875 a
!= NULL_TREE
&& !attribute_value_equal (a
, a2
);
5876 a
= lookup_ident_attribute (get_attribute_name (a2
),
5881 a1
= copy_node (a2
);
5882 TREE_CHAIN (a1
) = attributes
;
5891 /* Given types T1 and T2, merge their attributes and return
5895 merge_type_attributes (tree t1
, tree t2
)
5897 return merge_attributes (TYPE_ATTRIBUTES (t1
),
5898 TYPE_ATTRIBUTES (t2
));
5901 /* Given decls OLDDECL and NEWDECL, merge their attributes and return
5905 merge_decl_attributes (tree olddecl
, tree newdecl
)
5907 return merge_attributes (DECL_ATTRIBUTES (olddecl
),
5908 DECL_ATTRIBUTES (newdecl
));
5911 #if TARGET_DLLIMPORT_DECL_ATTRIBUTES
5913 /* Specialization of merge_decl_attributes for various Windows targets.
5915 This handles the following situation:
5917 __declspec (dllimport) int foo;
5920 The second instance of `foo' nullifies the dllimport. */
5923 merge_dllimport_decl_attributes (tree old
, tree new_tree
)
5926 int delete_dllimport_p
= 1;
5928 /* What we need to do here is remove from `old' dllimport if it doesn't
5929 appear in `new'. dllimport behaves like extern: if a declaration is
5930 marked dllimport and a definition appears later, then the object
5931 is not dllimport'd. We also remove a `new' dllimport if the old list
5932 contains dllexport: dllexport always overrides dllimport, regardless
5933 of the order of declaration. */
5934 if (!VAR_OR_FUNCTION_DECL_P (new_tree
))
5935 delete_dllimport_p
= 0;
5936 else if (DECL_DLLIMPORT_P (new_tree
)
5937 && lookup_attribute ("dllexport", DECL_ATTRIBUTES (old
)))
5939 DECL_DLLIMPORT_P (new_tree
) = 0;
5940 warning (OPT_Wattributes
, "%q+D already declared with dllexport attribute: "
5941 "dllimport ignored", new_tree
);
5943 else if (DECL_DLLIMPORT_P (old
) && !DECL_DLLIMPORT_P (new_tree
))
5945 /* Warn about overriding a symbol that has already been used, e.g.:
5946 extern int __attribute__ ((dllimport)) foo;
5947 int* bar () {return &foo;}
5950 if (TREE_USED (old
))
5952 warning (0, "%q+D redeclared without dllimport attribute "
5953 "after being referenced with dll linkage", new_tree
);
5954 /* If we have used a variable's address with dllimport linkage,
5955 keep the old DECL_DLLIMPORT_P flag: the ADDR_EXPR using the
5956 decl may already have had TREE_CONSTANT computed.
5957 We still remove the attribute so that assembler code refers
5958 to '&foo rather than '_imp__foo'. */
5959 if (TREE_CODE (old
) == VAR_DECL
&& TREE_ADDRESSABLE (old
))
5960 DECL_DLLIMPORT_P (new_tree
) = 1;
5963 /* Let an inline definition silently override the external reference,
5964 but otherwise warn about attribute inconsistency. */
5965 else if (TREE_CODE (new_tree
) == VAR_DECL
5966 || !DECL_DECLARED_INLINE_P (new_tree
))
5967 warning (OPT_Wattributes
, "%q+D redeclared without dllimport attribute: "
5968 "previous dllimport ignored", new_tree
);
5971 delete_dllimport_p
= 0;
5973 a
= merge_attributes (DECL_ATTRIBUTES (old
), DECL_ATTRIBUTES (new_tree
));
5975 if (delete_dllimport_p
)
5976 a
= remove_attribute ("dllimport", a
);
5981 /* Handle a "dllimport" or "dllexport" attribute; arguments as in
5982 struct attribute_spec.handler. */
5985 handle_dll_attribute (tree
* pnode
, tree name
, tree args
, int flags
,
5991 /* These attributes may apply to structure and union types being created,
5992 but otherwise should pass to the declaration involved. */
5995 if (flags
& ((int) ATTR_FLAG_DECL_NEXT
| (int) ATTR_FLAG_FUNCTION_NEXT
5996 | (int) ATTR_FLAG_ARRAY_NEXT
))
5998 *no_add_attrs
= true;
5999 return tree_cons (name
, args
, NULL_TREE
);
6001 if (TREE_CODE (node
) == RECORD_TYPE
6002 || TREE_CODE (node
) == UNION_TYPE
)
6004 node
= TYPE_NAME (node
);
6010 warning (OPT_Wattributes
, "%qE attribute ignored",
6012 *no_add_attrs
= true;
6017 if (TREE_CODE (node
) != FUNCTION_DECL
6018 && TREE_CODE (node
) != VAR_DECL
6019 && TREE_CODE (node
) != TYPE_DECL
)
6021 *no_add_attrs
= true;
6022 warning (OPT_Wattributes
, "%qE attribute ignored",
6027 if (TREE_CODE (node
) == TYPE_DECL
6028 && TREE_CODE (TREE_TYPE (node
)) != RECORD_TYPE
6029 && TREE_CODE (TREE_TYPE (node
)) != UNION_TYPE
)
6031 *no_add_attrs
= true;
6032 warning (OPT_Wattributes
, "%qE attribute ignored",
6037 is_dllimport
= is_attribute_p ("dllimport", name
);
6039 /* Report error on dllimport ambiguities seen now before they cause
6043 /* Honor any target-specific overrides. */
6044 if (!targetm
.valid_dllimport_attribute_p (node
))
6045 *no_add_attrs
= true;
6047 else if (TREE_CODE (node
) == FUNCTION_DECL
6048 && DECL_DECLARED_INLINE_P (node
))
6050 warning (OPT_Wattributes
, "inline function %q+D declared as "
6051 " dllimport: attribute ignored", node
);
6052 *no_add_attrs
= true;
6054 /* Like MS, treat definition of dllimported variables and
6055 non-inlined functions on declaration as syntax errors. */
6056 else if (TREE_CODE (node
) == FUNCTION_DECL
&& DECL_INITIAL (node
))
6058 error ("function %q+D definition is marked dllimport", node
);
6059 *no_add_attrs
= true;
6062 else if (TREE_CODE (node
) == VAR_DECL
)
6064 if (DECL_INITIAL (node
))
6066 error ("variable %q+D definition is marked dllimport",
6068 *no_add_attrs
= true;
6071 /* `extern' needn't be specified with dllimport.
6072 Specify `extern' now and hope for the best. Sigh. */
6073 DECL_EXTERNAL (node
) = 1;
6074 /* Also, implicitly give dllimport'd variables declared within
6075 a function global scope, unless declared static. */
6076 if (current_function_decl
!= NULL_TREE
&& !TREE_STATIC (node
))
6077 TREE_PUBLIC (node
) = 1;
6080 if (*no_add_attrs
== false)
6081 DECL_DLLIMPORT_P (node
) = 1;
6083 else if (TREE_CODE (node
) == FUNCTION_DECL
6084 && DECL_DECLARED_INLINE_P (node
)
6085 && flag_keep_inline_dllexport
)
6086 /* An exported function, even if inline, must be emitted. */
6087 DECL_EXTERNAL (node
) = 0;
6089 /* Report error if symbol is not accessible at global scope. */
6090 if (!TREE_PUBLIC (node
)
6091 && (TREE_CODE (node
) == VAR_DECL
6092 || TREE_CODE (node
) == FUNCTION_DECL
))
6094 error ("external linkage required for symbol %q+D because of "
6095 "%qE attribute", node
, name
);
6096 *no_add_attrs
= true;
6099 /* A dllexport'd entity must have default visibility so that other
6100 program units (shared libraries or the main executable) can see
6101 it. A dllimport'd entity must have default visibility so that
6102 the linker knows that undefined references within this program
6103 unit can be resolved by the dynamic linker. */
6106 if (DECL_VISIBILITY_SPECIFIED (node
)
6107 && DECL_VISIBILITY (node
) != VISIBILITY_DEFAULT
)
6108 error ("%qE implies default visibility, but %qD has already "
6109 "been declared with a different visibility",
6111 DECL_VISIBILITY (node
) = VISIBILITY_DEFAULT
;
6112 DECL_VISIBILITY_SPECIFIED (node
) = 1;
6118 #endif /* TARGET_DLLIMPORT_DECL_ATTRIBUTES */
6120 /* Set the type qualifiers for TYPE to TYPE_QUALS, which is a bitmask
6121 of the various TYPE_QUAL values. Also, set the UPC layout qualifier,
6122 which is either null or a reference to an integral constant. */
6125 set_type_quals (tree type
, int type_quals
, tree layout_qualifier
)
6127 TYPE_READONLY (type
) = (type_quals
& TYPE_QUAL_CONST
) != 0;
6128 TYPE_VOLATILE (type
) = (type_quals
& TYPE_QUAL_VOLATILE
) != 0;
6129 TYPE_RESTRICT (type
) = (type_quals
& TYPE_QUAL_RESTRICT
) != 0;
6130 TYPE_ATOMIC (type
) = (type_quals
& TYPE_QUAL_ATOMIC
) != 0;
6131 TYPE_ADDR_SPACE (type
) = DECODE_QUAL_ADDR_SPACE (type_quals
);
6132 TYPE_UPC_SHARED (type
) = (type_quals
& TYPE_QUAL_UPC_SHARED
) != 0;
6133 TYPE_UPC_STRICT (type
) = (type_quals
& TYPE_QUAL_UPC_STRICT
) != 0;
6134 TYPE_UPC_RELAXED (type
) = (type_quals
& TYPE_QUAL_UPC_RELAXED
) != 0;
6135 if (TYPE_UPC_SHARED (type
))
6136 SET_TYPE_UPC_BLOCK_FACTOR (type
, layout_qualifier
);
6139 /* Returns true iff CAND is equivalent to BASE with
6140 TYPE_QUALS and LAYOUT_QUALIFIER. */
6143 check_qualified_type (const_tree cand
, const_tree base
,
6144 int type_quals
, tree layout_qualifier
)
6146 return (TYPE_QUALS (cand
) == type_quals
6147 && TYPE_UPC_BLOCK_FACTOR (cand
) == layout_qualifier
6148 && TYPE_NAME (cand
) == TYPE_NAME (base
)
6149 /* Apparently this is needed for Objective-C. */
6150 && TYPE_CONTEXT (cand
) == TYPE_CONTEXT (base
)
6151 /* Check alignment. */
6152 && TYPE_ALIGN (cand
) == TYPE_ALIGN (base
)
6153 && attribute_list_equal (TYPE_ATTRIBUTES (cand
),
6154 TYPE_ATTRIBUTES (base
)));
6157 /* Returns true iff CAND is equivalent to BASE with ALIGN. */
6160 check_aligned_type (const_tree cand
, const_tree base
, unsigned int align
)
6162 return (TYPE_QUALS (cand
) == TYPE_QUALS (base
)
6163 && TYPE_UPC_BLOCK_FACTOR (cand
) == TYPE_UPC_BLOCK_FACTOR (base
)
6164 && TYPE_NAME (cand
) == TYPE_NAME (base
)
6165 /* Apparently this is needed for Objective-C. */
6166 && TYPE_CONTEXT (cand
) == TYPE_CONTEXT (base
)
6167 /* Check alignment. */
6168 && TYPE_ALIGN (cand
) == align
6169 && attribute_list_equal (TYPE_ATTRIBUTES (cand
),
6170 TYPE_ATTRIBUTES (base
)));
6173 /* This function checks to see if TYPE matches the size one of the built-in
6174 atomic types, and returns that core atomic type. */
6177 find_atomic_core_type (tree type
)
6179 tree base_atomic_type
;
6181 /* Only handle complete types. */
6182 if (TYPE_SIZE (type
) == NULL_TREE
)
6185 HOST_WIDE_INT type_size
= tree_to_uhwi (TYPE_SIZE (type
));
6189 base_atomic_type
= atomicQI_type_node
;
6193 base_atomic_type
= atomicHI_type_node
;
6197 base_atomic_type
= atomicSI_type_node
;
6201 base_atomic_type
= atomicDI_type_node
;
6205 base_atomic_type
= atomicTI_type_node
;
6209 base_atomic_type
= NULL_TREE
;
6212 return base_atomic_type
;
6215 /* Return a version of the TYPE, qualified as indicated by the
6216 TYPE_QUALS, if one exists. If no qualified version exists yet,
6217 return NULL_TREE. */
6220 get_qualified_type_1 (tree type
, int type_quals
, tree layout_qualifier
)
6224 if (TYPE_QUALS (type
) == type_quals
)
6227 /* Search the chain of variants to see if there is already one there just
6228 like the one we need to have. If so, use that existing one. We must
6229 preserve the TYPE_NAME, since there is code that depends on this. */
6230 for (t
= TYPE_MAIN_VARIANT (type
); t
; t
= TYPE_NEXT_VARIANT (t
))
6231 if (check_qualified_type (t
, type
, type_quals
, layout_qualifier
))
6237 /* Like get_qualified_type_1, but creates the type if it does not
6238 exist. This function never returns NULL_TREE. */
6241 build_qualified_type_1 (tree type
, int type_quals
, tree layout_qualifier
)
6245 /* See if we already have the appropriate qualified variant. */
6246 t
= get_qualified_type_1 (type
, type_quals
, layout_qualifier
);
6248 /* If not, build it. */
6251 t
= build_variant_type_copy (type
);
6252 set_type_quals (t
, type_quals
, layout_qualifier
);
6254 if (((type_quals
& TYPE_QUAL_ATOMIC
) == TYPE_QUAL_ATOMIC
))
6256 /* See if this object can map to a basic atomic type. */
6257 tree atomic_type
= find_atomic_core_type (type
);
6260 /* Ensure the alignment of this type is compatible with
6261 the required alignment of the atomic type. */
6262 if (TYPE_ALIGN (atomic_type
) > TYPE_ALIGN (t
))
6263 TYPE_ALIGN (t
) = TYPE_ALIGN (atomic_type
);
6267 if (TYPE_STRUCTURAL_EQUALITY_P (type
))
6268 /* Propagate structural equality. */
6269 SET_TYPE_STRUCTURAL_EQUALITY (t
);
6270 else if (TYPE_CANONICAL (type
) != type
)
6271 /* Build the underlying canonical type, since it is different
6273 TYPE_CANONICAL (t
) = build_qualified_type (TYPE_CANONICAL (type
),
6276 /* T is its own canonical type. */
6277 TYPE_CANONICAL (t
) = t
;
6284 /* Create a variant of type T with alignment ALIGN. */
6287 build_aligned_type (tree type
, unsigned int align
)
6291 if (TYPE_PACKED (type
)
6292 || TYPE_ALIGN (type
) == align
)
6295 for (t
= TYPE_MAIN_VARIANT (type
); t
; t
= TYPE_NEXT_VARIANT (t
))
6296 if (check_aligned_type (t
, type
, align
))
6299 t
= build_variant_type_copy (type
);
6300 TYPE_ALIGN (t
) = align
;
6305 /* Create a new distinct copy of TYPE. The new type is made its own
6306 MAIN_VARIANT. If TYPE requires structural equality checks, the
6307 resulting type requires structural equality checks; otherwise, its
6308 TYPE_CANONICAL points to itself. */
6311 build_distinct_type_copy (tree type
)
6313 tree t
= copy_node (type
);
6315 TYPE_POINTER_TO (t
) = 0;
6316 TYPE_REFERENCE_TO (t
) = 0;
6318 /* Set the canonical type either to a new equivalence class, or
6319 propagate the need for structural equality checks. */
6320 if (TYPE_STRUCTURAL_EQUALITY_P (type
))
6321 SET_TYPE_STRUCTURAL_EQUALITY (t
);
6323 TYPE_CANONICAL (t
) = t
;
6325 /* Make it its own variant. */
6326 TYPE_MAIN_VARIANT (t
) = t
;
6327 TYPE_NEXT_VARIANT (t
) = 0;
6329 /* Note that it is now possible for TYPE_MIN_VALUE to be a value
6330 whose TREE_TYPE is not t. This can also happen in the Ada
6331 frontend when using subtypes. */
6336 /* Create a new variant of TYPE, equivalent but distinct. This is so
6337 the caller can modify it. TYPE_CANONICAL for the return type will
6338 be equivalent to TYPE_CANONICAL of TYPE, indicating that the types
6339 are considered equal by the language itself (or that both types
6340 require structural equality checks). */
6343 build_variant_type_copy (tree type
)
6345 tree t
, m
= TYPE_MAIN_VARIANT (type
);
6347 t
= build_distinct_type_copy (type
);
6349 /* Since we're building a variant, assume that it is a non-semantic
6350 variant. This also propagates TYPE_STRUCTURAL_EQUALITY_P. */
6351 TYPE_CANONICAL (t
) = TYPE_CANONICAL (type
);
6353 /* Add the new type to the chain of variants of TYPE. */
6354 TYPE_NEXT_VARIANT (t
) = TYPE_NEXT_VARIANT (m
);
6355 TYPE_NEXT_VARIANT (m
) = t
;
6356 TYPE_MAIN_VARIANT (t
) = m
;
6361 /* Return true if the from tree in both tree maps are equal. */
6364 tree_map_base_eq (const void *va
, const void *vb
)
6366 const struct tree_map_base
*const a
= (const struct tree_map_base
*) va
,
6367 *const b
= (const struct tree_map_base
*) vb
;
6368 return (a
->from
== b
->from
);
6371 /* Hash a from tree in a tree_base_map. */
6374 tree_map_base_hash (const void *item
)
6376 return htab_hash_pointer (((const struct tree_map_base
*)item
)->from
);
6379 /* Return true if this tree map structure is marked for garbage collection
6380 purposes. We simply return true if the from tree is marked, so that this
6381 structure goes away when the from tree goes away. */
6384 tree_map_base_marked_p (const void *p
)
6386 return ggc_marked_p (((const struct tree_map_base
*) p
)->from
);
6389 /* Hash a from tree in a tree_map. */
6392 tree_map_hash (const void *item
)
6394 return (((const struct tree_map
*) item
)->hash
);
6397 /* Hash a from tree in a tree_decl_map. */
6400 tree_decl_map_hash (const void *item
)
6402 return DECL_UID (((const struct tree_decl_map
*) item
)->base
.from
);
6405 /* Return the initialization priority for DECL. */
6408 decl_init_priority_lookup (tree decl
)
6410 struct tree_priority_map
*h
;
6411 struct tree_map_base in
;
6413 gcc_assert (VAR_OR_FUNCTION_DECL_P (decl
));
6415 h
= (struct tree_priority_map
*) htab_find (init_priority_for_decl
, &in
);
6416 return h
? h
->init
: DEFAULT_INIT_PRIORITY
;
6419 /* Return the finalization priority for DECL. */
6422 decl_fini_priority_lookup (tree decl
)
6424 struct tree_priority_map
*h
;
6425 struct tree_map_base in
;
6427 gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
);
6429 h
= (struct tree_priority_map
*) htab_find (init_priority_for_decl
, &in
);
6430 return h
? h
->fini
: DEFAULT_INIT_PRIORITY
;
6433 /* Return the initialization and finalization priority information for
6434 DECL. If there is no previous priority information, a freshly
6435 allocated structure is returned. */
6437 static struct tree_priority_map
*
6438 decl_priority_info (tree decl
)
6440 struct tree_priority_map in
;
6441 struct tree_priority_map
*h
;
6444 in
.base
.from
= decl
;
6445 loc
= htab_find_slot (init_priority_for_decl
, &in
, INSERT
);
6446 h
= (struct tree_priority_map
*) *loc
;
6449 h
= ggc_alloc_cleared_tree_priority_map ();
6451 h
->base
.from
= decl
;
6452 h
->init
= DEFAULT_INIT_PRIORITY
;
6453 h
->fini
= DEFAULT_INIT_PRIORITY
;
6459 /* Set the initialization priority for DECL to PRIORITY. */
6462 decl_init_priority_insert (tree decl
, priority_type priority
)
6464 struct tree_priority_map
*h
;
6466 gcc_assert (VAR_OR_FUNCTION_DECL_P (decl
));
6467 if (priority
== DEFAULT_INIT_PRIORITY
)
6469 h
= decl_priority_info (decl
);
6473 /* Set the finalization priority for DECL to PRIORITY. */
6476 decl_fini_priority_insert (tree decl
, priority_type priority
)
6478 struct tree_priority_map
*h
;
6480 gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
);
6481 if (priority
== DEFAULT_INIT_PRIORITY
)
6483 h
= decl_priority_info (decl
);
6487 /* Print out the statistics for the DECL_DEBUG_EXPR hash table. */
6490 print_debug_expr_statistics (void)
6492 fprintf (stderr
, "DECL_DEBUG_EXPR hash: size %ld, %ld elements, %f collisions\n",
6493 (long) htab_size (debug_expr_for_decl
),
6494 (long) htab_elements (debug_expr_for_decl
),
6495 htab_collisions (debug_expr_for_decl
));
6498 /* Print out the statistics for the DECL_VALUE_EXPR hash table. */
6501 print_value_expr_statistics (void)
6503 fprintf (stderr
, "DECL_VALUE_EXPR hash: size %ld, %ld elements, %f collisions\n",
6504 (long) htab_size (value_expr_for_decl
),
6505 (long) htab_elements (value_expr_for_decl
),
6506 htab_collisions (value_expr_for_decl
));
6509 /* Lookup a debug expression for FROM, and return it if we find one. */
6512 decl_debug_expr_lookup (tree from
)
6514 struct tree_decl_map
*h
, in
;
6515 in
.base
.from
= from
;
6517 h
= (struct tree_decl_map
*)
6518 htab_find_with_hash (debug_expr_for_decl
, &in
, DECL_UID (from
));
6524 /* Insert a mapping FROM->TO in the debug expression hashtable. */
6527 decl_debug_expr_insert (tree from
, tree to
)
6529 struct tree_decl_map
*h
;
6532 h
= ggc_alloc_tree_decl_map ();
6533 h
->base
.from
= from
;
6535 loc
= htab_find_slot_with_hash (debug_expr_for_decl
, h
, DECL_UID (from
),
6537 *(struct tree_decl_map
**) loc
= h
;
6540 /* Lookup a value expression for FROM, and return it if we find one. */
6543 decl_value_expr_lookup (tree from
)
6545 struct tree_decl_map
*h
, in
;
6546 in
.base
.from
= from
;
6548 h
= (struct tree_decl_map
*)
6549 htab_find_with_hash (value_expr_for_decl
, &in
, DECL_UID (from
));
6555 /* Insert a mapping FROM->TO in the value expression hashtable. */
6558 decl_value_expr_insert (tree from
, tree to
)
6560 struct tree_decl_map
*h
;
6563 h
= ggc_alloc_tree_decl_map ();
6564 h
->base
.from
= from
;
6566 loc
= htab_find_slot_with_hash (value_expr_for_decl
, h
, DECL_UID (from
),
6568 *(struct tree_decl_map
**) loc
= h
;
6571 /* Lookup a vector of debug arguments for FROM, and return it if we
6575 decl_debug_args_lookup (tree from
)
6577 struct tree_vec_map
*h
, in
;
6579 if (!DECL_HAS_DEBUG_ARGS_P (from
))
6581 gcc_checking_assert (debug_args_for_decl
!= NULL
);
6582 in
.base
.from
= from
;
6583 h
= (struct tree_vec_map
*)
6584 htab_find_with_hash (debug_args_for_decl
, &in
, DECL_UID (from
));
6590 /* Insert a mapping FROM->empty vector of debug arguments in the value
6591 expression hashtable. */
6594 decl_debug_args_insert (tree from
)
6596 struct tree_vec_map
*h
;
6599 if (DECL_HAS_DEBUG_ARGS_P (from
))
6600 return decl_debug_args_lookup (from
);
6601 if (debug_args_for_decl
== NULL
)
6602 debug_args_for_decl
= htab_create_ggc (64, tree_vec_map_hash
,
6603 tree_vec_map_eq
, 0);
6604 h
= ggc_alloc_tree_vec_map ();
6605 h
->base
.from
= from
;
6607 loc
= htab_find_slot_with_hash (debug_args_for_decl
, h
, DECL_UID (from
),
6609 *(struct tree_vec_map
**) loc
= h
;
6610 DECL_HAS_DEBUG_ARGS_P (from
) = 1;
6614 /* Hashing of types so that we don't make duplicates.
6615 The entry point is `type_hash_canon'. */
6617 /* Compute a hash code for a list of types (chain of TREE_LIST nodes
6618 with types in the TREE_VALUE slots), by adding the hash codes
6619 of the individual types. */
6622 type_hash_list (const_tree list
, hashval_t hashcode
)
6626 for (tail
= list
; tail
; tail
= TREE_CHAIN (tail
))
6627 if (TREE_VALUE (tail
) != error_mark_node
)
6628 hashcode
= iterative_hash_object (TYPE_HASH (TREE_VALUE (tail
)),
6634 /* These are the Hashtable callback functions. */
6636 /* Returns true iff the types are equivalent. */
6639 type_hash_eq (const void *va
, const void *vb
)
6641 const struct type_hash
*const a
= (const struct type_hash
*) va
,
6642 *const b
= (const struct type_hash
*) vb
;
6644 /* First test the things that are the same for all types. */
6645 if (a
->hash
!= b
->hash
6646 || TREE_CODE (a
->type
) != TREE_CODE (b
->type
)
6647 || TREE_TYPE (a
->type
) != TREE_TYPE (b
->type
)
6648 || !attribute_list_equal (TYPE_ATTRIBUTES (a
->type
),
6649 TYPE_ATTRIBUTES (b
->type
))
6650 || (TREE_CODE (a
->type
) != COMPLEX_TYPE
6651 && TYPE_NAME (a
->type
) != TYPE_NAME (b
->type
)))
6654 /* Be careful about comparing arrays before and after the element type
6655 has been completed; don't compare TYPE_ALIGN unless both types are
6657 if (COMPLETE_TYPE_P (a
->type
) && COMPLETE_TYPE_P (b
->type
)
6658 && (TYPE_ALIGN (a
->type
) != TYPE_ALIGN (b
->type
)
6659 || TYPE_MODE (a
->type
) != TYPE_MODE (b
->type
)))
6662 switch (TREE_CODE (a
->type
))
6667 case REFERENCE_TYPE
:
6672 return TYPE_VECTOR_SUBPARTS (a
->type
) == TYPE_VECTOR_SUBPARTS (b
->type
);
6675 if (TYPE_VALUES (a
->type
) != TYPE_VALUES (b
->type
)
6676 && !(TYPE_VALUES (a
->type
)
6677 && TREE_CODE (TYPE_VALUES (a
->type
)) == TREE_LIST
6678 && TYPE_VALUES (b
->type
)
6679 && TREE_CODE (TYPE_VALUES (b
->type
)) == TREE_LIST
6680 && type_list_equal (TYPE_VALUES (a
->type
),
6681 TYPE_VALUES (b
->type
))))
6684 /* ... fall through ... */
6689 return ((TYPE_MAX_VALUE (a
->type
) == TYPE_MAX_VALUE (b
->type
)
6690 || tree_int_cst_equal (TYPE_MAX_VALUE (a
->type
),
6691 TYPE_MAX_VALUE (b
->type
)))
6692 && (TYPE_MIN_VALUE (a
->type
) == TYPE_MIN_VALUE (b
->type
)
6693 || tree_int_cst_equal (TYPE_MIN_VALUE (a
->type
),
6694 TYPE_MIN_VALUE (b
->type
))));
6696 case FIXED_POINT_TYPE
:
6697 return TYPE_SATURATING (a
->type
) == TYPE_SATURATING (b
->type
);
6700 return TYPE_OFFSET_BASETYPE (a
->type
) == TYPE_OFFSET_BASETYPE (b
->type
);
6703 if (TYPE_METHOD_BASETYPE (a
->type
) == TYPE_METHOD_BASETYPE (b
->type
)
6704 && (TYPE_ARG_TYPES (a
->type
) == TYPE_ARG_TYPES (b
->type
)
6705 || (TYPE_ARG_TYPES (a
->type
)
6706 && TREE_CODE (TYPE_ARG_TYPES (a
->type
)) == TREE_LIST
6707 && TYPE_ARG_TYPES (b
->type
)
6708 && TREE_CODE (TYPE_ARG_TYPES (b
->type
)) == TREE_LIST
6709 && type_list_equal (TYPE_ARG_TYPES (a
->type
),
6710 TYPE_ARG_TYPES (b
->type
)))))
6714 return TYPE_DOMAIN (a
->type
) == TYPE_DOMAIN (b
->type
);
6718 case QUAL_UNION_TYPE
:
6719 return (TYPE_FIELDS (a
->type
) == TYPE_FIELDS (b
->type
)
6720 || (TYPE_FIELDS (a
->type
)
6721 && TREE_CODE (TYPE_FIELDS (a
->type
)) == TREE_LIST
6722 && TYPE_FIELDS (b
->type
)
6723 && TREE_CODE (TYPE_FIELDS (b
->type
)) == TREE_LIST
6724 && type_list_equal (TYPE_FIELDS (a
->type
),
6725 TYPE_FIELDS (b
->type
))));
6728 if (TYPE_ARG_TYPES (a
->type
) == TYPE_ARG_TYPES (b
->type
)
6729 || (TYPE_ARG_TYPES (a
->type
)
6730 && TREE_CODE (TYPE_ARG_TYPES (a
->type
)) == TREE_LIST
6731 && TYPE_ARG_TYPES (b
->type
)
6732 && TREE_CODE (TYPE_ARG_TYPES (b
->type
)) == TREE_LIST
6733 && type_list_equal (TYPE_ARG_TYPES (a
->type
),
6734 TYPE_ARG_TYPES (b
->type
))))
6742 if (lang_hooks
.types
.type_hash_eq
!= NULL
)
6743 return lang_hooks
.types
.type_hash_eq (a
->type
, b
->type
);
6748 /* Return the cached hash value. */
6751 type_hash_hash (const void *item
)
6753 return ((const struct type_hash
*) item
)->hash
;
6756 /* Look in the type hash table for a type isomorphic to TYPE.
6757 If one is found, return it. Otherwise return 0. */
6760 type_hash_lookup (hashval_t hashcode
, tree type
)
6762 struct type_hash
*h
, in
;
6764 /* The TYPE_ALIGN field of a type is set by layout_type(), so we
6765 must call that routine before comparing TYPE_ALIGNs. */
6771 h
= (struct type_hash
*) htab_find_with_hash (type_hash_table
, &in
,
6778 /* Add an entry to the type-hash-table
6779 for a type TYPE whose hash code is HASHCODE. */
6782 type_hash_add (hashval_t hashcode
, tree type
)
6784 struct type_hash
*h
;
6787 h
= ggc_alloc_type_hash ();
6790 loc
= htab_find_slot_with_hash (type_hash_table
, h
, hashcode
, INSERT
);
6794 /* Given TYPE, and HASHCODE its hash code, return the canonical
6795 object for an identical type if one already exists.
6796 Otherwise, return TYPE, and record it as the canonical object.
6798 To use this function, first create a type of the sort you want.
6799 Then compute its hash code from the fields of the type that
6800 make it different from other similar types.
6801 Then call this function and use the value. */
6804 type_hash_canon (unsigned int hashcode
, tree type
)
6808 /* The hash table only contains main variants, so ensure that's what we're
6810 gcc_assert (TYPE_MAIN_VARIANT (type
) == type
);
6812 /* See if the type is in the hash table already. If so, return it.
6813 Otherwise, add the type. */
6814 t1
= type_hash_lookup (hashcode
, type
);
6817 if (GATHER_STATISTICS
)
6819 tree_code_counts
[(int) TREE_CODE (type
)]--;
6820 tree_node_counts
[(int) t_kind
]--;
6821 tree_node_sizes
[(int) t_kind
] -= sizeof (struct tree_type_non_common
);
6827 type_hash_add (hashcode
, type
);
6832 /* See if the data pointed to by the type hash table is marked. We consider
6833 it marked if the type is marked or if a debug type number or symbol
6834 table entry has been made for the type. */
6837 type_hash_marked_p (const void *p
)
6839 const_tree
const type
= ((const struct type_hash
*) p
)->type
;
6841 return ggc_marked_p (type
);
6845 print_type_hash_statistics (void)
6847 fprintf (stderr
, "Type hash: size %ld, %ld elements, %f collisions\n",
6848 (long) htab_size (type_hash_table
),
6849 (long) htab_elements (type_hash_table
),
6850 htab_collisions (type_hash_table
));
6853 /* Compute a hash code for a list of attributes (chain of TREE_LIST nodes
6854 with names in the TREE_PURPOSE slots and args in the TREE_VALUE slots),
6855 by adding the hash codes of the individual attributes. */
6858 attribute_hash_list (const_tree list
, hashval_t hashcode
)
6862 for (tail
= list
; tail
; tail
= TREE_CHAIN (tail
))
6863 /* ??? Do we want to add in TREE_VALUE too? */
6864 hashcode
= iterative_hash_object
6865 (IDENTIFIER_HASH_VALUE (get_attribute_name (tail
)), hashcode
);
6869 /* Given two lists of attributes, return true if list l2 is
6870 equivalent to l1. */
6873 attribute_list_equal (const_tree l1
, const_tree l2
)
6878 return attribute_list_contained (l1
, l2
)
6879 && attribute_list_contained (l2
, l1
);
6882 /* Given two lists of attributes, return true if list L2 is
6883 completely contained within L1. */
6884 /* ??? This would be faster if attribute names were stored in a canonicalized
6885 form. Otherwise, if L1 uses `foo' and L2 uses `__foo__', the long method
6886 must be used to show these elements are equivalent (which they are). */
6887 /* ??? It's not clear that attributes with arguments will always be handled
6891 attribute_list_contained (const_tree l1
, const_tree l2
)
6895 /* First check the obvious, maybe the lists are identical. */
6899 /* Maybe the lists are similar. */
6900 for (t1
= l1
, t2
= l2
;
6902 && get_attribute_name (t1
) == get_attribute_name (t2
)
6903 && TREE_VALUE (t1
) == TREE_VALUE (t2
);
6904 t1
= TREE_CHAIN (t1
), t2
= TREE_CHAIN (t2
))
6907 /* Maybe the lists are equal. */
6908 if (t1
== 0 && t2
== 0)
6911 for (; t2
!= 0; t2
= TREE_CHAIN (t2
))
6914 /* This CONST_CAST is okay because lookup_attribute does not
6915 modify its argument and the return value is assigned to a
6917 for (attr
= lookup_ident_attribute (get_attribute_name (t2
),
6918 CONST_CAST_TREE (l1
));
6919 attr
!= NULL_TREE
&& !attribute_value_equal (t2
, attr
);
6920 attr
= lookup_ident_attribute (get_attribute_name (t2
),
6924 if (attr
== NULL_TREE
)
6931 /* Given two lists of types
6932 (chains of TREE_LIST nodes with types in the TREE_VALUE slots)
6933 return 1 if the lists contain the same types in the same order.
6934 Also, the TREE_PURPOSEs must match. */
6937 type_list_equal (const_tree l1
, const_tree l2
)
6941 for (t1
= l1
, t2
= l2
; t1
&& t2
; t1
= TREE_CHAIN (t1
), t2
= TREE_CHAIN (t2
))
6942 if (TREE_VALUE (t1
) != TREE_VALUE (t2
)
6943 || (TREE_PURPOSE (t1
) != TREE_PURPOSE (t2
)
6944 && ! (1 == simple_cst_equal (TREE_PURPOSE (t1
), TREE_PURPOSE (t2
))
6945 && (TREE_TYPE (TREE_PURPOSE (t1
))
6946 == TREE_TYPE (TREE_PURPOSE (t2
))))))
6952 /* Returns the number of arguments to the FUNCTION_TYPE or METHOD_TYPE
6953 given by TYPE. If the argument list accepts variable arguments,
6954 then this function counts only the ordinary arguments. */
6957 type_num_arguments (const_tree type
)
6962 for (t
= TYPE_ARG_TYPES (type
); t
; t
= TREE_CHAIN (t
))
6963 /* If the function does not take a variable number of arguments,
6964 the last element in the list will have type `void'. */
6965 if (VOID_TYPE_P (TREE_VALUE (t
)))
6973 /* Nonzero if integer constants T1 and T2
6974 represent the same constant value. */
6977 tree_int_cst_equal (const_tree t1
, const_tree t2
)
6982 if (t1
== 0 || t2
== 0)
6985 if (TREE_CODE (t1
) == INTEGER_CST
6986 && TREE_CODE (t2
) == INTEGER_CST
6987 && TREE_INT_CST_LOW (t1
) == TREE_INT_CST_LOW (t2
)
6988 && TREE_INT_CST_HIGH (t1
) == TREE_INT_CST_HIGH (t2
))
6994 /* Nonzero if integer constants T1 and T2 represent values that satisfy <.
6995 The precise way of comparison depends on their data type. */
6998 tree_int_cst_lt (const_tree t1
, const_tree t2
)
7003 if (TYPE_UNSIGNED (TREE_TYPE (t1
)) != TYPE_UNSIGNED (TREE_TYPE (t2
)))
7005 int t1_sgn
= tree_int_cst_sgn (t1
);
7006 int t2_sgn
= tree_int_cst_sgn (t2
);
7008 if (t1_sgn
< t2_sgn
)
7010 else if (t1_sgn
> t2_sgn
)
7012 /* Otherwise, both are non-negative, so we compare them as
7013 unsigned just in case one of them would overflow a signed
7016 else if (!TYPE_UNSIGNED (TREE_TYPE (t1
)))
7017 return INT_CST_LT (t1
, t2
);
7019 return INT_CST_LT_UNSIGNED (t1
, t2
);
7022 /* Returns -1 if T1 < T2, 0 if T1 == T2, and 1 if T1 > T2. */
7025 tree_int_cst_compare (const_tree t1
, const_tree t2
)
7027 if (tree_int_cst_lt (t1
, t2
))
7029 else if (tree_int_cst_lt (t2
, t1
))
7035 /* Return true if T is an INTEGER_CST whose numerical value (extended
7036 according to TYPE_UNSIGNED) fits in a signed HOST_WIDE_INT. */
7039 tree_fits_shwi_p (const_tree t
)
7041 return (t
!= NULL_TREE
7042 && TREE_CODE (t
) == INTEGER_CST
7043 && ((TREE_INT_CST_HIGH (t
) == 0
7044 && (HOST_WIDE_INT
) TREE_INT_CST_LOW (t
) >= 0)
7045 || (TREE_INT_CST_HIGH (t
) == -1
7046 && (HOST_WIDE_INT
) TREE_INT_CST_LOW (t
) < 0
7047 && !TYPE_UNSIGNED (TREE_TYPE (t
)))));
7050 /* Return true if T is an INTEGER_CST whose numerical value (extended
7051 according to TYPE_UNSIGNED) fits in an unsigned HOST_WIDE_INT. */
7054 tree_fits_uhwi_p (const_tree t
)
7056 return (t
!= NULL_TREE
7057 && TREE_CODE (t
) == INTEGER_CST
7058 && TREE_INT_CST_HIGH (t
) == 0);
7061 /* T is an INTEGER_CST whose numerical value (extended according to
7062 TYPE_UNSIGNED) fits in a signed HOST_WIDE_INT. Return that
7066 tree_to_shwi (const_tree t
)
7068 gcc_assert (tree_fits_shwi_p (t
));
7069 return TREE_INT_CST_LOW (t
);
7072 /* T is an INTEGER_CST whose numerical value (extended according to
7073 TYPE_UNSIGNED) fits in an unsigned HOST_WIDE_INT. Return that
7076 unsigned HOST_WIDE_INT
7077 tree_to_uhwi (const_tree t
)
7079 gcc_assert (tree_fits_uhwi_p (t
));
7080 return TREE_INT_CST_LOW (t
);
7083 /* Return the most significant (sign) bit of T. */
7086 tree_int_cst_sign_bit (const_tree t
)
7088 unsigned bitno
= TYPE_PRECISION (TREE_TYPE (t
)) - 1;
7089 unsigned HOST_WIDE_INT w
;
7091 if (bitno
< HOST_BITS_PER_WIDE_INT
)
7092 w
= TREE_INT_CST_LOW (t
);
7095 w
= TREE_INT_CST_HIGH (t
);
7096 bitno
-= HOST_BITS_PER_WIDE_INT
;
7099 return (w
>> bitno
) & 1;
7102 /* Return an indication of the sign of the integer constant T.
7103 The return value is -1 if T < 0, 0 if T == 0, and 1 if T > 0.
7104 Note that -1 will never be returned if T's type is unsigned. */
7107 tree_int_cst_sgn (const_tree t
)
7109 if (TREE_INT_CST_LOW (t
) == 0 && TREE_INT_CST_HIGH (t
) == 0)
7111 else if (TYPE_UNSIGNED (TREE_TYPE (t
)))
7113 else if (TREE_INT_CST_HIGH (t
) < 0)
7119 /* Return the minimum number of bits needed to represent VALUE in a
7120 signed or unsigned type, UNSIGNEDP says which. */
7123 tree_int_cst_min_precision (tree value
, bool unsignedp
)
7125 /* If the value is negative, compute its negative minus 1. The latter
7126 adjustment is because the absolute value of the largest negative value
7127 is one larger than the largest positive value. This is equivalent to
7128 a bit-wise negation, so use that operation instead. */
7130 if (tree_int_cst_sgn (value
) < 0)
7131 value
= fold_build1 (BIT_NOT_EXPR
, TREE_TYPE (value
), value
);
7133 /* Return the number of bits needed, taking into account the fact
7134 that we need one more bit for a signed than unsigned type.
7135 If value is 0 or -1, the minimum precision is 1 no matter
7136 whether unsignedp is true or false. */
7138 if (integer_zerop (value
))
7141 return tree_floor_log2 (value
) + 1 + !unsignedp
;
7144 /* Return truthvalue of whether T1 is the same tree structure as T2.
7145 Return 1 if they are the same.
7146 Return 0 if they are understandably different.
7147 Return -1 if either contains tree structure not understood by
7151 simple_cst_equal (const_tree t1
, const_tree t2
)
7153 enum tree_code code1
, code2
;
7159 if (t1
== 0 || t2
== 0)
7162 code1
= TREE_CODE (t1
);
7163 code2
= TREE_CODE (t2
);
7165 if (CONVERT_EXPR_CODE_P (code1
) || code1
== NON_LVALUE_EXPR
)
7167 if (CONVERT_EXPR_CODE_P (code2
)
7168 || code2
== NON_LVALUE_EXPR
)
7169 return simple_cst_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
7171 return simple_cst_equal (TREE_OPERAND (t1
, 0), t2
);
7174 else if (CONVERT_EXPR_CODE_P (code2
)
7175 || code2
== NON_LVALUE_EXPR
)
7176 return simple_cst_equal (t1
, TREE_OPERAND (t2
, 0));
7184 return (TREE_INT_CST_LOW (t1
) == TREE_INT_CST_LOW (t2
)
7185 && TREE_INT_CST_HIGH (t1
) == TREE_INT_CST_HIGH (t2
));
7188 return REAL_VALUES_IDENTICAL (TREE_REAL_CST (t1
), TREE_REAL_CST (t2
));
7191 return FIXED_VALUES_IDENTICAL (TREE_FIXED_CST (t1
), TREE_FIXED_CST (t2
));
7194 return (TREE_STRING_LENGTH (t1
) == TREE_STRING_LENGTH (t2
)
7195 && ! memcmp (TREE_STRING_POINTER (t1
), TREE_STRING_POINTER (t2
),
7196 TREE_STRING_LENGTH (t1
)));
7200 unsigned HOST_WIDE_INT idx
;
7201 vec
<constructor_elt
, va_gc
> *v1
= CONSTRUCTOR_ELTS (t1
);
7202 vec
<constructor_elt
, va_gc
> *v2
= CONSTRUCTOR_ELTS (t2
);
7204 if (vec_safe_length (v1
) != vec_safe_length (v2
))
7207 for (idx
= 0; idx
< vec_safe_length (v1
); ++idx
)
7208 /* ??? Should we handle also fields here? */
7209 if (!simple_cst_equal ((*v1
)[idx
].value
, (*v2
)[idx
].value
))
7215 return simple_cst_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
7218 cmp
= simple_cst_equal (CALL_EXPR_FN (t1
), CALL_EXPR_FN (t2
));
7221 if (call_expr_nargs (t1
) != call_expr_nargs (t2
))
7224 const_tree arg1
, arg2
;
7225 const_call_expr_arg_iterator iter1
, iter2
;
7226 for (arg1
= first_const_call_expr_arg (t1
, &iter1
),
7227 arg2
= first_const_call_expr_arg (t2
, &iter2
);
7229 arg1
= next_const_call_expr_arg (&iter1
),
7230 arg2
= next_const_call_expr_arg (&iter2
))
7232 cmp
= simple_cst_equal (arg1
, arg2
);
7236 return arg1
== arg2
;
7240 /* Special case: if either target is an unallocated VAR_DECL,
7241 it means that it's going to be unified with whatever the
7242 TARGET_EXPR is really supposed to initialize, so treat it
7243 as being equivalent to anything. */
7244 if ((TREE_CODE (TREE_OPERAND (t1
, 0)) == VAR_DECL
7245 && DECL_NAME (TREE_OPERAND (t1
, 0)) == NULL_TREE
7246 && !DECL_RTL_SET_P (TREE_OPERAND (t1
, 0)))
7247 || (TREE_CODE (TREE_OPERAND (t2
, 0)) == VAR_DECL
7248 && DECL_NAME (TREE_OPERAND (t2
, 0)) == NULL_TREE
7249 && !DECL_RTL_SET_P (TREE_OPERAND (t2
, 0))))
7252 cmp
= simple_cst_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
7257 return simple_cst_equal (TREE_OPERAND (t1
, 1), TREE_OPERAND (t2
, 1));
7259 case WITH_CLEANUP_EXPR
:
7260 cmp
= simple_cst_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
7264 return simple_cst_equal (TREE_OPERAND (t1
, 1), TREE_OPERAND (t1
, 1));
7267 if (TREE_OPERAND (t1
, 1) == TREE_OPERAND (t2
, 1))
7268 return simple_cst_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
7282 /* This general rule works for most tree codes. All exceptions should be
7283 handled above. If this is a language-specific tree code, we can't
7284 trust what might be in the operand, so say we don't know
7286 if ((int) code1
>= (int) LAST_AND_UNUSED_TREE_CODE
)
7289 switch (TREE_CODE_CLASS (code1
))
7293 case tcc_comparison
:
7294 case tcc_expression
:
7298 for (i
= 0; i
< TREE_CODE_LENGTH (code1
); i
++)
7300 cmp
= simple_cst_equal (TREE_OPERAND (t1
, i
), TREE_OPERAND (t2
, i
));
7312 /* Compare the value of T, an INTEGER_CST, with U, an unsigned integer value.
7313 Return -1, 0, or 1 if the value of T is less than, equal to, or greater
7314 than U, respectively. */
7317 compare_tree_int (const_tree t
, unsigned HOST_WIDE_INT u
)
7319 if (tree_int_cst_sgn (t
) < 0)
7321 else if (TREE_INT_CST_HIGH (t
) != 0)
7323 else if (TREE_INT_CST_LOW (t
) == u
)
7325 else if (TREE_INT_CST_LOW (t
) < u
)
7331 /* Return true if SIZE represents a constant size that is in bounds of
7332 what the middle-end and the backend accepts (covering not more than
7333 half of the address-space). */
7336 valid_constant_size_p (const_tree size
)
7338 if (! tree_fits_uhwi_p (size
)
7339 || TREE_OVERFLOW (size
)
7340 || tree_int_cst_sign_bit (size
) != 0)
7345 /* Return the precision of the type, or for a complex or vector type the
7346 precision of the type of its elements. */
7349 element_precision (const_tree type
)
7351 enum tree_code code
= TREE_CODE (type
);
7352 if (code
== COMPLEX_TYPE
|| code
== VECTOR_TYPE
)
7353 type
= TREE_TYPE (type
);
7355 return TYPE_PRECISION (type
);
7358 /* Return true if CODE represents an associative tree code. Otherwise
7361 associative_tree_code (enum tree_code code
)
7380 /* Return true if CODE represents a commutative tree code. Otherwise
7383 commutative_tree_code (enum tree_code code
)
7389 case MULT_HIGHPART_EXPR
:
7397 case UNORDERED_EXPR
:
7401 case TRUTH_AND_EXPR
:
7402 case TRUTH_XOR_EXPR
:
7404 case WIDEN_MULT_EXPR
:
7405 case VEC_WIDEN_MULT_HI_EXPR
:
7406 case VEC_WIDEN_MULT_LO_EXPR
:
7407 case VEC_WIDEN_MULT_EVEN_EXPR
:
7408 case VEC_WIDEN_MULT_ODD_EXPR
:
7417 /* Return true if CODE represents a ternary tree code for which the
7418 first two operands are commutative. Otherwise return false. */
7420 commutative_ternary_tree_code (enum tree_code code
)
7424 case WIDEN_MULT_PLUS_EXPR
:
7425 case WIDEN_MULT_MINUS_EXPR
:
7434 /* Generate a hash value for an expression. This can be used iteratively
7435 by passing a previous result as the VAL argument.
7437 This function is intended to produce the same hash for expressions which
7438 would compare equal using operand_equal_p. */
7441 iterative_hash_expr (const_tree t
, hashval_t val
)
7444 enum tree_code code
;
7445 enum tree_code_class tclass
;
7448 return iterative_hash_hashval_t (0, val
);
7450 code
= TREE_CODE (t
);
7454 /* Alas, constants aren't shared, so we can't rely on pointer
7457 val
= iterative_hash_host_wide_int (TREE_INT_CST_LOW (t
), val
);
7458 return iterative_hash_host_wide_int (TREE_INT_CST_HIGH (t
), val
);
7461 unsigned int val2
= real_hash (TREE_REAL_CST_PTR (t
));
7463 return iterative_hash_hashval_t (val2
, val
);
7467 unsigned int val2
= fixed_hash (TREE_FIXED_CST_PTR (t
));
7469 return iterative_hash_hashval_t (val2
, val
);
7472 return iterative_hash (TREE_STRING_POINTER (t
),
7473 TREE_STRING_LENGTH (t
), val
);
7475 val
= iterative_hash_expr (TREE_REALPART (t
), val
);
7476 return iterative_hash_expr (TREE_IMAGPART (t
), val
);
7480 for (i
= 0; i
< VECTOR_CST_NELTS (t
); ++i
)
7481 val
= iterative_hash_expr (VECTOR_CST_ELT (t
, i
), val
);
7485 /* We can just compare by pointer. */
7486 return iterative_hash_host_wide_int (SSA_NAME_VERSION (t
), val
);
7487 case PLACEHOLDER_EXPR
:
7488 /* The node itself doesn't matter. */
7491 /* A list of expressions, for a CALL_EXPR or as the elements of a
7493 for (; t
; t
= TREE_CHAIN (t
))
7494 val
= iterative_hash_expr (TREE_VALUE (t
), val
);
7498 unsigned HOST_WIDE_INT idx
;
7500 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t
), idx
, field
, value
)
7502 val
= iterative_hash_expr (field
, val
);
7503 val
= iterative_hash_expr (value
, val
);
7508 /* When referring to a built-in FUNCTION_DECL, use the __builtin__ form.
7509 Otherwise nodes that compare equal according to operand_equal_p might
7510 get different hash codes. However, don't do this for machine specific
7511 or front end builtins, since the function code is overloaded in those
7513 if (DECL_BUILT_IN_CLASS (t
) == BUILT_IN_NORMAL
7514 && builtin_decl_explicit_p (DECL_FUNCTION_CODE (t
)))
7516 t
= builtin_decl_explicit (DECL_FUNCTION_CODE (t
));
7517 code
= TREE_CODE (t
);
7521 tclass
= TREE_CODE_CLASS (code
);
7523 if (tclass
== tcc_declaration
)
7525 /* DECL's have a unique ID */
7526 val
= iterative_hash_host_wide_int (DECL_UID (t
), val
);
7530 gcc_assert (IS_EXPR_CODE_CLASS (tclass
));
7532 val
= iterative_hash_object (code
, val
);
7534 /* Don't hash the type, that can lead to having nodes which
7535 compare equal according to operand_equal_p, but which
7536 have different hash codes. */
7537 if (CONVERT_EXPR_CODE_P (code
)
7538 || code
== NON_LVALUE_EXPR
)
7540 /* Make sure to include signness in the hash computation. */
7541 val
+= TYPE_UNSIGNED (TREE_TYPE (t
));
7542 val
= iterative_hash_expr (TREE_OPERAND (t
, 0), val
);
7545 else if (commutative_tree_code (code
))
7547 /* It's a commutative expression. We want to hash it the same
7548 however it appears. We do this by first hashing both operands
7549 and then rehashing based on the order of their independent
7551 hashval_t one
= iterative_hash_expr (TREE_OPERAND (t
, 0), 0);
7552 hashval_t two
= iterative_hash_expr (TREE_OPERAND (t
, 1), 0);
7556 t
= one
, one
= two
, two
= t
;
7558 val
= iterative_hash_hashval_t (one
, val
);
7559 val
= iterative_hash_hashval_t (two
, val
);
7562 for (i
= TREE_OPERAND_LENGTH (t
) - 1; i
>= 0; --i
)
7563 val
= iterative_hash_expr (TREE_OPERAND (t
, i
), val
);
7569 /* Constructors for pointer, array and function types.
7570 (RECORD_TYPE, UNION_TYPE and ENUMERAL_TYPE nodes are
7571 constructed by language-dependent code, not here.) */
7573 /* Construct, lay out and return the type of pointers to TO_TYPE with
7574 mode MODE. If CAN_ALIAS_ALL is TRUE, indicate this type can
7575 reference all of memory. If such a type has already been
7576 constructed, reuse it. */
7579 build_pointer_type_for_mode (tree to_type
, enum machine_mode mode
,
7584 if (to_type
== error_mark_node
)
7585 return error_mark_node
;
7587 /* If the pointed-to type has the may_alias attribute set, force
7588 a TYPE_REF_CAN_ALIAS_ALL pointer to be generated. */
7589 if (lookup_attribute ("may_alias", TYPE_ATTRIBUTES (to_type
)))
7590 can_alias_all
= true;
7592 /* In some cases, languages will have things that aren't a POINTER_TYPE
7593 (such as a RECORD_TYPE for fat pointers in Ada) as TYPE_POINTER_TO.
7594 In that case, return that type without regard to the rest of our
7597 ??? This is a kludge, but consistent with the way this function has
7598 always operated and there doesn't seem to be a good way to avoid this
7600 if (TYPE_POINTER_TO (to_type
) != 0
7601 && TREE_CODE (TYPE_POINTER_TO (to_type
)) != POINTER_TYPE
)
7602 return TYPE_POINTER_TO (to_type
);
7604 /* First, if we already have a type for pointers to TO_TYPE and it's
7605 the proper mode, use it. */
7606 for (t
= TYPE_POINTER_TO (to_type
); t
; t
= TYPE_NEXT_PTR_TO (t
))
7607 if (TYPE_MODE (t
) == mode
&& TYPE_REF_CAN_ALIAS_ALL (t
) == can_alias_all
)
7610 t
= make_node (POINTER_TYPE
);
7612 TREE_TYPE (t
) = to_type
;
7613 SET_TYPE_MODE (t
, mode
);
7614 TYPE_REF_CAN_ALIAS_ALL (t
) = can_alias_all
;
7615 TYPE_NEXT_PTR_TO (t
) = TYPE_POINTER_TO (to_type
);
7616 TYPE_POINTER_TO (to_type
) = t
;
7618 if (TYPE_STRUCTURAL_EQUALITY_P (to_type
))
7619 SET_TYPE_STRUCTURAL_EQUALITY (t
);
7620 else if (TYPE_CANONICAL (to_type
) != to_type
)
7622 = build_pointer_type_for_mode (TYPE_CANONICAL (to_type
),
7623 mode
, can_alias_all
);
7625 /* Lay out the type. This function has many callers that are concerned
7626 with expression-construction, and this simplifies them all. */
7632 /* By default build pointers in ptr_mode. */
7635 build_pointer_type (tree to_type
)
7637 addr_space_t as
= to_type
== error_mark_node
? ADDR_SPACE_GENERIC
7638 : TYPE_ADDR_SPACE (to_type
);
7639 enum machine_mode pointer_mode
= targetm
.addr_space
.pointer_mode (as
);
7640 if (upc_shared_type_p (to_type
))
7643 pointer_mode
= TYPE_MODE (upc_pts_rep_type_node
);
7644 upc_pts_type
= build_pointer_type_for_mode (to_type
, pointer_mode
,
7646 TYPE_USER_ALIGN (upc_pts_type
) = TYPE_USER_ALIGN (upc_pts_rep_type_node
);
7647 TYPE_ALIGN (upc_pts_type
) = TYPE_ALIGN (upc_pts_rep_type_node
);
7648 return upc_pts_type
;
7650 return build_pointer_type_for_mode (to_type
, pointer_mode
, false);
7653 /* Same as build_pointer_type_for_mode, but for REFERENCE_TYPE. */
7656 build_reference_type_for_mode (tree to_type
, enum machine_mode mode
,
7661 if (to_type
== error_mark_node
)
7662 return error_mark_node
;
7664 /* If the pointed-to type has the may_alias attribute set, force
7665 a TYPE_REF_CAN_ALIAS_ALL pointer to be generated. */
7666 if (lookup_attribute ("may_alias", TYPE_ATTRIBUTES (to_type
)))
7667 can_alias_all
= true;
7669 /* In some cases, languages will have things that aren't a REFERENCE_TYPE
7670 (such as a RECORD_TYPE for fat pointers in Ada) as TYPE_REFERENCE_TO.
7671 In that case, return that type without regard to the rest of our
7674 ??? This is a kludge, but consistent with the way this function has
7675 always operated and there doesn't seem to be a good way to avoid this
7677 if (TYPE_REFERENCE_TO (to_type
) != 0
7678 && TREE_CODE (TYPE_REFERENCE_TO (to_type
)) != REFERENCE_TYPE
)
7679 return TYPE_REFERENCE_TO (to_type
);
7681 /* First, if we already have a type for pointers to TO_TYPE and it's
7682 the proper mode, use it. */
7683 for (t
= TYPE_REFERENCE_TO (to_type
); t
; t
= TYPE_NEXT_REF_TO (t
))
7684 if (TYPE_MODE (t
) == mode
&& TYPE_REF_CAN_ALIAS_ALL (t
) == can_alias_all
)
7687 t
= make_node (REFERENCE_TYPE
);
7689 TREE_TYPE (t
) = to_type
;
7690 SET_TYPE_MODE (t
, mode
);
7691 TYPE_REF_CAN_ALIAS_ALL (t
) = can_alias_all
;
7692 TYPE_NEXT_REF_TO (t
) = TYPE_REFERENCE_TO (to_type
);
7693 TYPE_REFERENCE_TO (to_type
) = t
;
7695 if (TYPE_STRUCTURAL_EQUALITY_P (to_type
))
7696 SET_TYPE_STRUCTURAL_EQUALITY (t
);
7697 else if (TYPE_CANONICAL (to_type
) != to_type
)
7699 = build_reference_type_for_mode (TYPE_CANONICAL (to_type
),
7700 mode
, can_alias_all
);
7708 /* Build the node for the type of references-to-TO_TYPE by default
7712 build_reference_type (tree to_type
)
7714 addr_space_t as
= to_type
== error_mark_node
? ADDR_SPACE_GENERIC
7715 : TYPE_ADDR_SPACE (to_type
);
7716 enum machine_mode pointer_mode
= targetm
.addr_space
.pointer_mode (as
);
7717 return build_reference_type_for_mode (to_type
, pointer_mode
, false);
7720 #define MAX_INT_CACHED_PREC \
7721 (HOST_BITS_PER_WIDE_INT > 64 ? HOST_BITS_PER_WIDE_INT : 64)
7722 static GTY(()) tree nonstandard_integer_type_cache
[2 * MAX_INT_CACHED_PREC
+ 2];
7724 /* Builds a signed or unsigned integer type of precision PRECISION.
7725 Used for C bitfields whose precision does not match that of
7726 built-in target types. */
7728 build_nonstandard_integer_type (unsigned HOST_WIDE_INT precision
,
7734 unsignedp
= MAX_INT_CACHED_PREC
+ 1;
7736 if (precision
<= MAX_INT_CACHED_PREC
)
7738 itype
= nonstandard_integer_type_cache
[precision
+ unsignedp
];
7743 itype
= make_node (INTEGER_TYPE
);
7744 TYPE_PRECISION (itype
) = precision
;
7747 fixup_unsigned_type (itype
);
7749 fixup_signed_type (itype
);
7752 if (tree_fits_uhwi_p (TYPE_MAX_VALUE (itype
)))
7753 ret
= type_hash_canon (tree_to_uhwi (TYPE_MAX_VALUE (itype
)), itype
);
7754 if (precision
<= MAX_INT_CACHED_PREC
)
7755 nonstandard_integer_type_cache
[precision
+ unsignedp
] = ret
;
7760 /* Create a range of some discrete type TYPE (an INTEGER_TYPE, ENUMERAL_TYPE
7761 or BOOLEAN_TYPE) with low bound LOWVAL and high bound HIGHVAL. If SHARED
7762 is true, reuse such a type that has already been constructed. */
7765 build_range_type_1 (tree type
, tree lowval
, tree highval
, bool shared
)
7767 tree itype
= make_node (INTEGER_TYPE
);
7768 hashval_t hashcode
= 0;
7770 TREE_TYPE (itype
) = type
;
7772 TYPE_MIN_VALUE (itype
) = fold_convert (type
, lowval
);
7773 TYPE_MAX_VALUE (itype
) = highval
? fold_convert (type
, highval
) : NULL
;
7775 TYPE_PRECISION (itype
) = TYPE_PRECISION (type
);
7776 SET_TYPE_MODE (itype
, TYPE_MODE (type
));
7777 TYPE_SIZE (itype
) = TYPE_SIZE (type
);
7778 TYPE_SIZE_UNIT (itype
) = TYPE_SIZE_UNIT (type
);
7779 TYPE_ALIGN (itype
) = TYPE_ALIGN (type
);
7780 TYPE_USER_ALIGN (itype
) = TYPE_USER_ALIGN (type
);
7785 if ((TYPE_MIN_VALUE (itype
)
7786 && TREE_CODE (TYPE_MIN_VALUE (itype
)) != INTEGER_CST
)
7787 || (TYPE_MAX_VALUE (itype
)
7788 && TREE_CODE (TYPE_MAX_VALUE (itype
)) != INTEGER_CST
))
7790 /* Since we cannot reliably merge this type, we need to compare it using
7791 structural equality checks. */
7792 SET_TYPE_STRUCTURAL_EQUALITY (itype
);
7796 hashcode
= iterative_hash_expr (TYPE_MIN_VALUE (itype
), hashcode
);
7797 hashcode
= iterative_hash_expr (TYPE_MAX_VALUE (itype
), hashcode
);
7798 hashcode
= iterative_hash_hashval_t (TYPE_HASH (type
), hashcode
);
7799 itype
= type_hash_canon (hashcode
, itype
);
7804 /* Wrapper around build_range_type_1 with SHARED set to true. */
7807 build_range_type (tree type
, tree lowval
, tree highval
)
7809 return build_range_type_1 (type
, lowval
, highval
, true);
7812 /* Wrapper around build_range_type_1 with SHARED set to false. */
7815 build_nonshared_range_type (tree type
, tree lowval
, tree highval
)
7817 return build_range_type_1 (type
, lowval
, highval
, false);
7820 /* Create a type of integers to be the TYPE_DOMAIN of an ARRAY_TYPE.
7821 MAXVAL should be the maximum value in the domain
7822 (one less than the length of the array).
7824 The maximum value that MAXVAL can have is INT_MAX for a HOST_WIDE_INT.
7825 We don't enforce this limit, that is up to caller (e.g. language front end).
7826 The limit exists because the result is a signed type and we don't handle
7827 sizes that use more than one HOST_WIDE_INT. */
7830 build_index_type (tree maxval
)
7832 return build_range_type (sizetype
, size_zero_node
, maxval
);
7835 /* Return true if the debug information for TYPE, a subtype, should be emitted
7836 as a subrange type. If so, set LOWVAL to the low bound and HIGHVAL to the
7837 high bound, respectively. Sometimes doing so unnecessarily obfuscates the
7838 debug info and doesn't reflect the source code. */
7841 subrange_type_for_debug_p (const_tree type
, tree
*lowval
, tree
*highval
)
7843 tree base_type
= TREE_TYPE (type
), low
, high
;
7845 /* Subrange types have a base type which is an integral type. */
7846 if (!INTEGRAL_TYPE_P (base_type
))
7849 /* Get the real bounds of the subtype. */
7850 if (lang_hooks
.types
.get_subrange_bounds
)
7851 lang_hooks
.types
.get_subrange_bounds (type
, &low
, &high
);
7854 low
= TYPE_MIN_VALUE (type
);
7855 high
= TYPE_MAX_VALUE (type
);
7858 /* If the type and its base type have the same representation and the same
7859 name, then the type is not a subrange but a copy of the base type. */
7860 if ((TREE_CODE (base_type
) == INTEGER_TYPE
7861 || TREE_CODE (base_type
) == BOOLEAN_TYPE
)
7862 && int_size_in_bytes (type
) == int_size_in_bytes (base_type
)
7863 && tree_int_cst_equal (low
, TYPE_MIN_VALUE (base_type
))
7864 && tree_int_cst_equal (high
, TYPE_MAX_VALUE (base_type
))
7865 && TYPE_IDENTIFIER (type
) == TYPE_IDENTIFIER (base_type
))
7875 /* Construct, lay out and return the type of arrays of elements with ELT_TYPE
7876 and number of elements specified by the range of values of INDEX_TYPE.
7877 If SHARED is true, reuse such a type that has already been constructed. */
7880 build_array_type_1 (tree elt_type
, tree index_type
, bool shared
)
7884 if (TREE_CODE (elt_type
) == FUNCTION_TYPE
)
7886 error ("arrays of functions are not meaningful");
7887 elt_type
= integer_type_node
;
7890 t
= make_node (ARRAY_TYPE
);
7891 TREE_TYPE (t
) = elt_type
;
7892 TYPE_DOMAIN (t
) = index_type
;
7893 TYPE_ADDR_SPACE (t
) = TYPE_ADDR_SPACE (elt_type
);
7896 /* If the element type is incomplete at this point we get marked for
7897 structural equality. Do not record these types in the canonical
7899 if (TYPE_STRUCTURAL_EQUALITY_P (t
))
7904 hashval_t hashcode
= iterative_hash_object (TYPE_HASH (elt_type
), 0);
7906 hashcode
= iterative_hash_object (TYPE_HASH (index_type
), hashcode
);
7907 t
= type_hash_canon (hashcode
, t
);
7910 if (TYPE_CANONICAL (t
) == t
)
7912 if (TYPE_STRUCTURAL_EQUALITY_P (elt_type
)
7913 || (index_type
&& TYPE_STRUCTURAL_EQUALITY_P (index_type
)))
7914 SET_TYPE_STRUCTURAL_EQUALITY (t
);
7915 else if (TYPE_CANONICAL (elt_type
) != elt_type
7916 || (index_type
&& TYPE_CANONICAL (index_type
) != index_type
))
7918 = build_array_type_1 (TYPE_CANONICAL (elt_type
),
7920 ? TYPE_CANONICAL (index_type
) : NULL_TREE
,
7927 /* Wrapper around build_array_type_1 with SHARED set to true. */
7930 build_array_type (tree elt_type
, tree index_type
)
7932 return build_array_type_1 (elt_type
, index_type
, true);
7935 /* Wrapper around build_array_type_1 with SHARED set to false. */
7938 build_nonshared_array_type (tree elt_type
, tree index_type
)
7940 return build_array_type_1 (elt_type
, index_type
, false);
7943 /* Return a representation of ELT_TYPE[NELTS], using indices of type
7947 build_array_type_nelts (tree elt_type
, unsigned HOST_WIDE_INT nelts
)
7949 return build_array_type (elt_type
, build_index_type (size_int (nelts
- 1)));
7952 /* Recursively examines the array elements of TYPE, until a non-array
7953 element type is found. */
7956 strip_array_types (tree type
)
7958 while (TREE_CODE (type
) == ARRAY_TYPE
)
7959 type
= TREE_TYPE (type
);
7964 /* Computes the canonical argument types from the argument type list
7967 Upon return, *ANY_STRUCTURAL_P will be true iff either it was true
7968 on entry to this function, or if any of the ARGTYPES are
7971 Upon return, *ANY_NONCANONICAL_P will be true iff either it was
7972 true on entry to this function, or if any of the ARGTYPES are
7975 Returns a canonical argument list, which may be ARGTYPES when the
7976 canonical argument list is unneeded (i.e., *ANY_STRUCTURAL_P is
7977 true) or would not differ from ARGTYPES. */
7980 maybe_canonicalize_argtypes (tree argtypes
,
7981 bool *any_structural_p
,
7982 bool *any_noncanonical_p
)
7985 bool any_noncanonical_argtypes_p
= false;
7987 for (arg
= argtypes
; arg
&& !(*any_structural_p
); arg
= TREE_CHAIN (arg
))
7989 if (!TREE_VALUE (arg
) || TREE_VALUE (arg
) == error_mark_node
)
7990 /* Fail gracefully by stating that the type is structural. */
7991 *any_structural_p
= true;
7992 else if (TYPE_STRUCTURAL_EQUALITY_P (TREE_VALUE (arg
)))
7993 *any_structural_p
= true;
7994 else if (TYPE_CANONICAL (TREE_VALUE (arg
)) != TREE_VALUE (arg
)
7995 || TREE_PURPOSE (arg
))
7996 /* If the argument has a default argument, we consider it
7997 non-canonical even though the type itself is canonical.
7998 That way, different variants of function and method types
7999 with default arguments will all point to the variant with
8000 no defaults as their canonical type. */
8001 any_noncanonical_argtypes_p
= true;
8004 if (*any_structural_p
)
8007 if (any_noncanonical_argtypes_p
)
8009 /* Build the canonical list of argument types. */
8010 tree canon_argtypes
= NULL_TREE
;
8011 bool is_void
= false;
8013 for (arg
= argtypes
; arg
; arg
= TREE_CHAIN (arg
))
8015 if (arg
== void_list_node
)
8018 canon_argtypes
= tree_cons (NULL_TREE
,
8019 TYPE_CANONICAL (TREE_VALUE (arg
)),
8023 canon_argtypes
= nreverse (canon_argtypes
);
8025 canon_argtypes
= chainon (canon_argtypes
, void_list_node
);
8027 /* There is a non-canonical type. */
8028 *any_noncanonical_p
= true;
8029 return canon_argtypes
;
8032 /* The canonical argument types are the same as ARGTYPES. */
8036 /* Construct, lay out and return
8037 the type of functions returning type VALUE_TYPE
8038 given arguments of types ARG_TYPES.
8039 ARG_TYPES is a chain of TREE_LIST nodes whose TREE_VALUEs
8040 are data type nodes for the arguments of the function.
8041 If such a type has already been constructed, reuse it. */
8044 build_function_type (tree value_type
, tree arg_types
)
8047 hashval_t hashcode
= 0;
8048 bool any_structural_p
, any_noncanonical_p
;
8049 tree canon_argtypes
;
8051 if (TREE_CODE (value_type
) == FUNCTION_TYPE
)
8053 error ("function return type cannot be function");
8054 value_type
= integer_type_node
;
8057 /* Make a node of the sort we want. */
8058 t
= make_node (FUNCTION_TYPE
);
8059 TREE_TYPE (t
) = value_type
;
8060 TYPE_ARG_TYPES (t
) = arg_types
;
8062 /* If we already have such a type, use the old one. */
8063 hashcode
= iterative_hash_object (TYPE_HASH (value_type
), hashcode
);
8064 hashcode
= type_hash_list (arg_types
, hashcode
);
8065 t
= type_hash_canon (hashcode
, t
);
8067 /* Set up the canonical type. */
8068 any_structural_p
= TYPE_STRUCTURAL_EQUALITY_P (value_type
);
8069 any_noncanonical_p
= TYPE_CANONICAL (value_type
) != value_type
;
8070 canon_argtypes
= maybe_canonicalize_argtypes (arg_types
,
8072 &any_noncanonical_p
);
8073 if (any_structural_p
)
8074 SET_TYPE_STRUCTURAL_EQUALITY (t
);
8075 else if (any_noncanonical_p
)
8076 TYPE_CANONICAL (t
) = build_function_type (TYPE_CANONICAL (value_type
),
8079 if (!COMPLETE_TYPE_P (t
))
8084 /* Build a function type. The RETURN_TYPE is the type returned by the
8085 function. If VAARGS is set, no void_type_node is appended to the
8086 the list. ARGP must be always be terminated be a NULL_TREE. */
8089 build_function_type_list_1 (bool vaargs
, tree return_type
, va_list argp
)
8093 t
= va_arg (argp
, tree
);
8094 for (args
= NULL_TREE
; t
!= NULL_TREE
; t
= va_arg (argp
, tree
))
8095 args
= tree_cons (NULL_TREE
, t
, args
);
8100 if (args
!= NULL_TREE
)
8101 args
= nreverse (args
);
8102 gcc_assert (last
!= void_list_node
);
8104 else if (args
== NULL_TREE
)
8105 args
= void_list_node
;
8109 args
= nreverse (args
);
8110 TREE_CHAIN (last
) = void_list_node
;
8112 args
= build_function_type (return_type
, args
);
8117 /* Build a function type. The RETURN_TYPE is the type returned by the
8118 function. If additional arguments are provided, they are
8119 additional argument types. The list of argument types must always
8120 be terminated by NULL_TREE. */
8123 build_function_type_list (tree return_type
, ...)
8128 va_start (p
, return_type
);
8129 args
= build_function_type_list_1 (false, return_type
, p
);
8134 /* Build a variable argument function type. The RETURN_TYPE is the
8135 type returned by the function. If additional arguments are provided,
8136 they are additional argument types. The list of argument types must
8137 always be terminated by NULL_TREE. */
8140 build_varargs_function_type_list (tree return_type
, ...)
8145 va_start (p
, return_type
);
8146 args
= build_function_type_list_1 (true, return_type
, p
);
8152 /* Build a function type. RETURN_TYPE is the type returned by the
8153 function; VAARGS indicates whether the function takes varargs. The
8154 function takes N named arguments, the types of which are provided in
8158 build_function_type_array_1 (bool vaargs
, tree return_type
, int n
,
8162 tree t
= vaargs
? NULL_TREE
: void_list_node
;
8164 for (i
= n
- 1; i
>= 0; i
--)
8165 t
= tree_cons (NULL_TREE
, arg_types
[i
], t
);
8167 return build_function_type (return_type
, t
);
8170 /* Build a function type. RETURN_TYPE is the type returned by the
8171 function. The function takes N named arguments, the types of which
8172 are provided in ARG_TYPES. */
8175 build_function_type_array (tree return_type
, int n
, tree
*arg_types
)
8177 return build_function_type_array_1 (false, return_type
, n
, arg_types
);
8180 /* Build a variable argument function type. RETURN_TYPE is the type
8181 returned by the function. The function takes N named arguments, the
8182 types of which are provided in ARG_TYPES. */
8185 build_varargs_function_type_array (tree return_type
, int n
, tree
*arg_types
)
8187 return build_function_type_array_1 (true, return_type
, n
, arg_types
);
8190 /* Build a METHOD_TYPE for a member of BASETYPE. The RETTYPE (a TYPE)
8191 and ARGTYPES (a TREE_LIST) are the return type and arguments types
8192 for the method. An implicit additional parameter (of type
8193 pointer-to-BASETYPE) is added to the ARGTYPES. */
8196 build_method_type_directly (tree basetype
,
8203 bool any_structural_p
, any_noncanonical_p
;
8204 tree canon_argtypes
;
8206 /* Make a node of the sort we want. */
8207 t
= make_node (METHOD_TYPE
);
8209 TYPE_METHOD_BASETYPE (t
) = TYPE_MAIN_VARIANT (basetype
);
8210 TREE_TYPE (t
) = rettype
;
8211 ptype
= build_pointer_type (basetype
);
8213 /* The actual arglist for this function includes a "hidden" argument
8214 which is "this". Put it into the list of argument types. */
8215 argtypes
= tree_cons (NULL_TREE
, ptype
, argtypes
);
8216 TYPE_ARG_TYPES (t
) = argtypes
;
8218 /* If we already have such a type, use the old one. */
8219 hashcode
= iterative_hash_object (TYPE_HASH (basetype
), hashcode
);
8220 hashcode
= iterative_hash_object (TYPE_HASH (rettype
), hashcode
);
8221 hashcode
= type_hash_list (argtypes
, hashcode
);
8222 t
= type_hash_canon (hashcode
, t
);
8224 /* Set up the canonical type. */
8226 = (TYPE_STRUCTURAL_EQUALITY_P (basetype
)
8227 || TYPE_STRUCTURAL_EQUALITY_P (rettype
));
8229 = (TYPE_CANONICAL (basetype
) != basetype
8230 || TYPE_CANONICAL (rettype
) != rettype
);
8231 canon_argtypes
= maybe_canonicalize_argtypes (TREE_CHAIN (argtypes
),
8233 &any_noncanonical_p
);
8234 if (any_structural_p
)
8235 SET_TYPE_STRUCTURAL_EQUALITY (t
);
8236 else if (any_noncanonical_p
)
8238 = build_method_type_directly (TYPE_CANONICAL (basetype
),
8239 TYPE_CANONICAL (rettype
),
8241 if (!COMPLETE_TYPE_P (t
))
8247 /* Construct, lay out and return the type of methods belonging to class
8248 BASETYPE and whose arguments and values are described by TYPE.
8249 If that type exists already, reuse it.
8250 TYPE must be a FUNCTION_TYPE node. */
8253 build_method_type (tree basetype
, tree type
)
8255 gcc_assert (TREE_CODE (type
) == FUNCTION_TYPE
);
8257 return build_method_type_directly (basetype
,
8259 TYPE_ARG_TYPES (type
));
8262 /* Construct, lay out and return the type of offsets to a value
8263 of type TYPE, within an object of type BASETYPE.
8264 If a suitable offset type exists already, reuse it. */
8267 build_offset_type (tree basetype
, tree type
)
8270 hashval_t hashcode
= 0;
8272 /* Make a node of the sort we want. */
8273 t
= make_node (OFFSET_TYPE
);
8275 TYPE_OFFSET_BASETYPE (t
) = TYPE_MAIN_VARIANT (basetype
);
8276 TREE_TYPE (t
) = type
;
8278 /* If we already have such a type, use the old one. */
8279 hashcode
= iterative_hash_object (TYPE_HASH (basetype
), hashcode
);
8280 hashcode
= iterative_hash_object (TYPE_HASH (type
), hashcode
);
8281 t
= type_hash_canon (hashcode
, t
);
8283 if (!COMPLETE_TYPE_P (t
))
8286 if (TYPE_CANONICAL (t
) == t
)
8288 if (TYPE_STRUCTURAL_EQUALITY_P (basetype
)
8289 || TYPE_STRUCTURAL_EQUALITY_P (type
))
8290 SET_TYPE_STRUCTURAL_EQUALITY (t
);
8291 else if (TYPE_CANONICAL (TYPE_MAIN_VARIANT (basetype
)) != basetype
8292 || TYPE_CANONICAL (type
) != type
)
8294 = build_offset_type (TYPE_CANONICAL (TYPE_MAIN_VARIANT (basetype
)),
8295 TYPE_CANONICAL (type
));
8301 /* Create a complex type whose components are COMPONENT_TYPE. */
8304 build_complex_type (tree component_type
)
8309 gcc_assert (INTEGRAL_TYPE_P (component_type
)
8310 || SCALAR_FLOAT_TYPE_P (component_type
)
8311 || FIXED_POINT_TYPE_P (component_type
));
8313 /* Make a node of the sort we want. */
8314 t
= make_node (COMPLEX_TYPE
);
8316 TREE_TYPE (t
) = TYPE_MAIN_VARIANT (component_type
);
8318 /* If we already have such a type, use the old one. */
8319 hashcode
= iterative_hash_object (TYPE_HASH (component_type
), 0);
8320 t
= type_hash_canon (hashcode
, t
);
8322 if (!COMPLETE_TYPE_P (t
))
8325 if (TYPE_CANONICAL (t
) == t
)
8327 if (TYPE_STRUCTURAL_EQUALITY_P (component_type
))
8328 SET_TYPE_STRUCTURAL_EQUALITY (t
);
8329 else if (TYPE_CANONICAL (component_type
) != component_type
)
8331 = build_complex_type (TYPE_CANONICAL (component_type
));
8334 /* We need to create a name, since complex is a fundamental type. */
8335 if (! TYPE_NAME (t
))
8338 if (component_type
== char_type_node
)
8339 name
= "complex char";
8340 else if (component_type
== signed_char_type_node
)
8341 name
= "complex signed char";
8342 else if (component_type
== unsigned_char_type_node
)
8343 name
= "complex unsigned char";
8344 else if (component_type
== short_integer_type_node
)
8345 name
= "complex short int";
8346 else if (component_type
== short_unsigned_type_node
)
8347 name
= "complex short unsigned int";
8348 else if (component_type
== integer_type_node
)
8349 name
= "complex int";
8350 else if (component_type
== unsigned_type_node
)
8351 name
= "complex unsigned int";
8352 else if (component_type
== long_integer_type_node
)
8353 name
= "complex long int";
8354 else if (component_type
== long_unsigned_type_node
)
8355 name
= "complex long unsigned int";
8356 else if (component_type
== long_long_integer_type_node
)
8357 name
= "complex long long int";
8358 else if (component_type
== long_long_unsigned_type_node
)
8359 name
= "complex long long unsigned int";
8364 TYPE_NAME (t
) = build_decl (UNKNOWN_LOCATION
, TYPE_DECL
,
8365 get_identifier (name
), t
);
8368 return build_qualified_type (t
, TYPE_QUALS (component_type
));
8371 /* If TYPE is a real or complex floating-point type and the target
8372 does not directly support arithmetic on TYPE then return the wider
8373 type to be used for arithmetic on TYPE. Otherwise, return
8377 excess_precision_type (tree type
)
8379 if (flag_excess_precision
!= EXCESS_PRECISION_FAST
)
8381 int flt_eval_method
= TARGET_FLT_EVAL_METHOD
;
8382 switch (TREE_CODE (type
))
8385 switch (flt_eval_method
)
8388 if (TYPE_MODE (type
) == TYPE_MODE (float_type_node
))
8389 return double_type_node
;
8392 if (TYPE_MODE (type
) == TYPE_MODE (float_type_node
)
8393 || TYPE_MODE (type
) == TYPE_MODE (double_type_node
))
8394 return long_double_type_node
;
8401 if (TREE_CODE (TREE_TYPE (type
)) != REAL_TYPE
)
8403 switch (flt_eval_method
)
8406 if (TYPE_MODE (TREE_TYPE (type
)) == TYPE_MODE (float_type_node
))
8407 return complex_double_type_node
;
8410 if (TYPE_MODE (TREE_TYPE (type
)) == TYPE_MODE (float_type_node
)
8411 || (TYPE_MODE (TREE_TYPE (type
))
8412 == TYPE_MODE (double_type_node
)))
8413 return complex_long_double_type_node
;
8426 /* Return OP, stripped of any conversions to wider types as much as is safe.
8427 Converting the value back to OP's type makes a value equivalent to OP.
8429 If FOR_TYPE is nonzero, we return a value which, if converted to
8430 type FOR_TYPE, would be equivalent to converting OP to type FOR_TYPE.
8432 OP must have integer, real or enumeral type. Pointers are not allowed!
8434 There are some cases where the obvious value we could return
8435 would regenerate to OP if converted to OP's type,
8436 but would not extend like OP to wider types.
8437 If FOR_TYPE indicates such extension is contemplated, we eschew such values.
8438 For example, if OP is (unsigned short)(signed char)-1,
8439 we avoid returning (signed char)-1 if FOR_TYPE is int,
8440 even though extending that to an unsigned short would regenerate OP,
8441 since the result of extending (signed char)-1 to (int)
8442 is different from (int) OP. */
8445 get_unwidened (tree op
, tree for_type
)
8447 /* Set UNS initially if converting OP to FOR_TYPE is a zero-extension. */
8448 tree type
= TREE_TYPE (op
);
8450 = TYPE_PRECISION (for_type
!= 0 ? for_type
: type
);
8452 = (for_type
!= 0 && for_type
!= type
8453 && final_prec
> TYPE_PRECISION (type
)
8454 && TYPE_UNSIGNED (type
));
8457 while (CONVERT_EXPR_P (op
))
8461 /* TYPE_PRECISION on vector types has different meaning
8462 (TYPE_VECTOR_SUBPARTS) and casts from vectors are view conversions,
8463 so avoid them here. */
8464 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (op
, 0))) == VECTOR_TYPE
)
8467 bitschange
= TYPE_PRECISION (TREE_TYPE (op
))
8468 - TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op
, 0)));
8470 /* Truncations are many-one so cannot be removed.
8471 Unless we are later going to truncate down even farther. */
8473 && final_prec
> TYPE_PRECISION (TREE_TYPE (op
)))
8476 /* See what's inside this conversion. If we decide to strip it,
8478 op
= TREE_OPERAND (op
, 0);
8480 /* If we have not stripped any zero-extensions (uns is 0),
8481 we can strip any kind of extension.
8482 If we have previously stripped a zero-extension,
8483 only zero-extensions can safely be stripped.
8484 Any extension can be stripped if the bits it would produce
8485 are all going to be discarded later by truncating to FOR_TYPE. */
8489 if (! uns
|| final_prec
<= TYPE_PRECISION (TREE_TYPE (op
)))
8491 /* TYPE_UNSIGNED says whether this is a zero-extension.
8492 Let's avoid computing it if it does not affect WIN
8493 and if UNS will not be needed again. */
8495 || CONVERT_EXPR_P (op
))
8496 && TYPE_UNSIGNED (TREE_TYPE (op
)))
8504 /* If we finally reach a constant see if it fits in for_type and
8505 in that case convert it. */
8507 && TREE_CODE (win
) == INTEGER_CST
8508 && TREE_TYPE (win
) != for_type
8509 && int_fits_type_p (win
, for_type
))
8510 win
= fold_convert (for_type
, win
);
8515 /* Return OP or a simpler expression for a narrower value
8516 which can be sign-extended or zero-extended to give back OP.
8517 Store in *UNSIGNEDP_PTR either 1 if the value should be zero-extended
8518 or 0 if the value should be sign-extended. */
8521 get_narrower (tree op
, int *unsignedp_ptr
)
8526 bool integral_p
= INTEGRAL_TYPE_P (TREE_TYPE (op
));
8528 while (TREE_CODE (op
) == NOP_EXPR
)
8531 = (TYPE_PRECISION (TREE_TYPE (op
))
8532 - TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op
, 0))));
8534 /* Truncations are many-one so cannot be removed. */
8538 /* See what's inside this conversion. If we decide to strip it,
8543 op
= TREE_OPERAND (op
, 0);
8544 /* An extension: the outermost one can be stripped,
8545 but remember whether it is zero or sign extension. */
8547 uns
= TYPE_UNSIGNED (TREE_TYPE (op
));
8548 /* Otherwise, if a sign extension has been stripped,
8549 only sign extensions can now be stripped;
8550 if a zero extension has been stripped, only zero-extensions. */
8551 else if (uns
!= TYPE_UNSIGNED (TREE_TYPE (op
)))
8555 else /* bitschange == 0 */
8557 /* A change in nominal type can always be stripped, but we must
8558 preserve the unsignedness. */
8560 uns
= TYPE_UNSIGNED (TREE_TYPE (op
));
8562 op
= TREE_OPERAND (op
, 0);
8563 /* Keep trying to narrow, but don't assign op to win if it
8564 would turn an integral type into something else. */
8565 if (INTEGRAL_TYPE_P (TREE_TYPE (op
)) != integral_p
)
8572 if (TREE_CODE (op
) == COMPONENT_REF
8573 /* Since type_for_size always gives an integer type. */
8574 && TREE_CODE (TREE_TYPE (op
)) != REAL_TYPE
8575 && TREE_CODE (TREE_TYPE (op
)) != FIXED_POINT_TYPE
8576 /* Ensure field is laid out already. */
8577 && DECL_SIZE (TREE_OPERAND (op
, 1)) != 0
8578 && tree_fits_uhwi_p (DECL_SIZE (TREE_OPERAND (op
, 1))))
8580 unsigned HOST_WIDE_INT innerprec
8581 = tree_to_uhwi (DECL_SIZE (TREE_OPERAND (op
, 1)));
8582 int unsignedp
= (DECL_UNSIGNED (TREE_OPERAND (op
, 1))
8583 || TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op
, 1))));
8584 tree type
= lang_hooks
.types
.type_for_size (innerprec
, unsignedp
);
8586 /* We can get this structure field in a narrower type that fits it,
8587 but the resulting extension to its nominal type (a fullword type)
8588 must satisfy the same conditions as for other extensions.
8590 Do this only for fields that are aligned (not bit-fields),
8591 because when bit-field insns will be used there is no
8592 advantage in doing this. */
8594 if (innerprec
< TYPE_PRECISION (TREE_TYPE (op
))
8595 && ! DECL_BIT_FIELD (TREE_OPERAND (op
, 1))
8596 && (first
|| uns
== DECL_UNSIGNED (TREE_OPERAND (op
, 1)))
8600 uns
= DECL_UNSIGNED (TREE_OPERAND (op
, 1));
8601 win
= fold_convert (type
, op
);
8605 *unsignedp_ptr
= uns
;
8609 /* Returns true if integer constant C has a value that is permissible
8610 for type TYPE (an INTEGER_TYPE). */
8613 int_fits_type_p (const_tree c
, const_tree type
)
8615 tree type_low_bound
, type_high_bound
;
8616 bool ok_for_low_bound
, ok_for_high_bound
, unsc
;
8619 dc
= tree_to_double_int (c
);
8620 unsc
= TYPE_UNSIGNED (TREE_TYPE (c
));
8623 type_low_bound
= TYPE_MIN_VALUE (type
);
8624 type_high_bound
= TYPE_MAX_VALUE (type
);
8626 /* If at least one bound of the type is a constant integer, we can check
8627 ourselves and maybe make a decision. If no such decision is possible, but
8628 this type is a subtype, try checking against that. Otherwise, use
8629 double_int_fits_to_tree_p, which checks against the precision.
8631 Compute the status for each possibly constant bound, and return if we see
8632 one does not match. Use ok_for_xxx_bound for this purpose, assigning -1
8633 for "unknown if constant fits", 0 for "constant known *not* to fit" and 1
8634 for "constant known to fit". */
8636 /* Check if c >= type_low_bound. */
8637 if (type_low_bound
&& TREE_CODE (type_low_bound
) == INTEGER_CST
)
8639 dd
= tree_to_double_int (type_low_bound
);
8640 if (unsc
!= TYPE_UNSIGNED (TREE_TYPE (type_low_bound
)))
8642 int c_neg
= (!unsc
&& dc
.is_negative ());
8643 int t_neg
= (unsc
&& dd
.is_negative ());
8645 if (c_neg
&& !t_neg
)
8647 if ((c_neg
|| !t_neg
) && dc
.ult (dd
))
8650 else if (dc
.cmp (dd
, unsc
) < 0)
8652 ok_for_low_bound
= true;
8655 ok_for_low_bound
= false;
8657 /* Check if c <= type_high_bound. */
8658 if (type_high_bound
&& TREE_CODE (type_high_bound
) == INTEGER_CST
)
8660 dd
= tree_to_double_int (type_high_bound
);
8661 if (unsc
!= TYPE_UNSIGNED (TREE_TYPE (type_high_bound
)))
8663 int c_neg
= (!unsc
&& dc
.is_negative ());
8664 int t_neg
= (unsc
&& dd
.is_negative ());
8666 if (t_neg
&& !c_neg
)
8668 if ((t_neg
|| !c_neg
) && dc
.ugt (dd
))
8671 else if (dc
.cmp (dd
, unsc
) > 0)
8673 ok_for_high_bound
= true;
8676 ok_for_high_bound
= false;
8678 /* If the constant fits both bounds, the result is known. */
8679 if (ok_for_low_bound
&& ok_for_high_bound
)
8682 /* Perform some generic filtering which may allow making a decision
8683 even if the bounds are not constant. First, negative integers
8684 never fit in unsigned types, */
8685 if (TYPE_UNSIGNED (type
) && !unsc
&& dc
.is_negative ())
8688 /* Second, narrower types always fit in wider ones. */
8689 if (TYPE_PRECISION (type
) > TYPE_PRECISION (TREE_TYPE (c
)))
8692 /* Third, unsigned integers with top bit set never fit signed types. */
8693 if (! TYPE_UNSIGNED (type
) && unsc
)
8695 int prec
= GET_MODE_PRECISION (TYPE_MODE (TREE_TYPE (c
))) - 1;
8696 if (prec
< HOST_BITS_PER_WIDE_INT
)
8698 if (((((unsigned HOST_WIDE_INT
) 1) << prec
) & dc
.low
) != 0)
8701 else if (((((unsigned HOST_WIDE_INT
) 1)
8702 << (prec
- HOST_BITS_PER_WIDE_INT
)) & dc
.high
) != 0)
8706 /* If we haven't been able to decide at this point, there nothing more we
8707 can check ourselves here. Look at the base type if we have one and it
8708 has the same precision. */
8709 if (TREE_CODE (type
) == INTEGER_TYPE
8710 && TREE_TYPE (type
) != 0
8711 && TYPE_PRECISION (type
) == TYPE_PRECISION (TREE_TYPE (type
)))
8713 type
= TREE_TYPE (type
);
8717 /* Or to double_int_fits_to_tree_p, if nothing else. */
8718 return double_int_fits_to_tree_p (type
, dc
);
8721 /* Stores bounds of an integer TYPE in MIN and MAX. If TYPE has non-constant
8722 bounds or is a POINTER_TYPE, the maximum and/or minimum values that can be
8723 represented (assuming two's-complement arithmetic) within the bit
8724 precision of the type are returned instead. */
8727 get_type_static_bounds (const_tree type
, mpz_t min
, mpz_t max
)
8729 if (!POINTER_TYPE_P (type
) && TYPE_MIN_VALUE (type
)
8730 && TREE_CODE (TYPE_MIN_VALUE (type
)) == INTEGER_CST
)
8731 mpz_set_double_int (min
, tree_to_double_int (TYPE_MIN_VALUE (type
)),
8732 TYPE_UNSIGNED (type
));
8735 if (TYPE_UNSIGNED (type
))
8736 mpz_set_ui (min
, 0);
8740 mn
= double_int::mask (TYPE_PRECISION (type
) - 1);
8741 mn
= (mn
+ double_int_one
).sext (TYPE_PRECISION (type
));
8742 mpz_set_double_int (min
, mn
, false);
8746 if (!POINTER_TYPE_P (type
) && TYPE_MAX_VALUE (type
)
8747 && TREE_CODE (TYPE_MAX_VALUE (type
)) == INTEGER_CST
)
8748 mpz_set_double_int (max
, tree_to_double_int (TYPE_MAX_VALUE (type
)),
8749 TYPE_UNSIGNED (type
));
8752 if (TYPE_UNSIGNED (type
))
8753 mpz_set_double_int (max
, double_int::mask (TYPE_PRECISION (type
)),
8756 mpz_set_double_int (max
, double_int::mask (TYPE_PRECISION (type
) - 1),
8761 /* Return true if VAR is an automatic variable defined in function FN. */
8764 auto_var_in_fn_p (const_tree var
, const_tree fn
)
8766 return (DECL_P (var
) && DECL_CONTEXT (var
) == fn
8767 && ((((TREE_CODE (var
) == VAR_DECL
&& ! DECL_EXTERNAL (var
))
8768 || TREE_CODE (var
) == PARM_DECL
)
8769 && ! TREE_STATIC (var
))
8770 || TREE_CODE (var
) == LABEL_DECL
8771 || TREE_CODE (var
) == RESULT_DECL
));
8774 /* Subprogram of following function. Called by walk_tree.
8776 Return *TP if it is an automatic variable or parameter of the
8777 function passed in as DATA. */
8780 find_var_from_fn (tree
*tp
, int *walk_subtrees
, void *data
)
8782 tree fn
= (tree
) data
;
8787 else if (DECL_P (*tp
)
8788 && auto_var_in_fn_p (*tp
, fn
))
8794 /* Returns true if T is, contains, or refers to a type with variable
8795 size. For METHOD_TYPEs and FUNCTION_TYPEs we exclude the
8796 arguments, but not the return type. If FN is nonzero, only return
8797 true if a modifier of the type or position of FN is a variable or
8798 parameter inside FN.
8800 This concept is more general than that of C99 'variably modified types':
8801 in C99, a struct type is never variably modified because a VLA may not
8802 appear as a structure member. However, in GNU C code like:
8804 struct S { int i[f()]; };
8806 is valid, and other languages may define similar constructs. */
8809 variably_modified_type_p (tree type
, tree fn
)
8813 /* Test if T is either variable (if FN is zero) or an expression containing
8814 a variable in FN. If TYPE isn't gimplified, return true also if
8815 gimplify_one_sizepos would gimplify the expression into a local
8817 #define RETURN_TRUE_IF_VAR(T) \
8818 do { tree _t = (T); \
8819 if (_t != NULL_TREE \
8820 && _t != error_mark_node \
8821 && TREE_CODE (_t) != INTEGER_CST \
8822 && TREE_CODE (_t) != PLACEHOLDER_EXPR \
8824 || (!TYPE_SIZES_GIMPLIFIED (type) \
8825 && !is_gimple_sizepos (_t)) \
8826 || walk_tree (&_t, find_var_from_fn, fn, NULL))) \
8827 return true; } while (0)
8829 if (type
== error_mark_node
)
8832 /* If TYPE itself has variable size, it is variably modified. */
8833 RETURN_TRUE_IF_VAR (TYPE_SIZE (type
));
8834 RETURN_TRUE_IF_VAR (TYPE_SIZE_UNIT (type
));
8836 switch (TREE_CODE (type
))
8839 case REFERENCE_TYPE
:
8841 if (variably_modified_type_p (TREE_TYPE (type
), fn
))
8847 /* If TYPE is a function type, it is variably modified if the
8848 return type is variably modified. */
8849 if (variably_modified_type_p (TREE_TYPE (type
), fn
))
8855 case FIXED_POINT_TYPE
:
8858 /* Scalar types are variably modified if their end points
8860 RETURN_TRUE_IF_VAR (TYPE_MIN_VALUE (type
));
8861 RETURN_TRUE_IF_VAR (TYPE_MAX_VALUE (type
));
8866 case QUAL_UNION_TYPE
:
8867 /* We can't see if any of the fields are variably-modified by the
8868 definition we normally use, since that would produce infinite
8869 recursion via pointers. */
8870 /* This is variably modified if some field's type is. */
8871 for (t
= TYPE_FIELDS (type
); t
; t
= DECL_CHAIN (t
))
8872 if (TREE_CODE (t
) == FIELD_DECL
)
8874 RETURN_TRUE_IF_VAR (DECL_FIELD_OFFSET (t
));
8875 RETURN_TRUE_IF_VAR (DECL_SIZE (t
));
8876 RETURN_TRUE_IF_VAR (DECL_SIZE_UNIT (t
));
8878 if (TREE_CODE (type
) == QUAL_UNION_TYPE
)
8879 RETURN_TRUE_IF_VAR (DECL_QUALIFIER (t
));
8884 /* Do not call ourselves to avoid infinite recursion. This is
8885 variably modified if the element type is. */
8886 RETURN_TRUE_IF_VAR (TYPE_SIZE (TREE_TYPE (type
)));
8887 RETURN_TRUE_IF_VAR (TYPE_SIZE_UNIT (TREE_TYPE (type
)));
8894 /* The current language may have other cases to check, but in general,
8895 all other types are not variably modified. */
8896 return lang_hooks
.tree_inlining
.var_mod_type_p (type
, fn
);
8898 #undef RETURN_TRUE_IF_VAR
8901 /* Given a DECL or TYPE, return the scope in which it was declared, or
8902 NULL_TREE if there is no containing scope. */
8905 get_containing_scope (const_tree t
)
8907 return (TYPE_P (t
) ? TYPE_CONTEXT (t
) : DECL_CONTEXT (t
));
8910 /* Return the innermost context enclosing DECL that is
8911 a FUNCTION_DECL, or zero if none. */
8914 decl_function_context (const_tree decl
)
8918 if (TREE_CODE (decl
) == ERROR_MARK
)
8921 /* C++ virtual functions use DECL_CONTEXT for the class of the vtable
8922 where we look up the function at runtime. Such functions always take
8923 a first argument of type 'pointer to real context'.
8925 C++ should really be fixed to use DECL_CONTEXT for the real context,
8926 and use something else for the "virtual context". */
8927 else if (TREE_CODE (decl
) == FUNCTION_DECL
&& DECL_VINDEX (decl
))
8930 (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl
)))));
8932 context
= DECL_CONTEXT (decl
);
8934 while (context
&& TREE_CODE (context
) != FUNCTION_DECL
)
8936 if (TREE_CODE (context
) == BLOCK
)
8937 context
= BLOCK_SUPERCONTEXT (context
);
8939 context
= get_containing_scope (context
);
8945 /* Return the innermost context enclosing DECL that is
8946 a RECORD_TYPE, UNION_TYPE or QUAL_UNION_TYPE, or zero if none.
8947 TYPE_DECLs and FUNCTION_DECLs are transparent to this function. */
8950 decl_type_context (const_tree decl
)
8952 tree context
= DECL_CONTEXT (decl
);
8955 switch (TREE_CODE (context
))
8957 case NAMESPACE_DECL
:
8958 case TRANSLATION_UNIT_DECL
:
8963 case QUAL_UNION_TYPE
:
8968 context
= DECL_CONTEXT (context
);
8972 context
= BLOCK_SUPERCONTEXT (context
);
8982 /* CALL is a CALL_EXPR. Return the declaration for the function
8983 called, or NULL_TREE if the called function cannot be
8987 get_callee_fndecl (const_tree call
)
8991 if (call
== error_mark_node
)
8992 return error_mark_node
;
8994 /* It's invalid to call this function with anything but a
8996 gcc_assert (TREE_CODE (call
) == CALL_EXPR
);
8998 /* The first operand to the CALL is the address of the function
9000 addr
= CALL_EXPR_FN (call
);
9004 /* If this is a readonly function pointer, extract its initial value. */
9005 if (DECL_P (addr
) && TREE_CODE (addr
) != FUNCTION_DECL
9006 && TREE_READONLY (addr
) && ! TREE_THIS_VOLATILE (addr
)
9007 && DECL_INITIAL (addr
))
9008 addr
= DECL_INITIAL (addr
);
9010 /* If the address is just `&f' for some function `f', then we know
9011 that `f' is being called. */
9012 if (TREE_CODE (addr
) == ADDR_EXPR
9013 && TREE_CODE (TREE_OPERAND (addr
, 0)) == FUNCTION_DECL
)
9014 return TREE_OPERAND (addr
, 0);
9016 /* We couldn't figure out what was being called. */
9020 /* Print debugging information about tree nodes generated during the compile,
9021 and any language-specific information. */
9024 dump_tree_statistics (void)
9026 if (GATHER_STATISTICS
)
9029 int total_nodes
, total_bytes
;
9030 fprintf (stderr
, "Kind Nodes Bytes\n");
9031 fprintf (stderr
, "---------------------------------------\n");
9032 total_nodes
= total_bytes
= 0;
9033 for (i
= 0; i
< (int) all_kinds
; i
++)
9035 fprintf (stderr
, "%-20s %7d %10d\n", tree_node_kind_names
[i
],
9036 tree_node_counts
[i
], tree_node_sizes
[i
]);
9037 total_nodes
+= tree_node_counts
[i
];
9038 total_bytes
+= tree_node_sizes
[i
];
9040 fprintf (stderr
, "---------------------------------------\n");
9041 fprintf (stderr
, "%-20s %7d %10d\n", "Total", total_nodes
, total_bytes
);
9042 fprintf (stderr
, "---------------------------------------\n");
9043 fprintf (stderr
, "Code Nodes\n");
9044 fprintf (stderr
, "----------------------------\n");
9045 for (i
= 0; i
< (int) MAX_TREE_CODES
; i
++)
9046 fprintf (stderr
, "%-20s %7d\n", get_tree_code_name ((enum tree_code
) i
),
9047 tree_code_counts
[i
]);
9048 fprintf (stderr
, "----------------------------\n");
9049 ssanames_print_statistics ();
9050 phinodes_print_statistics ();
9053 fprintf (stderr
, "(No per-node statistics)\n");
9055 print_type_hash_statistics ();
9056 print_debug_expr_statistics ();
9057 print_value_expr_statistics ();
9058 lang_hooks
.print_statistics ();
9061 #define FILE_FUNCTION_FORMAT "_GLOBAL__%s_%s"
9063 /* Generate a crc32 of a byte. */
9066 crc32_unsigned_bits (unsigned chksum
, unsigned value
, unsigned bits
)
9070 for (ix
= bits
; ix
--; value
<<= 1)
9074 feedback
= (value
^ chksum
) & 0x80000000 ? 0x04c11db7 : 0;
9081 /* Generate a crc32 of a 32-bit unsigned. */
9084 crc32_unsigned (unsigned chksum
, unsigned value
)
9086 return crc32_unsigned_bits (chksum
, value
, 32);
9089 /* Generate a crc32 of a byte. */
9092 crc32_byte (unsigned chksum
, char byte
)
9094 return crc32_unsigned_bits (chksum
, (unsigned) byte
<< 24, 8);
9097 /* Generate a crc32 of a string. */
9100 crc32_string (unsigned chksum
, const char *string
)
9104 chksum
= crc32_byte (chksum
, *string
);
9110 /* P is a string that will be used in a symbol. Mask out any characters
9111 that are not valid in that context. */
9114 clean_symbol_name (char *p
)
9118 #ifndef NO_DOLLAR_IN_LABEL /* this for `$'; unlikely, but... -- kr */
9121 #ifndef NO_DOT_IN_LABEL /* this for `.'; unlikely, but... */
9128 /* Generate a name for a special-purpose function.
9129 The generated name may need to be unique across the whole link.
9130 Changes to this function may also require corresponding changes to
9131 xstrdup_mask_random.
9132 TYPE is some string to identify the purpose of this function to the
9133 linker or collect2; it must start with an uppercase letter,
9135 I - for constructors
9137 N - for C++ anonymous namespaces
9138 F - for DWARF unwind frame information. */
9141 get_file_function_name (const char *type
)
9147 /* If we already have a name we know to be unique, just use that. */
9148 if (first_global_object_name
)
9149 p
= q
= ASTRDUP (first_global_object_name
);
9150 /* If the target is handling the constructors/destructors, they
9151 will be local to this file and the name is only necessary for
9153 We also assign sub_I and sub_D sufixes to constructors called from
9154 the global static constructors. These are always local. */
9155 else if (((type
[0] == 'I' || type
[0] == 'D') && targetm
.have_ctors_dtors
)
9156 || (strncmp (type
, "sub_", 4) == 0
9157 && (type
[4] == 'I' || type
[4] == 'D')))
9159 const char *file
= main_input_filename
;
9161 file
= LOCATION_FILE (input_location
);
9162 /* Just use the file's basename, because the full pathname
9163 might be quite long. */
9164 p
= q
= ASTRDUP (lbasename (file
));
9168 /* Otherwise, the name must be unique across the entire link.
9169 We don't have anything that we know to be unique to this translation
9170 unit, so use what we do have and throw in some randomness. */
9172 const char *name
= weak_global_object_name
;
9173 const char *file
= main_input_filename
;
9178 file
= LOCATION_FILE (input_location
);
9180 len
= strlen (file
);
9181 q
= (char *) alloca (9 + 17 + len
+ 1);
9182 memcpy (q
, file
, len
+ 1);
9184 snprintf (q
+ len
, 9 + 17 + 1, "_%08X_" HOST_WIDE_INT_PRINT_HEX
,
9185 crc32_string (0, name
), get_random_seed (false));
9190 clean_symbol_name (q
);
9191 buf
= (char *) alloca (sizeof (FILE_FUNCTION_FORMAT
) + strlen (p
)
9194 /* Set up the name of the file-level functions we may need.
9195 Use a global object (which is already required to be unique over
9196 the program) rather than the file name (which imposes extra
9198 sprintf (buf
, FILE_FUNCTION_FORMAT
, type
, p
);
9200 return get_identifier (buf
);
9203 #if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
9205 /* Complain that the tree code of NODE does not match the expected 0
9206 terminated list of trailing codes. The trailing code list can be
9207 empty, for a more vague error message. FILE, LINE, and FUNCTION
9208 are of the caller. */
9211 tree_check_failed (const_tree node
, const char *file
,
9212 int line
, const char *function
, ...)
9216 unsigned length
= 0;
9217 enum tree_code code
;
9219 va_start (args
, function
);
9220 while ((code
= (enum tree_code
) va_arg (args
, int)))
9221 length
+= 4 + strlen (get_tree_code_name (code
));
9226 va_start (args
, function
);
9227 length
+= strlen ("expected ");
9228 buffer
= tmp
= (char *) alloca (length
);
9230 while ((code
= (enum tree_code
) va_arg (args
, int)))
9232 const char *prefix
= length
? " or " : "expected ";
9234 strcpy (tmp
+ length
, prefix
);
9235 length
+= strlen (prefix
);
9236 strcpy (tmp
+ length
, get_tree_code_name (code
));
9237 length
+= strlen (get_tree_code_name (code
));
9242 buffer
= "unexpected node";
9244 internal_error ("tree check: %s, have %s in %s, at %s:%d",
9245 buffer
, get_tree_code_name (TREE_CODE (node
)),
9246 function
, trim_filename (file
), line
);
9249 /* Complain that the tree code of NODE does match the expected 0
9250 terminated list of trailing codes. FILE, LINE, and FUNCTION are of
9254 tree_not_check_failed (const_tree node
, const char *file
,
9255 int line
, const char *function
, ...)
9259 unsigned length
= 0;
9260 enum tree_code code
;
9262 va_start (args
, function
);
9263 while ((code
= (enum tree_code
) va_arg (args
, int)))
9264 length
+= 4 + strlen (get_tree_code_name (code
));
9266 va_start (args
, function
);
9267 buffer
= (char *) alloca (length
);
9269 while ((code
= (enum tree_code
) va_arg (args
, int)))
9273 strcpy (buffer
+ length
, " or ");
9276 strcpy (buffer
+ length
, get_tree_code_name (code
));
9277 length
+= strlen (get_tree_code_name (code
));
9281 internal_error ("tree check: expected none of %s, have %s in %s, at %s:%d",
9282 buffer
, get_tree_code_name (TREE_CODE (node
)),
9283 function
, trim_filename (file
), line
);
9286 /* Similar to tree_check_failed, except that we check for a class of tree
9287 code, given in CL. */
9290 tree_class_check_failed (const_tree node
, const enum tree_code_class cl
,
9291 const char *file
, int line
, const char *function
)
9294 ("tree check: expected class %qs, have %qs (%s) in %s, at %s:%d",
9295 TREE_CODE_CLASS_STRING (cl
),
9296 TREE_CODE_CLASS_STRING (TREE_CODE_CLASS (TREE_CODE (node
))),
9297 get_tree_code_name (TREE_CODE (node
)), function
, trim_filename (file
), line
);
9300 /* Similar to tree_check_failed, except that instead of specifying a
9301 dozen codes, use the knowledge that they're all sequential. */
9304 tree_range_check_failed (const_tree node
, const char *file
, int line
,
9305 const char *function
, enum tree_code c1
,
9309 unsigned length
= 0;
9312 for (c
= c1
; c
<= c2
; ++c
)
9313 length
+= 4 + strlen (get_tree_code_name ((enum tree_code
) c
));
9315 length
+= strlen ("expected ");
9316 buffer
= (char *) alloca (length
);
9319 for (c
= c1
; c
<= c2
; ++c
)
9321 const char *prefix
= length
? " or " : "expected ";
9323 strcpy (buffer
+ length
, prefix
);
9324 length
+= strlen (prefix
);
9325 strcpy (buffer
+ length
, get_tree_code_name ((enum tree_code
) c
));
9326 length
+= strlen (get_tree_code_name ((enum tree_code
) c
));
9329 internal_error ("tree check: %s, have %s in %s, at %s:%d",
9330 buffer
, get_tree_code_name (TREE_CODE (node
)),
9331 function
, trim_filename (file
), line
);
9335 /* Similar to tree_check_failed, except that we check that a tree does
9336 not have the specified code, given in CL. */
9339 tree_not_class_check_failed (const_tree node
, const enum tree_code_class cl
,
9340 const char *file
, int line
, const char *function
)
9343 ("tree check: did not expect class %qs, have %qs (%s) in %s, at %s:%d",
9344 TREE_CODE_CLASS_STRING (cl
),
9345 TREE_CODE_CLASS_STRING (TREE_CODE_CLASS (TREE_CODE (node
))),
9346 get_tree_code_name (TREE_CODE (node
)), function
, trim_filename (file
), line
);
9350 /* Similar to tree_check_failed but applied to OMP_CLAUSE codes. */
9353 omp_clause_check_failed (const_tree node
, const char *file
, int line
,
9354 const char *function
, enum omp_clause_code code
)
9356 internal_error ("tree check: expected omp_clause %s, have %s in %s, at %s:%d",
9357 omp_clause_code_name
[code
], get_tree_code_name (TREE_CODE (node
)),
9358 function
, trim_filename (file
), line
);
9362 /* Similar to tree_range_check_failed but applied to OMP_CLAUSE codes. */
9365 omp_clause_range_check_failed (const_tree node
, const char *file
, int line
,
9366 const char *function
, enum omp_clause_code c1
,
9367 enum omp_clause_code c2
)
9370 unsigned length
= 0;
9373 for (c
= c1
; c
<= c2
; ++c
)
9374 length
+= 4 + strlen (omp_clause_code_name
[c
]);
9376 length
+= strlen ("expected ");
9377 buffer
= (char *) alloca (length
);
9380 for (c
= c1
; c
<= c2
; ++c
)
9382 const char *prefix
= length
? " or " : "expected ";
9384 strcpy (buffer
+ length
, prefix
);
9385 length
+= strlen (prefix
);
9386 strcpy (buffer
+ length
, omp_clause_code_name
[c
]);
9387 length
+= strlen (omp_clause_code_name
[c
]);
9390 internal_error ("tree check: %s, have %s in %s, at %s:%d",
9391 buffer
, omp_clause_code_name
[TREE_CODE (node
)],
9392 function
, trim_filename (file
), line
);
9396 #undef DEFTREESTRUCT
9397 #define DEFTREESTRUCT(VAL, NAME) NAME,
9399 static const char *ts_enum_names
[] = {
9400 #include "treestruct.def"
9402 #undef DEFTREESTRUCT
9404 #define TS_ENUM_NAME(EN) (ts_enum_names[(EN)])
9406 /* Similar to tree_class_check_failed, except that we check for
9407 whether CODE contains the tree structure identified by EN. */
9410 tree_contains_struct_check_failed (const_tree node
,
9411 const enum tree_node_structure_enum en
,
9412 const char *file
, int line
,
9413 const char *function
)
9416 ("tree check: expected tree that contains %qs structure, have %qs in %s, at %s:%d",
9418 get_tree_code_name (TREE_CODE (node
)), function
, trim_filename (file
), line
);
9422 /* Similar to above, except that the check is for the bounds of a TREE_VEC's
9423 (dynamically sized) vector. */
9426 tree_vec_elt_check_failed (int idx
, int len
, const char *file
, int line
,
9427 const char *function
)
9430 ("tree check: accessed elt %d of tree_vec with %d elts in %s, at %s:%d",
9431 idx
+ 1, len
, function
, trim_filename (file
), line
);
9434 /* Similar to above, except that the check is for the bounds of the operand
9435 vector of an expression node EXP. */
9438 tree_operand_check_failed (int idx
, const_tree exp
, const char *file
,
9439 int line
, const char *function
)
9441 enum tree_code code
= TREE_CODE (exp
);
9443 ("tree check: accessed operand %d of %s with %d operands in %s, at %s:%d",
9444 idx
+ 1, get_tree_code_name (code
), TREE_OPERAND_LENGTH (exp
),
9445 function
, trim_filename (file
), line
);
9448 /* Similar to above, except that the check is for the number of
9449 operands of an OMP_CLAUSE node. */
9452 omp_clause_operand_check_failed (int idx
, const_tree t
, const char *file
,
9453 int line
, const char *function
)
9456 ("tree check: accessed operand %d of omp_clause %s with %d operands "
9457 "in %s, at %s:%d", idx
+ 1, omp_clause_code_name
[OMP_CLAUSE_CODE (t
)],
9458 omp_clause_num_ops
[OMP_CLAUSE_CODE (t
)], function
,
9459 trim_filename (file
), line
);
9461 #endif /* ENABLE_TREE_CHECKING */
9463 /* Create a new vector type node holding SUBPARTS units of type INNERTYPE,
9464 and mapped to the machine mode MODE. Initialize its fields and build
9465 the information necessary for debugging output. */
9468 make_vector_type (tree innertype
, int nunits
, enum machine_mode mode
)
9471 hashval_t hashcode
= 0;
9473 t
= make_node (VECTOR_TYPE
);
9474 TREE_TYPE (t
) = TYPE_MAIN_VARIANT (innertype
);
9475 SET_TYPE_VECTOR_SUBPARTS (t
, nunits
);
9476 SET_TYPE_MODE (t
, mode
);
9478 if (TYPE_STRUCTURAL_EQUALITY_P (innertype
))
9479 SET_TYPE_STRUCTURAL_EQUALITY (t
);
9480 else if (TYPE_CANONICAL (innertype
) != innertype
9481 || mode
!= VOIDmode
)
9483 = make_vector_type (TYPE_CANONICAL (innertype
), nunits
, VOIDmode
);
9487 hashcode
= iterative_hash_host_wide_int (VECTOR_TYPE
, hashcode
);
9488 hashcode
= iterative_hash_host_wide_int (nunits
, hashcode
);
9489 hashcode
= iterative_hash_host_wide_int (mode
, hashcode
);
9490 hashcode
= iterative_hash_object (TYPE_HASH (TREE_TYPE (t
)), hashcode
);
9491 t
= type_hash_canon (hashcode
, t
);
9493 /* We have built a main variant, based on the main variant of the
9494 inner type. Use it to build the variant we return. */
9495 if ((TYPE_ATTRIBUTES (innertype
) || TYPE_QUALS (innertype
))
9496 && TREE_TYPE (t
) != innertype
)
9497 return build_type_attribute_qual_variant (t
,
9498 TYPE_ATTRIBUTES (innertype
),
9499 TYPE_QUALS (innertype
));
9505 make_or_reuse_type (unsigned size
, int unsignedp
)
9507 if (size
== INT_TYPE_SIZE
)
9508 return unsignedp
? unsigned_type_node
: integer_type_node
;
9509 if (size
== CHAR_TYPE_SIZE
)
9510 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
9511 if (size
== SHORT_TYPE_SIZE
)
9512 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
9513 if (size
== LONG_TYPE_SIZE
)
9514 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
9515 if (size
== LONG_LONG_TYPE_SIZE
)
9516 return (unsignedp
? long_long_unsigned_type_node
9517 : long_long_integer_type_node
);
9518 if (size
== 128 && int128_integer_type_node
)
9519 return (unsignedp
? int128_unsigned_type_node
9520 : int128_integer_type_node
);
9523 return make_unsigned_type (size
);
9525 return make_signed_type (size
);
9528 /* Create or reuse a fract type by SIZE, UNSIGNEDP, and SATP. */
9531 make_or_reuse_fract_type (unsigned size
, int unsignedp
, int satp
)
9535 if (size
== SHORT_FRACT_TYPE_SIZE
)
9536 return unsignedp
? sat_unsigned_short_fract_type_node
9537 : sat_short_fract_type_node
;
9538 if (size
== FRACT_TYPE_SIZE
)
9539 return unsignedp
? sat_unsigned_fract_type_node
: sat_fract_type_node
;
9540 if (size
== LONG_FRACT_TYPE_SIZE
)
9541 return unsignedp
? sat_unsigned_long_fract_type_node
9542 : sat_long_fract_type_node
;
9543 if (size
== LONG_LONG_FRACT_TYPE_SIZE
)
9544 return unsignedp
? sat_unsigned_long_long_fract_type_node
9545 : sat_long_long_fract_type_node
;
9549 if (size
== SHORT_FRACT_TYPE_SIZE
)
9550 return unsignedp
? unsigned_short_fract_type_node
9551 : short_fract_type_node
;
9552 if (size
== FRACT_TYPE_SIZE
)
9553 return unsignedp
? unsigned_fract_type_node
: fract_type_node
;
9554 if (size
== LONG_FRACT_TYPE_SIZE
)
9555 return unsignedp
? unsigned_long_fract_type_node
9556 : long_fract_type_node
;
9557 if (size
== LONG_LONG_FRACT_TYPE_SIZE
)
9558 return unsignedp
? unsigned_long_long_fract_type_node
9559 : long_long_fract_type_node
;
9562 return make_fract_type (size
, unsignedp
, satp
);
9565 /* Create or reuse an accum type by SIZE, UNSIGNEDP, and SATP. */
9568 make_or_reuse_accum_type (unsigned size
, int unsignedp
, int satp
)
9572 if (size
== SHORT_ACCUM_TYPE_SIZE
)
9573 return unsignedp
? sat_unsigned_short_accum_type_node
9574 : sat_short_accum_type_node
;
9575 if (size
== ACCUM_TYPE_SIZE
)
9576 return unsignedp
? sat_unsigned_accum_type_node
: sat_accum_type_node
;
9577 if (size
== LONG_ACCUM_TYPE_SIZE
)
9578 return unsignedp
? sat_unsigned_long_accum_type_node
9579 : sat_long_accum_type_node
;
9580 if (size
== LONG_LONG_ACCUM_TYPE_SIZE
)
9581 return unsignedp
? sat_unsigned_long_long_accum_type_node
9582 : sat_long_long_accum_type_node
;
9586 if (size
== SHORT_ACCUM_TYPE_SIZE
)
9587 return unsignedp
? unsigned_short_accum_type_node
9588 : short_accum_type_node
;
9589 if (size
== ACCUM_TYPE_SIZE
)
9590 return unsignedp
? unsigned_accum_type_node
: accum_type_node
;
9591 if (size
== LONG_ACCUM_TYPE_SIZE
)
9592 return unsignedp
? unsigned_long_accum_type_node
9593 : long_accum_type_node
;
9594 if (size
== LONG_LONG_ACCUM_TYPE_SIZE
)
9595 return unsignedp
? unsigned_long_long_accum_type_node
9596 : long_long_accum_type_node
;
9599 return make_accum_type (size
, unsignedp
, satp
);
9603 /* Create an atomic variant node for TYPE. This routine is called
9604 during initialization of data types to create the 5 basic atomic
9605 types. The generic build_variant_type function requires these to
9606 already be set up in order to function properly, so cannot be
9607 called from there. If ALIGN is non-zero, then ensure alignment is
9608 overridden to this value. */
9611 build_atomic_base (tree type
, unsigned int align
)
9615 /* Make sure its not already registered. */
9616 if ((t
= get_qualified_type (type
, TYPE_QUAL_ATOMIC
)))
9619 t
= build_variant_type_copy (type
);
9620 set_type_quals (t
, TYPE_QUAL_ATOMIC
, NULL_TREE
);
9623 TYPE_ALIGN (t
) = align
;
9628 /* Create nodes for all integer types (and error_mark_node) using the sizes
9629 of C datatypes. SIGNED_CHAR specifies whether char is signed,
9630 SHORT_DOUBLE specifies whether double should be of the same precision
9634 build_common_tree_nodes (bool signed_char
, bool short_double
)
9636 error_mark_node
= make_node (ERROR_MARK
);
9637 TREE_TYPE (error_mark_node
) = error_mark_node
;
9639 initialize_sizetypes ();
9641 /* Define both `signed char' and `unsigned char'. */
9642 signed_char_type_node
= make_signed_type (CHAR_TYPE_SIZE
);
9643 TYPE_STRING_FLAG (signed_char_type_node
) = 1;
9644 unsigned_char_type_node
= make_unsigned_type (CHAR_TYPE_SIZE
);
9645 TYPE_STRING_FLAG (unsigned_char_type_node
) = 1;
9647 /* Define `char', which is like either `signed char' or `unsigned char'
9648 but not the same as either. */
9651 ? make_signed_type (CHAR_TYPE_SIZE
)
9652 : make_unsigned_type (CHAR_TYPE_SIZE
));
9653 TYPE_STRING_FLAG (char_type_node
) = 1;
9655 short_integer_type_node
= make_signed_type (SHORT_TYPE_SIZE
);
9656 short_unsigned_type_node
= make_unsigned_type (SHORT_TYPE_SIZE
);
9657 integer_type_node
= make_signed_type (INT_TYPE_SIZE
);
9658 unsigned_type_node
= make_unsigned_type (INT_TYPE_SIZE
);
9659 long_integer_type_node
= make_signed_type (LONG_TYPE_SIZE
);
9660 long_unsigned_type_node
= make_unsigned_type (LONG_TYPE_SIZE
);
9661 long_long_integer_type_node
= make_signed_type (LONG_LONG_TYPE_SIZE
);
9662 long_long_unsigned_type_node
= make_unsigned_type (LONG_LONG_TYPE_SIZE
);
9663 #if HOST_BITS_PER_WIDE_INT >= 64
9664 /* TODO: This isn't correct, but as logic depends at the moment on
9665 host's instead of target's wide-integer.
9666 If there is a target not supporting TImode, but has an 128-bit
9667 integer-scalar register, this target check needs to be adjusted. */
9668 if (targetm
.scalar_mode_supported_p (TImode
))
9670 int128_integer_type_node
= make_signed_type (128);
9671 int128_unsigned_type_node
= make_unsigned_type (128);
9675 /* Define a boolean type. This type only represents boolean values but
9676 may be larger than char depending on the value of BOOL_TYPE_SIZE.
9677 Front ends which want to override this size (i.e. Java) can redefine
9678 boolean_type_node before calling build_common_tree_nodes_2. */
9679 boolean_type_node
= make_unsigned_type (BOOL_TYPE_SIZE
);
9680 TREE_SET_CODE (boolean_type_node
, BOOLEAN_TYPE
);
9681 TYPE_MAX_VALUE (boolean_type_node
) = build_int_cst (boolean_type_node
, 1);
9682 TYPE_PRECISION (boolean_type_node
) = 1;
9684 /* Define what type to use for size_t. */
9685 if (strcmp (SIZE_TYPE
, "unsigned int") == 0)
9686 size_type_node
= unsigned_type_node
;
9687 else if (strcmp (SIZE_TYPE
, "long unsigned int") == 0)
9688 size_type_node
= long_unsigned_type_node
;
9689 else if (strcmp (SIZE_TYPE
, "long long unsigned int") == 0)
9690 size_type_node
= long_long_unsigned_type_node
;
9691 else if (strcmp (SIZE_TYPE
, "short unsigned int") == 0)
9692 size_type_node
= short_unsigned_type_node
;
9696 /* Fill in the rest of the sized types. Reuse existing type nodes
9698 intQI_type_node
= make_or_reuse_type (GET_MODE_BITSIZE (QImode
), 0);
9699 intHI_type_node
= make_or_reuse_type (GET_MODE_BITSIZE (HImode
), 0);
9700 intSI_type_node
= make_or_reuse_type (GET_MODE_BITSIZE (SImode
), 0);
9701 intDI_type_node
= make_or_reuse_type (GET_MODE_BITSIZE (DImode
), 0);
9702 intTI_type_node
= make_or_reuse_type (GET_MODE_BITSIZE (TImode
), 0);
9704 unsigned_intQI_type_node
= make_or_reuse_type (GET_MODE_BITSIZE (QImode
), 1);
9705 unsigned_intHI_type_node
= make_or_reuse_type (GET_MODE_BITSIZE (HImode
), 1);
9706 unsigned_intSI_type_node
= make_or_reuse_type (GET_MODE_BITSIZE (SImode
), 1);
9707 unsigned_intDI_type_node
= make_or_reuse_type (GET_MODE_BITSIZE (DImode
), 1);
9708 unsigned_intTI_type_node
= make_or_reuse_type (GET_MODE_BITSIZE (TImode
), 1);
9710 /* Don't call build_qualified type for atomics. That routine does
9711 special processing for atomics, and until they are initialized
9712 it's better not to make that call.
9714 Check to see if there is a target override for atomic types. */
9716 atomicQI_type_node
= build_atomic_base (unsigned_intQI_type_node
,
9717 targetm
.atomic_align_for_mode (QImode
));
9718 atomicHI_type_node
= build_atomic_base (unsigned_intHI_type_node
,
9719 targetm
.atomic_align_for_mode (HImode
));
9720 atomicSI_type_node
= build_atomic_base (unsigned_intSI_type_node
,
9721 targetm
.atomic_align_for_mode (SImode
));
9722 atomicDI_type_node
= build_atomic_base (unsigned_intDI_type_node
,
9723 targetm
.atomic_align_for_mode (DImode
));
9724 atomicTI_type_node
= build_atomic_base (unsigned_intTI_type_node
,
9725 targetm
.atomic_align_for_mode (TImode
));
9727 access_public_node
= get_identifier ("public");
9728 access_protected_node
= get_identifier ("protected");
9729 access_private_node
= get_identifier ("private");
9731 /* Define these next since types below may used them. */
9732 integer_zero_node
= build_int_cst (integer_type_node
, 0);
9733 integer_one_node
= build_int_cst (integer_type_node
, 1);
9734 integer_three_node
= build_int_cst (integer_type_node
, 3);
9735 integer_minus_one_node
= build_int_cst (integer_type_node
, -1);
9737 size_zero_node
= size_int (0);
9738 size_one_node
= size_int (1);
9739 bitsize_zero_node
= bitsize_int (0);
9740 bitsize_one_node
= bitsize_int (1);
9741 bitsize_unit_node
= bitsize_int (BITS_PER_UNIT
);
9743 boolean_false_node
= TYPE_MIN_VALUE (boolean_type_node
);
9744 boolean_true_node
= TYPE_MAX_VALUE (boolean_type_node
);
9746 void_type_node
= make_node (VOID_TYPE
);
9747 layout_type (void_type_node
);
9749 /* We are not going to have real types in C with less than byte alignment,
9750 so we might as well not have any types that claim to have it. */
9751 TYPE_ALIGN (void_type_node
) = BITS_PER_UNIT
;
9752 TYPE_USER_ALIGN (void_type_node
) = 0;
9754 null_pointer_node
= build_int_cst (build_pointer_type (void_type_node
), 0);
9755 layout_type (TREE_TYPE (null_pointer_node
));
9757 ptr_type_node
= build_pointer_type (void_type_node
);
9759 = build_pointer_type (build_type_variant (void_type_node
, 1, 0));
9760 fileptr_type_node
= ptr_type_node
;
9762 pointer_sized_int_node
= build_nonstandard_integer_type (POINTER_SIZE
, 1);
9764 float_type_node
= make_node (REAL_TYPE
);
9765 TYPE_PRECISION (float_type_node
) = FLOAT_TYPE_SIZE
;
9766 layout_type (float_type_node
);
9768 double_type_node
= make_node (REAL_TYPE
);
9770 TYPE_PRECISION (double_type_node
) = FLOAT_TYPE_SIZE
;
9772 TYPE_PRECISION (double_type_node
) = DOUBLE_TYPE_SIZE
;
9773 layout_type (double_type_node
);
9775 long_double_type_node
= make_node (REAL_TYPE
);
9776 TYPE_PRECISION (long_double_type_node
) = LONG_DOUBLE_TYPE_SIZE
;
9777 layout_type (long_double_type_node
);
9779 float_ptr_type_node
= build_pointer_type (float_type_node
);
9780 double_ptr_type_node
= build_pointer_type (double_type_node
);
9781 long_double_ptr_type_node
= build_pointer_type (long_double_type_node
);
9782 integer_ptr_type_node
= build_pointer_type (integer_type_node
);
9784 /* Fixed size integer types. */
9785 uint16_type_node
= build_nonstandard_integer_type (16, true);
9786 uint32_type_node
= build_nonstandard_integer_type (32, true);
9787 uint64_type_node
= build_nonstandard_integer_type (64, true);
9789 /* Decimal float types. */
9790 dfloat32_type_node
= make_node (REAL_TYPE
);
9791 TYPE_PRECISION (dfloat32_type_node
) = DECIMAL32_TYPE_SIZE
;
9792 layout_type (dfloat32_type_node
);
9793 SET_TYPE_MODE (dfloat32_type_node
, SDmode
);
9794 dfloat32_ptr_type_node
= build_pointer_type (dfloat32_type_node
);
9796 dfloat64_type_node
= make_node (REAL_TYPE
);
9797 TYPE_PRECISION (dfloat64_type_node
) = DECIMAL64_TYPE_SIZE
;
9798 layout_type (dfloat64_type_node
);
9799 SET_TYPE_MODE (dfloat64_type_node
, DDmode
);
9800 dfloat64_ptr_type_node
= build_pointer_type (dfloat64_type_node
);
9802 dfloat128_type_node
= make_node (REAL_TYPE
);
9803 TYPE_PRECISION (dfloat128_type_node
) = DECIMAL128_TYPE_SIZE
;
9804 layout_type (dfloat128_type_node
);
9805 SET_TYPE_MODE (dfloat128_type_node
, TDmode
);
9806 dfloat128_ptr_type_node
= build_pointer_type (dfloat128_type_node
);
9808 complex_integer_type_node
= build_complex_type (integer_type_node
);
9809 complex_float_type_node
= build_complex_type (float_type_node
);
9810 complex_double_type_node
= build_complex_type (double_type_node
);
9811 complex_long_double_type_node
= build_complex_type (long_double_type_node
);
9813 /* Make fixed-point nodes based on sat/non-sat and signed/unsigned. */
9814 #define MAKE_FIXED_TYPE_NODE(KIND,SIZE) \
9815 sat_ ## KIND ## _type_node = \
9816 make_sat_signed_ ## KIND ## _type (SIZE); \
9817 sat_unsigned_ ## KIND ## _type_node = \
9818 make_sat_unsigned_ ## KIND ## _type (SIZE); \
9819 KIND ## _type_node = make_signed_ ## KIND ## _type (SIZE); \
9820 unsigned_ ## KIND ## _type_node = \
9821 make_unsigned_ ## KIND ## _type (SIZE);
9823 #define MAKE_FIXED_TYPE_NODE_WIDTH(KIND,WIDTH,SIZE) \
9824 sat_ ## WIDTH ## KIND ## _type_node = \
9825 make_sat_signed_ ## KIND ## _type (SIZE); \
9826 sat_unsigned_ ## WIDTH ## KIND ## _type_node = \
9827 make_sat_unsigned_ ## KIND ## _type (SIZE); \
9828 WIDTH ## KIND ## _type_node = make_signed_ ## KIND ## _type (SIZE); \
9829 unsigned_ ## WIDTH ## KIND ## _type_node = \
9830 make_unsigned_ ## KIND ## _type (SIZE);
9832 /* Make fixed-point type nodes based on four different widths. */
9833 #define MAKE_FIXED_TYPE_NODE_FAMILY(N1,N2) \
9834 MAKE_FIXED_TYPE_NODE_WIDTH (N1, short_, SHORT_ ## N2 ## _TYPE_SIZE) \
9835 MAKE_FIXED_TYPE_NODE (N1, N2 ## _TYPE_SIZE) \
9836 MAKE_FIXED_TYPE_NODE_WIDTH (N1, long_, LONG_ ## N2 ## _TYPE_SIZE) \
9837 MAKE_FIXED_TYPE_NODE_WIDTH (N1, long_long_, LONG_LONG_ ## N2 ## _TYPE_SIZE)
9839 /* Make fixed-point mode nodes based on sat/non-sat and signed/unsigned. */
9840 #define MAKE_FIXED_MODE_NODE(KIND,NAME,MODE) \
9841 NAME ## _type_node = \
9842 make_or_reuse_signed_ ## KIND ## _type (GET_MODE_BITSIZE (MODE ## mode)); \
9843 u ## NAME ## _type_node = \
9844 make_or_reuse_unsigned_ ## KIND ## _type \
9845 (GET_MODE_BITSIZE (U ## MODE ## mode)); \
9846 sat_ ## NAME ## _type_node = \
9847 make_or_reuse_sat_signed_ ## KIND ## _type \
9848 (GET_MODE_BITSIZE (MODE ## mode)); \
9849 sat_u ## NAME ## _type_node = \
9850 make_or_reuse_sat_unsigned_ ## KIND ## _type \
9851 (GET_MODE_BITSIZE (U ## MODE ## mode));
9853 /* Fixed-point type and mode nodes. */
9854 MAKE_FIXED_TYPE_NODE_FAMILY (fract
, FRACT
)
9855 MAKE_FIXED_TYPE_NODE_FAMILY (accum
, ACCUM
)
9856 MAKE_FIXED_MODE_NODE (fract
, qq
, QQ
)
9857 MAKE_FIXED_MODE_NODE (fract
, hq
, HQ
)
9858 MAKE_FIXED_MODE_NODE (fract
, sq
, SQ
)
9859 MAKE_FIXED_MODE_NODE (fract
, dq
, DQ
)
9860 MAKE_FIXED_MODE_NODE (fract
, tq
, TQ
)
9861 MAKE_FIXED_MODE_NODE (accum
, ha
, HA
)
9862 MAKE_FIXED_MODE_NODE (accum
, sa
, SA
)
9863 MAKE_FIXED_MODE_NODE (accum
, da
, DA
)
9864 MAKE_FIXED_MODE_NODE (accum
, ta
, TA
)
9867 tree t
= targetm
.build_builtin_va_list ();
9869 /* Many back-ends define record types without setting TYPE_NAME.
9870 If we copied the record type here, we'd keep the original
9871 record type without a name. This breaks name mangling. So,
9872 don't copy record types and let c_common_nodes_and_builtins()
9873 declare the type to be __builtin_va_list. */
9874 if (TREE_CODE (t
) != RECORD_TYPE
)
9875 t
= build_variant_type_copy (t
);
9877 va_list_type_node
= t
;
9881 /* Modify DECL for given flags.
9882 TM_PURE attribute is set only on types, so the function will modify
9883 DECL's type when ECF_TM_PURE is used. */
9886 set_call_expr_flags (tree decl
, int flags
)
9888 if (flags
& ECF_NOTHROW
)
9889 TREE_NOTHROW (decl
) = 1;
9890 if (flags
& ECF_CONST
)
9891 TREE_READONLY (decl
) = 1;
9892 if (flags
& ECF_PURE
)
9893 DECL_PURE_P (decl
) = 1;
9894 if (flags
& ECF_LOOPING_CONST_OR_PURE
)
9895 DECL_LOOPING_CONST_OR_PURE_P (decl
) = 1;
9896 if (flags
& ECF_NOVOPS
)
9897 DECL_IS_NOVOPS (decl
) = 1;
9898 if (flags
& ECF_NORETURN
)
9899 TREE_THIS_VOLATILE (decl
) = 1;
9900 if (flags
& ECF_MALLOC
)
9901 DECL_IS_MALLOC (decl
) = 1;
9902 if (flags
& ECF_RETURNS_TWICE
)
9903 DECL_IS_RETURNS_TWICE (decl
) = 1;
9904 if (flags
& ECF_LEAF
)
9905 DECL_ATTRIBUTES (decl
) = tree_cons (get_identifier ("leaf"),
9906 NULL
, DECL_ATTRIBUTES (decl
));
9907 if ((flags
& ECF_TM_PURE
) && flag_tm
)
9908 apply_tm_attr (decl
, get_identifier ("transaction_pure"));
9909 /* Looping const or pure is implied by noreturn.
9910 There is currently no way to declare looping const or looping pure alone. */
9911 gcc_assert (!(flags
& ECF_LOOPING_CONST_OR_PURE
)
9912 || ((flags
& ECF_NORETURN
) && (flags
& (ECF_CONST
| ECF_PURE
))));
9916 /* A subroutine of build_common_builtin_nodes. Define a builtin function. */
9919 local_define_builtin (const char *name
, tree type
, enum built_in_function code
,
9920 const char *library_name
, int ecf_flags
)
9924 decl
= add_builtin_function (name
, type
, code
, BUILT_IN_NORMAL
,
9925 library_name
, NULL_TREE
);
9926 set_call_expr_flags (decl
, ecf_flags
);
9928 set_builtin_decl (code
, decl
, true);
9931 /* Call this function after instantiating all builtins that the language
9932 front end cares about. This will build the rest of the builtins that
9933 are relied upon by the tree optimizers and the middle-end. */
9936 build_common_builtin_nodes (void)
9941 if (!builtin_decl_explicit_p (BUILT_IN_UNREACHABLE
))
9943 ftype
= build_function_type (void_type_node
, void_list_node
);
9944 local_define_builtin ("__builtin_unreachable", ftype
, BUILT_IN_UNREACHABLE
,
9945 "__builtin_unreachable",
9946 ECF_NOTHROW
| ECF_LEAF
| ECF_NORETURN
9947 | ECF_CONST
| ECF_LEAF
);
9950 if (!builtin_decl_explicit_p (BUILT_IN_MEMCPY
)
9951 || !builtin_decl_explicit_p (BUILT_IN_MEMMOVE
))
9953 ftype
= build_function_type_list (ptr_type_node
,
9954 ptr_type_node
, const_ptr_type_node
,
9955 size_type_node
, NULL_TREE
);
9957 if (!builtin_decl_explicit_p (BUILT_IN_MEMCPY
))
9958 local_define_builtin ("__builtin_memcpy", ftype
, BUILT_IN_MEMCPY
,
9959 "memcpy", ECF_NOTHROW
| ECF_LEAF
);
9960 if (!builtin_decl_explicit_p (BUILT_IN_MEMMOVE
))
9961 local_define_builtin ("__builtin_memmove", ftype
, BUILT_IN_MEMMOVE
,
9962 "memmove", ECF_NOTHROW
| ECF_LEAF
);
9965 if (!builtin_decl_explicit_p (BUILT_IN_MEMCMP
))
9967 ftype
= build_function_type_list (integer_type_node
, const_ptr_type_node
,
9968 const_ptr_type_node
, size_type_node
,
9970 local_define_builtin ("__builtin_memcmp", ftype
, BUILT_IN_MEMCMP
,
9971 "memcmp", ECF_PURE
| ECF_NOTHROW
| ECF_LEAF
);
9974 if (!builtin_decl_explicit_p (BUILT_IN_MEMSET
))
9976 ftype
= build_function_type_list (ptr_type_node
,
9977 ptr_type_node
, integer_type_node
,
9978 size_type_node
, NULL_TREE
);
9979 local_define_builtin ("__builtin_memset", ftype
, BUILT_IN_MEMSET
,
9980 "memset", ECF_NOTHROW
| ECF_LEAF
);
9983 if (!builtin_decl_explicit_p (BUILT_IN_ALLOCA
))
9985 ftype
= build_function_type_list (ptr_type_node
,
9986 size_type_node
, NULL_TREE
);
9987 local_define_builtin ("__builtin_alloca", ftype
, BUILT_IN_ALLOCA
,
9988 "alloca", ECF_MALLOC
| ECF_NOTHROW
| ECF_LEAF
);
9991 ftype
= build_function_type_list (ptr_type_node
, size_type_node
,
9992 size_type_node
, NULL_TREE
);
9993 local_define_builtin ("__builtin_alloca_with_align", ftype
,
9994 BUILT_IN_ALLOCA_WITH_ALIGN
, "alloca",
9995 ECF_MALLOC
| ECF_NOTHROW
| ECF_LEAF
);
9997 /* If we're checking the stack, `alloca' can throw. */
9998 if (flag_stack_check
)
10000 TREE_NOTHROW (builtin_decl_explicit (BUILT_IN_ALLOCA
)) = 0;
10001 TREE_NOTHROW (builtin_decl_explicit (BUILT_IN_ALLOCA_WITH_ALIGN
)) = 0;
10004 ftype
= build_function_type_list (void_type_node
,
10005 ptr_type_node
, ptr_type_node
,
10006 ptr_type_node
, NULL_TREE
);
10007 local_define_builtin ("__builtin_init_trampoline", ftype
,
10008 BUILT_IN_INIT_TRAMPOLINE
,
10009 "__builtin_init_trampoline", ECF_NOTHROW
| ECF_LEAF
);
10010 local_define_builtin ("__builtin_init_heap_trampoline", ftype
,
10011 BUILT_IN_INIT_HEAP_TRAMPOLINE
,
10012 "__builtin_init_heap_trampoline",
10013 ECF_NOTHROW
| ECF_LEAF
);
10015 ftype
= build_function_type_list (ptr_type_node
, ptr_type_node
, NULL_TREE
);
10016 local_define_builtin ("__builtin_adjust_trampoline", ftype
,
10017 BUILT_IN_ADJUST_TRAMPOLINE
,
10018 "__builtin_adjust_trampoline",
10019 ECF_CONST
| ECF_NOTHROW
);
10021 ftype
= build_function_type_list (void_type_node
,
10022 ptr_type_node
, ptr_type_node
, NULL_TREE
);
10023 local_define_builtin ("__builtin_nonlocal_goto", ftype
,
10024 BUILT_IN_NONLOCAL_GOTO
,
10025 "__builtin_nonlocal_goto",
10026 ECF_NORETURN
| ECF_NOTHROW
);
10028 ftype
= build_function_type_list (void_type_node
,
10029 ptr_type_node
, ptr_type_node
, NULL_TREE
);
10030 local_define_builtin ("__builtin_setjmp_setup", ftype
,
10031 BUILT_IN_SETJMP_SETUP
,
10032 "__builtin_setjmp_setup", ECF_NOTHROW
);
10034 ftype
= build_function_type_list (void_type_node
, ptr_type_node
, NULL_TREE
);
10035 local_define_builtin ("__builtin_setjmp_receiver", ftype
,
10036 BUILT_IN_SETJMP_RECEIVER
,
10037 "__builtin_setjmp_receiver", ECF_NOTHROW
| ECF_LEAF
);
10039 ftype
= build_function_type_list (ptr_type_node
, NULL_TREE
);
10040 local_define_builtin ("__builtin_stack_save", ftype
, BUILT_IN_STACK_SAVE
,
10041 "__builtin_stack_save", ECF_NOTHROW
| ECF_LEAF
);
10043 ftype
= build_function_type_list (void_type_node
, ptr_type_node
, NULL_TREE
);
10044 local_define_builtin ("__builtin_stack_restore", ftype
,
10045 BUILT_IN_STACK_RESTORE
,
10046 "__builtin_stack_restore", ECF_NOTHROW
| ECF_LEAF
);
10048 /* If there's a possibility that we might use the ARM EABI, build the
10049 alternate __cxa_end_cleanup node used to resume from C++ and Java. */
10050 if (targetm
.arm_eabi_unwinder
)
10052 ftype
= build_function_type_list (void_type_node
, NULL_TREE
);
10053 local_define_builtin ("__builtin_cxa_end_cleanup", ftype
,
10054 BUILT_IN_CXA_END_CLEANUP
,
10055 "__cxa_end_cleanup", ECF_NORETURN
| ECF_LEAF
);
10058 ftype
= build_function_type_list (void_type_node
, ptr_type_node
, NULL_TREE
);
10059 local_define_builtin ("__builtin_unwind_resume", ftype
,
10060 BUILT_IN_UNWIND_RESUME
,
10061 ((targetm_common
.except_unwind_info (&global_options
)
10063 ? "_Unwind_SjLj_Resume" : "_Unwind_Resume"),
10066 if (builtin_decl_explicit (BUILT_IN_RETURN_ADDRESS
) == NULL_TREE
)
10068 ftype
= build_function_type_list (ptr_type_node
, integer_type_node
,
10070 local_define_builtin ("__builtin_return_address", ftype
,
10071 BUILT_IN_RETURN_ADDRESS
,
10072 "__builtin_return_address",
10076 if (!builtin_decl_explicit_p (BUILT_IN_PROFILE_FUNC_ENTER
)
10077 || !builtin_decl_explicit_p (BUILT_IN_PROFILE_FUNC_EXIT
))
10079 ftype
= build_function_type_list (void_type_node
, ptr_type_node
,
10080 ptr_type_node
, NULL_TREE
);
10081 if (!builtin_decl_explicit_p (BUILT_IN_PROFILE_FUNC_ENTER
))
10082 local_define_builtin ("__cyg_profile_func_enter", ftype
,
10083 BUILT_IN_PROFILE_FUNC_ENTER
,
10084 "__cyg_profile_func_enter", 0);
10085 if (!builtin_decl_explicit_p (BUILT_IN_PROFILE_FUNC_EXIT
))
10086 local_define_builtin ("__cyg_profile_func_exit", ftype
,
10087 BUILT_IN_PROFILE_FUNC_EXIT
,
10088 "__cyg_profile_func_exit", 0);
10091 /* The exception object and filter values from the runtime. The argument
10092 must be zero before exception lowering, i.e. from the front end. After
10093 exception lowering, it will be the region number for the exception
10094 landing pad. These functions are PURE instead of CONST to prevent
10095 them from being hoisted past the exception edge that will initialize
10096 its value in the landing pad. */
10097 ftype
= build_function_type_list (ptr_type_node
,
10098 integer_type_node
, NULL_TREE
);
10099 ecf_flags
= ECF_PURE
| ECF_NOTHROW
| ECF_LEAF
;
10100 /* Only use TM_PURE if we we have TM language support. */
10101 if (builtin_decl_explicit_p (BUILT_IN_TM_LOAD_1
))
10102 ecf_flags
|= ECF_TM_PURE
;
10103 local_define_builtin ("__builtin_eh_pointer", ftype
, BUILT_IN_EH_POINTER
,
10104 "__builtin_eh_pointer", ecf_flags
);
10106 tmp
= lang_hooks
.types
.type_for_mode (targetm
.eh_return_filter_mode (), 0);
10107 ftype
= build_function_type_list (tmp
, integer_type_node
, NULL_TREE
);
10108 local_define_builtin ("__builtin_eh_filter", ftype
, BUILT_IN_EH_FILTER
,
10109 "__builtin_eh_filter", ECF_PURE
| ECF_NOTHROW
| ECF_LEAF
);
10111 ftype
= build_function_type_list (void_type_node
,
10112 integer_type_node
, integer_type_node
,
10114 local_define_builtin ("__builtin_eh_copy_values", ftype
,
10115 BUILT_IN_EH_COPY_VALUES
,
10116 "__builtin_eh_copy_values", ECF_NOTHROW
);
10118 /* Complex multiplication and division. These are handled as builtins
10119 rather than optabs because emit_library_call_value doesn't support
10120 complex. Further, we can do slightly better with folding these
10121 beasties if the real and complex parts of the arguments are separate. */
10125 for (mode
= MIN_MODE_COMPLEX_FLOAT
; mode
<= MAX_MODE_COMPLEX_FLOAT
; ++mode
)
10127 char mode_name_buf
[4], *q
;
10129 enum built_in_function mcode
, dcode
;
10130 tree type
, inner_type
;
10131 const char *prefix
= "__";
10133 if (targetm
.libfunc_gnu_prefix
)
10136 type
= lang_hooks
.types
.type_for_mode ((enum machine_mode
) mode
, 0);
10139 inner_type
= TREE_TYPE (type
);
10141 ftype
= build_function_type_list (type
, inner_type
, inner_type
,
10142 inner_type
, inner_type
, NULL_TREE
);
10144 mcode
= ((enum built_in_function
)
10145 (BUILT_IN_COMPLEX_MUL_MIN
+ mode
- MIN_MODE_COMPLEX_FLOAT
));
10146 dcode
= ((enum built_in_function
)
10147 (BUILT_IN_COMPLEX_DIV_MIN
+ mode
- MIN_MODE_COMPLEX_FLOAT
));
10149 for (p
= GET_MODE_NAME (mode
), q
= mode_name_buf
; *p
; p
++, q
++)
10153 built_in_names
[mcode
] = concat (prefix
, "mul", mode_name_buf
, "3",
10155 local_define_builtin (built_in_names
[mcode
], ftype
, mcode
,
10156 built_in_names
[mcode
],
10157 ECF_CONST
| ECF_NOTHROW
| ECF_LEAF
);
10159 built_in_names
[dcode
] = concat (prefix
, "div", mode_name_buf
, "3",
10161 local_define_builtin (built_in_names
[dcode
], ftype
, dcode
,
10162 built_in_names
[dcode
],
10163 ECF_CONST
| ECF_NOTHROW
| ECF_LEAF
);
10168 /* HACK. GROSS. This is absolutely disgusting. I wish there was a
10171 If we requested a pointer to a vector, build up the pointers that
10172 we stripped off while looking for the inner type. Similarly for
10173 return values from functions.
10175 The argument TYPE is the top of the chain, and BOTTOM is the
10176 new type which we will point to. */
10179 reconstruct_complex_type (tree type
, tree bottom
)
10183 if (TREE_CODE (type
) == POINTER_TYPE
)
10185 inner
= reconstruct_complex_type (TREE_TYPE (type
), bottom
);
10186 outer
= build_pointer_type_for_mode (inner
, TYPE_MODE (type
),
10187 TYPE_REF_CAN_ALIAS_ALL (type
));
10189 else if (TREE_CODE (type
) == REFERENCE_TYPE
)
10191 inner
= reconstruct_complex_type (TREE_TYPE (type
), bottom
);
10192 outer
= build_reference_type_for_mode (inner
, TYPE_MODE (type
),
10193 TYPE_REF_CAN_ALIAS_ALL (type
));
10195 else if (TREE_CODE (type
) == ARRAY_TYPE
)
10197 inner
= reconstruct_complex_type (TREE_TYPE (type
), bottom
);
10198 outer
= build_array_type (inner
, TYPE_DOMAIN (type
));
10200 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
10202 inner
= reconstruct_complex_type (TREE_TYPE (type
), bottom
);
10203 outer
= build_function_type (inner
, TYPE_ARG_TYPES (type
));
10205 else if (TREE_CODE (type
) == METHOD_TYPE
)
10207 inner
= reconstruct_complex_type (TREE_TYPE (type
), bottom
);
10208 /* The build_method_type_directly() routine prepends 'this' to argument list,
10209 so we must compensate by getting rid of it. */
10211 = build_method_type_directly
10212 (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (type
))),
10214 TREE_CHAIN (TYPE_ARG_TYPES (type
)));
10216 else if (TREE_CODE (type
) == OFFSET_TYPE
)
10218 inner
= reconstruct_complex_type (TREE_TYPE (type
), bottom
);
10219 outer
= build_offset_type (TYPE_OFFSET_BASETYPE (type
), inner
);
10224 return build_type_attribute_qual_variant (outer
, TYPE_ATTRIBUTES (type
),
10225 TYPE_QUALS (type
));
10228 /* Returns a vector tree node given a mode (integer, vector, or BLKmode) and
10231 build_vector_type_for_mode (tree innertype
, enum machine_mode mode
)
10235 switch (GET_MODE_CLASS (mode
))
10237 case MODE_VECTOR_INT
:
10238 case MODE_VECTOR_FLOAT
:
10239 case MODE_VECTOR_FRACT
:
10240 case MODE_VECTOR_UFRACT
:
10241 case MODE_VECTOR_ACCUM
:
10242 case MODE_VECTOR_UACCUM
:
10243 nunits
= GET_MODE_NUNITS (mode
);
10247 /* Check that there are no leftover bits. */
10248 gcc_assert (GET_MODE_BITSIZE (mode
)
10249 % TREE_INT_CST_LOW (TYPE_SIZE (innertype
)) == 0);
10251 nunits
= GET_MODE_BITSIZE (mode
)
10252 / TREE_INT_CST_LOW (TYPE_SIZE (innertype
));
10256 gcc_unreachable ();
10259 return make_vector_type (innertype
, nunits
, mode
);
10262 /* Similarly, but takes the inner type and number of units, which must be
10266 build_vector_type (tree innertype
, int nunits
)
10268 return make_vector_type (innertype
, nunits
, VOIDmode
);
10271 /* Similarly, but builds a variant type with TYPE_VECTOR_OPAQUE set. */
10274 build_opaque_vector_type (tree innertype
, int nunits
)
10276 tree t
= make_vector_type (innertype
, nunits
, VOIDmode
);
10278 /* We always build the non-opaque variant before the opaque one,
10279 so if it already exists, it is TYPE_NEXT_VARIANT of this one. */
10280 cand
= TYPE_NEXT_VARIANT (t
);
10282 && TYPE_VECTOR_OPAQUE (cand
)
10283 && check_qualified_type (cand
, t
, TYPE_QUALS (t
), NULL_TREE
))
10285 /* Othewise build a variant type and make sure to queue it after
10286 the non-opaque type. */
10287 cand
= build_distinct_type_copy (t
);
10288 TYPE_VECTOR_OPAQUE (cand
) = true;
10289 TYPE_CANONICAL (cand
) = TYPE_CANONICAL (t
);
10290 TYPE_NEXT_VARIANT (cand
) = TYPE_NEXT_VARIANT (t
);
10291 TYPE_NEXT_VARIANT (t
) = cand
;
10292 TYPE_MAIN_VARIANT (cand
) = TYPE_MAIN_VARIANT (t
);
10297 /* Given an initializer INIT, return TRUE if INIT is zero or some
10298 aggregate of zeros. Otherwise return FALSE. */
10300 initializer_zerop (const_tree init
)
10306 switch (TREE_CODE (init
))
10309 return integer_zerop (init
);
10312 /* ??? Note that this is not correct for C4X float formats. There,
10313 a bit pattern of all zeros is 1.0; 0.0 is encoded with the most
10314 negative exponent. */
10315 return real_zerop (init
)
10316 && ! REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (init
));
10319 return fixed_zerop (init
);
10322 return integer_zerop (init
)
10323 || (real_zerop (init
)
10324 && ! REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (TREE_REALPART (init
)))
10325 && ! REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (TREE_IMAGPART (init
))));
10330 for (i
= 0; i
< VECTOR_CST_NELTS (init
); ++i
)
10331 if (!initializer_zerop (VECTOR_CST_ELT (init
, i
)))
10338 unsigned HOST_WIDE_INT idx
;
10340 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (init
), idx
, elt
)
10341 if (!initializer_zerop (elt
))
10350 /* We need to loop through all elements to handle cases like
10351 "\0" and "\0foobar". */
10352 for (i
= 0; i
< TREE_STRING_LENGTH (init
); ++i
)
10353 if (TREE_STRING_POINTER (init
)[i
] != '\0')
10364 /* Check if vector VEC consists of all the equal elements and
10365 that the number of elements corresponds to the type of VEC.
10366 The function returns first element of the vector
10367 or NULL_TREE if the vector is not uniform. */
10369 uniform_vector_p (const_tree vec
)
10374 if (vec
== NULL_TREE
)
10377 gcc_assert (VECTOR_TYPE_P (TREE_TYPE (vec
)));
10379 if (TREE_CODE (vec
) == VECTOR_CST
)
10381 first
= VECTOR_CST_ELT (vec
, 0);
10382 for (i
= 1; i
< VECTOR_CST_NELTS (vec
); ++i
)
10383 if (!operand_equal_p (first
, VECTOR_CST_ELT (vec
, i
), 0))
10389 else if (TREE_CODE (vec
) == CONSTRUCTOR
)
10391 first
= error_mark_node
;
10393 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (vec
), i
, t
)
10400 if (!operand_equal_p (first
, t
, 0))
10403 if (i
!= TYPE_VECTOR_SUBPARTS (TREE_TYPE (vec
)))
10412 /* Build an empty statement at location LOC. */
10415 build_empty_stmt (location_t loc
)
10417 tree t
= build1 (NOP_EXPR
, void_type_node
, size_zero_node
);
10418 SET_EXPR_LOCATION (t
, loc
);
10423 /* Build an OpenMP clause with code CODE. LOC is the location of the
10427 build_omp_clause (location_t loc
, enum omp_clause_code code
)
10432 length
= omp_clause_num_ops
[code
];
10433 size
= (sizeof (struct tree_omp_clause
) + (length
- 1) * sizeof (tree
));
10435 record_node_allocation_statistics (OMP_CLAUSE
, size
);
10437 t
= ggc_alloc_tree_node (size
);
10438 memset (t
, 0, size
);
10439 TREE_SET_CODE (t
, OMP_CLAUSE
);
10440 OMP_CLAUSE_SET_CODE (t
, code
);
10441 OMP_CLAUSE_LOCATION (t
) = loc
;
10446 /* Build a tcc_vl_exp object with code CODE and room for LEN operands. LEN
10447 includes the implicit operand count in TREE_OPERAND 0, and so must be >= 1.
10448 Except for the CODE and operand count field, other storage for the
10449 object is initialized to zeros. */
10452 build_vl_exp_stat (enum tree_code code
, int len MEM_STAT_DECL
)
10455 int length
= (len
- 1) * sizeof (tree
) + sizeof (struct tree_exp
);
10457 gcc_assert (TREE_CODE_CLASS (code
) == tcc_vl_exp
);
10458 gcc_assert (len
>= 1);
10460 record_node_allocation_statistics (code
, length
);
10462 t
= ggc_alloc_cleared_tree_node_stat (length PASS_MEM_STAT
);
10464 TREE_SET_CODE (t
, code
);
10466 /* Can't use TREE_OPERAND to store the length because if checking is
10467 enabled, it will try to check the length before we store it. :-P */
10468 t
->exp
.operands
[0] = build_int_cst (sizetype
, len
);
10473 /* Helper function for build_call_* functions; build a CALL_EXPR with
10474 indicated RETURN_TYPE, FN, and NARGS, but do not initialize any of
10475 the argument slots. */
10478 build_call_1 (tree return_type
, tree fn
, int nargs
)
10482 t
= build_vl_exp (CALL_EXPR
, nargs
+ 3);
10483 TREE_TYPE (t
) = return_type
;
10484 CALL_EXPR_FN (t
) = fn
;
10485 CALL_EXPR_STATIC_CHAIN (t
) = NULL
;
10490 /* Build a CALL_EXPR of class tcc_vl_exp with the indicated RETURN_TYPE and
10491 FN and a null static chain slot. NARGS is the number of call arguments
10492 which are specified as "..." arguments. */
10495 build_call_nary (tree return_type
, tree fn
, int nargs
, ...)
10499 va_start (args
, nargs
);
10500 ret
= build_call_valist (return_type
, fn
, nargs
, args
);
10505 /* Build a CALL_EXPR of class tcc_vl_exp with the indicated RETURN_TYPE and
10506 FN and a null static chain slot. NARGS is the number of call arguments
10507 which are specified as a va_list ARGS. */
10510 build_call_valist (tree return_type
, tree fn
, int nargs
, va_list args
)
10515 t
= build_call_1 (return_type
, fn
, nargs
);
10516 for (i
= 0; i
< nargs
; i
++)
10517 CALL_EXPR_ARG (t
, i
) = va_arg (args
, tree
);
10518 process_call_operands (t
);
10522 /* Build a CALL_EXPR of class tcc_vl_exp with the indicated RETURN_TYPE and
10523 FN and a null static chain slot. NARGS is the number of call arguments
10524 which are specified as a tree array ARGS. */
10527 build_call_array_loc (location_t loc
, tree return_type
, tree fn
,
10528 int nargs
, const tree
*args
)
10533 t
= build_call_1 (return_type
, fn
, nargs
);
10534 for (i
= 0; i
< nargs
; i
++)
10535 CALL_EXPR_ARG (t
, i
) = args
[i
];
10536 process_call_operands (t
);
10537 SET_EXPR_LOCATION (t
, loc
);
10541 /* Like build_call_array, but takes a vec. */
10544 build_call_vec (tree return_type
, tree fn
, vec
<tree
, va_gc
> *args
)
10549 ret
= build_call_1 (return_type
, fn
, vec_safe_length (args
));
10550 FOR_EACH_VEC_SAFE_ELT (args
, ix
, t
)
10551 CALL_EXPR_ARG (ret
, ix
) = t
;
10552 process_call_operands (ret
);
10556 /* Return true if T (assumed to be a DECL) must be assigned a memory
10560 needs_to_live_in_memory (const_tree t
)
10562 return (TREE_ADDRESSABLE (t
)
10563 || is_global_var (t
)
10564 || (TREE_CODE (t
) == RESULT_DECL
10565 && !DECL_BY_REFERENCE (t
)
10566 && aggregate_value_p (t
, current_function_decl
)));
10569 /* Return value of a constant X and sign-extend it. */
10572 int_cst_value (const_tree x
)
10574 unsigned bits
= TYPE_PRECISION (TREE_TYPE (x
));
10575 unsigned HOST_WIDE_INT val
= TREE_INT_CST_LOW (x
);
10577 /* Make sure the sign-extended value will fit in a HOST_WIDE_INT. */
10578 gcc_assert (TREE_INT_CST_HIGH (x
) == 0
10579 || TREE_INT_CST_HIGH (x
) == -1);
10581 if (bits
< HOST_BITS_PER_WIDE_INT
)
10583 bool negative
= ((val
>> (bits
- 1)) & 1) != 0;
10585 val
|= (~(unsigned HOST_WIDE_INT
) 0) << (bits
- 1) << 1;
10587 val
&= ~((~(unsigned HOST_WIDE_INT
) 0) << (bits
- 1) << 1);
10593 /* Return value of a constant X and sign-extend it. */
10596 widest_int_cst_value (const_tree x
)
10598 unsigned bits
= TYPE_PRECISION (TREE_TYPE (x
));
10599 unsigned HOST_WIDEST_INT val
= TREE_INT_CST_LOW (x
);
10601 #if HOST_BITS_PER_WIDEST_INT > HOST_BITS_PER_WIDE_INT
10602 gcc_assert (HOST_BITS_PER_WIDEST_INT
>= HOST_BITS_PER_DOUBLE_INT
);
10603 val
|= (((unsigned HOST_WIDEST_INT
) TREE_INT_CST_HIGH (x
))
10604 << HOST_BITS_PER_WIDE_INT
);
10606 /* Make sure the sign-extended value will fit in a HOST_WIDE_INT. */
10607 gcc_assert (TREE_INT_CST_HIGH (x
) == 0
10608 || TREE_INT_CST_HIGH (x
) == -1);
10611 if (bits
< HOST_BITS_PER_WIDEST_INT
)
10613 bool negative
= ((val
>> (bits
- 1)) & 1) != 0;
10615 val
|= (~(unsigned HOST_WIDEST_INT
) 0) << (bits
- 1) << 1;
10617 val
&= ~((~(unsigned HOST_WIDEST_INT
) 0) << (bits
- 1) << 1);
10623 /* If TYPE is an integral or pointer type, return an integer type with
10624 the same precision which is unsigned iff UNSIGNEDP is true, or itself
10625 if TYPE is already an integer type of signedness UNSIGNEDP. */
10628 signed_or_unsigned_type_for (int unsignedp
, tree type
)
10630 if (TREE_CODE (type
) == INTEGER_TYPE
&& TYPE_UNSIGNED (type
) == unsignedp
)
10633 if (TREE_CODE (type
) == VECTOR_TYPE
)
10635 tree inner
= TREE_TYPE (type
);
10636 tree inner2
= signed_or_unsigned_type_for (unsignedp
, inner
);
10639 if (inner
== inner2
)
10641 return build_vector_type (inner2
, TYPE_VECTOR_SUBPARTS (type
));
10644 if (!INTEGRAL_TYPE_P (type
)
10645 && !POINTER_TYPE_P (type
)
10646 && TREE_CODE (type
) != OFFSET_TYPE
)
10649 return build_nonstandard_integer_type (TYPE_PRECISION (type
), unsignedp
);
10652 /* If TYPE is an integral or pointer type, return an integer type with
10653 the same precision which is unsigned, or itself if TYPE is already an
10654 unsigned integer type. */
10657 unsigned_type_for (tree type
)
10659 return signed_or_unsigned_type_for (1, type
);
10662 /* If TYPE is an integral or pointer type, return an integer type with
10663 the same precision which is signed, or itself if TYPE is already a
10664 signed integer type. */
10667 signed_type_for (tree type
)
10669 return signed_or_unsigned_type_for (0, type
);
10672 /* If TYPE is a vector type, return a signed integer vector type with the
10673 same width and number of subparts. Otherwise return boolean_type_node. */
10676 truth_type_for (tree type
)
10678 if (TREE_CODE (type
) == VECTOR_TYPE
)
10680 tree elem
= lang_hooks
.types
.type_for_size
10681 (GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (type
))), 0);
10682 return build_opaque_vector_type (elem
, TYPE_VECTOR_SUBPARTS (type
));
10685 return boolean_type_node
;
10688 /* Returns the largest value obtainable by casting something in INNER type to
10692 upper_bound_in_type (tree outer
, tree inner
)
10695 unsigned int det
= 0;
10696 unsigned oprec
= TYPE_PRECISION (outer
);
10697 unsigned iprec
= TYPE_PRECISION (inner
);
10700 /* Compute a unique number for every combination. */
10701 det
|= (oprec
> iprec
) ? 4 : 0;
10702 det
|= TYPE_UNSIGNED (outer
) ? 2 : 0;
10703 det
|= TYPE_UNSIGNED (inner
) ? 1 : 0;
10705 /* Determine the exponent to use. */
10710 /* oprec <= iprec, outer: signed, inner: don't care. */
10715 /* oprec <= iprec, outer: unsigned, inner: don't care. */
10719 /* oprec > iprec, outer: signed, inner: signed. */
10723 /* oprec > iprec, outer: signed, inner: unsigned. */
10727 /* oprec > iprec, outer: unsigned, inner: signed. */
10731 /* oprec > iprec, outer: unsigned, inner: unsigned. */
10735 gcc_unreachable ();
10738 /* Compute 2^^prec - 1. */
10739 if (prec
<= HOST_BITS_PER_WIDE_INT
)
10742 high
.low
= ((~(unsigned HOST_WIDE_INT
) 0)
10743 >> (HOST_BITS_PER_WIDE_INT
- prec
));
10747 high
.high
= ((~(unsigned HOST_WIDE_INT
) 0)
10748 >> (HOST_BITS_PER_DOUBLE_INT
- prec
));
10749 high
.low
= ~(unsigned HOST_WIDE_INT
) 0;
10752 return double_int_to_tree (outer
, high
);
10755 /* Returns the smallest value obtainable by casting something in INNER type to
10759 lower_bound_in_type (tree outer
, tree inner
)
10762 unsigned oprec
= TYPE_PRECISION (outer
);
10763 unsigned iprec
= TYPE_PRECISION (inner
);
10765 /* If OUTER type is unsigned, we can definitely cast 0 to OUTER type
10767 if (TYPE_UNSIGNED (outer
)
10768 /* If we are widening something of an unsigned type, OUTER type
10769 contains all values of INNER type. In particular, both INNER
10770 and OUTER types have zero in common. */
10771 || (oprec
> iprec
&& TYPE_UNSIGNED (inner
)))
10772 low
.low
= low
.high
= 0;
10775 /* If we are widening a signed type to another signed type, we
10776 want to obtain -2^^(iprec-1). If we are keeping the
10777 precision or narrowing to a signed type, we want to obtain
10779 unsigned prec
= oprec
> iprec
? iprec
: oprec
;
10781 if (prec
<= HOST_BITS_PER_WIDE_INT
)
10783 low
.high
= ~(unsigned HOST_WIDE_INT
) 0;
10784 low
.low
= (~(unsigned HOST_WIDE_INT
) 0) << (prec
- 1);
10788 low
.high
= ((~(unsigned HOST_WIDE_INT
) 0)
10789 << (prec
- HOST_BITS_PER_WIDE_INT
- 1));
10794 return double_int_to_tree (outer
, low
);
10797 /* Return nonzero if two operands that are suitable for PHI nodes are
10798 necessarily equal. Specifically, both ARG0 and ARG1 must be either
10799 SSA_NAME or invariant. Note that this is strictly an optimization.
10800 That is, callers of this function can directly call operand_equal_p
10801 and get the same result, only slower. */
10804 operand_equal_for_phi_arg_p (const_tree arg0
, const_tree arg1
)
10808 if (TREE_CODE (arg0
) == SSA_NAME
|| TREE_CODE (arg1
) == SSA_NAME
)
10810 return operand_equal_p (arg0
, arg1
, 0);
10813 /* Returns number of zeros at the end of binary representation of X.
10815 ??? Use ffs if available? */
10818 num_ending_zeros (const_tree x
)
10820 unsigned HOST_WIDE_INT fr
, nfr
;
10821 unsigned num
, abits
;
10822 tree type
= TREE_TYPE (x
);
10824 if (TREE_INT_CST_LOW (x
) == 0)
10826 num
= HOST_BITS_PER_WIDE_INT
;
10827 fr
= TREE_INT_CST_HIGH (x
);
10832 fr
= TREE_INT_CST_LOW (x
);
10835 for (abits
= HOST_BITS_PER_WIDE_INT
/ 2; abits
; abits
/= 2)
10838 if (nfr
<< abits
== fr
)
10845 if (num
> TYPE_PRECISION (type
))
10846 num
= TYPE_PRECISION (type
);
10848 return build_int_cst_type (type
, num
);
10852 #define WALK_SUBTREE(NODE) \
10855 result = walk_tree_1 (&(NODE), func, data, pset, lh); \
10861 /* This is a subroutine of walk_tree that walks field of TYPE that are to
10862 be walked whenever a type is seen in the tree. Rest of operands and return
10863 value are as for walk_tree. */
10866 walk_type_fields (tree type
, walk_tree_fn func
, void *data
,
10867 struct pointer_set_t
*pset
, walk_tree_lh lh
)
10869 tree result
= NULL_TREE
;
10871 switch (TREE_CODE (type
))
10874 case REFERENCE_TYPE
:
10876 /* We have to worry about mutually recursive pointers. These can't
10877 be written in C. They can in Ada. It's pathological, but
10878 there's an ACATS test (c38102a) that checks it. Deal with this
10879 by checking if we're pointing to another pointer, that one
10880 points to another pointer, that one does too, and we have no htab.
10881 If so, get a hash table. We check three levels deep to avoid
10882 the cost of the hash table if we don't need one. */
10883 if (POINTER_TYPE_P (TREE_TYPE (type
))
10884 && POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (type
)))
10885 && POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (TREE_TYPE (type
))))
10888 result
= walk_tree_without_duplicates (&TREE_TYPE (type
),
10896 /* ... fall through ... */
10899 WALK_SUBTREE (TREE_TYPE (type
));
10903 WALK_SUBTREE (TYPE_METHOD_BASETYPE (type
));
10905 /* Fall through. */
10907 case FUNCTION_TYPE
:
10908 WALK_SUBTREE (TREE_TYPE (type
));
10912 /* We never want to walk into default arguments. */
10913 for (arg
= TYPE_ARG_TYPES (type
); arg
; arg
= TREE_CHAIN (arg
))
10914 WALK_SUBTREE (TREE_VALUE (arg
));
10919 /* Don't follow this nodes's type if a pointer for fear that
10920 we'll have infinite recursion. If we have a PSET, then we
10923 || (!POINTER_TYPE_P (TREE_TYPE (type
))
10924 && TREE_CODE (TREE_TYPE (type
)) != OFFSET_TYPE
))
10925 WALK_SUBTREE (TREE_TYPE (type
));
10926 WALK_SUBTREE (TYPE_DOMAIN (type
));
10930 WALK_SUBTREE (TREE_TYPE (type
));
10931 WALK_SUBTREE (TYPE_OFFSET_BASETYPE (type
));
10941 /* Apply FUNC to all the sub-trees of TP in a pre-order traversal. FUNC is
10942 called with the DATA and the address of each sub-tree. If FUNC returns a
10943 non-NULL value, the traversal is stopped, and the value returned by FUNC
10944 is returned. If PSET is non-NULL it is used to record the nodes visited,
10945 and to avoid visiting a node more than once. */
10948 walk_tree_1 (tree
*tp
, walk_tree_fn func
, void *data
,
10949 struct pointer_set_t
*pset
, walk_tree_lh lh
)
10951 enum tree_code code
;
10955 #define WALK_SUBTREE_TAIL(NODE) \
10959 goto tail_recurse; \
10964 /* Skip empty subtrees. */
10968 /* Don't walk the same tree twice, if the user has requested
10969 that we avoid doing so. */
10970 if (pset
&& pointer_set_insert (pset
, *tp
))
10973 /* Call the function. */
10975 result
= (*func
) (tp
, &walk_subtrees
, data
);
10977 /* If we found something, return it. */
10981 code
= TREE_CODE (*tp
);
10983 /* Even if we didn't, FUNC may have decided that there was nothing
10984 interesting below this point in the tree. */
10985 if (!walk_subtrees
)
10987 /* But we still need to check our siblings. */
10988 if (code
== TREE_LIST
)
10989 WALK_SUBTREE_TAIL (TREE_CHAIN (*tp
));
10990 else if (code
== OMP_CLAUSE
)
10991 WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp
));
10998 result
= (*lh
) (tp
, &walk_subtrees
, func
, data
, pset
);
10999 if (result
|| !walk_subtrees
)
11006 case IDENTIFIER_NODE
:
11013 case PLACEHOLDER_EXPR
:
11017 /* None of these have subtrees other than those already walked
11022 WALK_SUBTREE (TREE_VALUE (*tp
));
11023 WALK_SUBTREE_TAIL (TREE_CHAIN (*tp
));
11028 int len
= TREE_VEC_LENGTH (*tp
);
11033 /* Walk all elements but the first. */
11035 WALK_SUBTREE (TREE_VEC_ELT (*tp
, len
));
11037 /* Now walk the first one as a tail call. */
11038 WALK_SUBTREE_TAIL (TREE_VEC_ELT (*tp
, 0));
11042 WALK_SUBTREE (TREE_REALPART (*tp
));
11043 WALK_SUBTREE_TAIL (TREE_IMAGPART (*tp
));
11047 unsigned HOST_WIDE_INT idx
;
11048 constructor_elt
*ce
;
11050 for (idx
= 0; vec_safe_iterate (CONSTRUCTOR_ELTS (*tp
), idx
, &ce
);
11052 WALK_SUBTREE (ce
->value
);
11057 WALK_SUBTREE_TAIL (TREE_OPERAND (*tp
, 0));
11062 for (decl
= BIND_EXPR_VARS (*tp
); decl
; decl
= DECL_CHAIN (decl
))
11064 /* Walk the DECL_INITIAL and DECL_SIZE. We don't want to walk
11065 into declarations that are just mentioned, rather than
11066 declared; they don't really belong to this part of the tree.
11067 And, we can see cycles: the initializer for a declaration
11068 can refer to the declaration itself. */
11069 WALK_SUBTREE (DECL_INITIAL (decl
));
11070 WALK_SUBTREE (DECL_SIZE (decl
));
11071 WALK_SUBTREE (DECL_SIZE_UNIT (decl
));
11073 WALK_SUBTREE_TAIL (BIND_EXPR_BODY (*tp
));
11076 case STATEMENT_LIST
:
11078 tree_stmt_iterator i
;
11079 for (i
= tsi_start (*tp
); !tsi_end_p (i
); tsi_next (&i
))
11080 WALK_SUBTREE (*tsi_stmt_ptr (i
));
11085 switch (OMP_CLAUSE_CODE (*tp
))
11087 case OMP_CLAUSE_PRIVATE
:
11088 case OMP_CLAUSE_SHARED
:
11089 case OMP_CLAUSE_FIRSTPRIVATE
:
11090 case OMP_CLAUSE_COPYIN
:
11091 case OMP_CLAUSE_COPYPRIVATE
:
11092 case OMP_CLAUSE_FINAL
:
11093 case OMP_CLAUSE_IF
:
11094 case OMP_CLAUSE_NUM_THREADS
:
11095 case OMP_CLAUSE_SCHEDULE
:
11096 case OMP_CLAUSE_UNIFORM
:
11097 case OMP_CLAUSE_DEPEND
:
11098 case OMP_CLAUSE_NUM_TEAMS
:
11099 case OMP_CLAUSE_THREAD_LIMIT
:
11100 case OMP_CLAUSE_DEVICE
:
11101 case OMP_CLAUSE_DIST_SCHEDULE
:
11102 case OMP_CLAUSE_SAFELEN
:
11103 case OMP_CLAUSE_SIMDLEN
:
11104 case OMP_CLAUSE__LOOPTEMP_
:
11105 case OMP_CLAUSE__SIMDUID_
:
11106 WALK_SUBTREE (OMP_CLAUSE_OPERAND (*tp
, 0));
11109 case OMP_CLAUSE_NOWAIT
:
11110 case OMP_CLAUSE_ORDERED
:
11111 case OMP_CLAUSE_DEFAULT
:
11112 case OMP_CLAUSE_UNTIED
:
11113 case OMP_CLAUSE_MERGEABLE
:
11114 case OMP_CLAUSE_PROC_BIND
:
11115 case OMP_CLAUSE_INBRANCH
:
11116 case OMP_CLAUSE_NOTINBRANCH
:
11117 case OMP_CLAUSE_FOR
:
11118 case OMP_CLAUSE_PARALLEL
:
11119 case OMP_CLAUSE_SECTIONS
:
11120 case OMP_CLAUSE_TASKGROUP
:
11121 WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp
));
11123 case OMP_CLAUSE_LASTPRIVATE
:
11124 WALK_SUBTREE (OMP_CLAUSE_DECL (*tp
));
11125 WALK_SUBTREE (OMP_CLAUSE_LASTPRIVATE_STMT (*tp
));
11126 WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp
));
11128 case OMP_CLAUSE_COLLAPSE
:
11131 for (i
= 0; i
< 3; i
++)
11132 WALK_SUBTREE (OMP_CLAUSE_OPERAND (*tp
, i
));
11133 WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp
));
11136 case OMP_CLAUSE_ALIGNED
:
11137 case OMP_CLAUSE_LINEAR
:
11138 case OMP_CLAUSE_FROM
:
11139 case OMP_CLAUSE_TO
:
11140 case OMP_CLAUSE_MAP
:
11141 WALK_SUBTREE (OMP_CLAUSE_DECL (*tp
));
11142 WALK_SUBTREE (OMP_CLAUSE_OPERAND (*tp
, 1));
11143 WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp
));
11145 case OMP_CLAUSE_REDUCTION
:
11148 for (i
= 0; i
< 4; i
++)
11149 WALK_SUBTREE (OMP_CLAUSE_OPERAND (*tp
, i
));
11150 WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp
));
11154 gcc_unreachable ();
11162 /* TARGET_EXPRs are peculiar: operands 1 and 3 can be the same.
11163 But, we only want to walk once. */
11164 len
= (TREE_OPERAND (*tp
, 3) == TREE_OPERAND (*tp
, 1)) ? 2 : 3;
11165 for (i
= 0; i
< len
; ++i
)
11166 WALK_SUBTREE (TREE_OPERAND (*tp
, i
));
11167 WALK_SUBTREE_TAIL (TREE_OPERAND (*tp
, len
));
11171 /* If this is a TYPE_DECL, walk into the fields of the type that it's
11172 defining. We only want to walk into these fields of a type in this
11173 case and not in the general case of a mere reference to the type.
11175 The criterion is as follows: if the field can be an expression, it
11176 must be walked only here. This should be in keeping with the fields
11177 that are directly gimplified in gimplify_type_sizes in order for the
11178 mark/copy-if-shared/unmark machinery of the gimplifier to work with
11179 variable-sized types.
11181 Note that DECLs get walked as part of processing the BIND_EXPR. */
11182 if (TREE_CODE (DECL_EXPR_DECL (*tp
)) == TYPE_DECL
)
11184 tree
*type_p
= &TREE_TYPE (DECL_EXPR_DECL (*tp
));
11185 if (TREE_CODE (*type_p
) == ERROR_MARK
)
11188 /* Call the function for the type. See if it returns anything or
11189 doesn't want us to continue. If we are to continue, walk both
11190 the normal fields and those for the declaration case. */
11191 result
= (*func
) (type_p
, &walk_subtrees
, data
);
11192 if (result
|| !walk_subtrees
)
11195 /* But do not walk a pointed-to type since it may itself need to
11196 be walked in the declaration case if it isn't anonymous. */
11197 if (!POINTER_TYPE_P (*type_p
))
11199 result
= walk_type_fields (*type_p
, func
, data
, pset
, lh
);
11204 /* If this is a record type, also walk the fields. */
11205 if (RECORD_OR_UNION_TYPE_P (*type_p
))
11209 for (field
= TYPE_FIELDS (*type_p
); field
;
11210 field
= DECL_CHAIN (field
))
11212 /* We'd like to look at the type of the field, but we can
11213 easily get infinite recursion. So assume it's pointed
11214 to elsewhere in the tree. Also, ignore things that
11216 if (TREE_CODE (field
) != FIELD_DECL
)
11219 WALK_SUBTREE (DECL_FIELD_OFFSET (field
));
11220 WALK_SUBTREE (DECL_SIZE (field
));
11221 WALK_SUBTREE (DECL_SIZE_UNIT (field
));
11222 if (TREE_CODE (*type_p
) == QUAL_UNION_TYPE
)
11223 WALK_SUBTREE (DECL_QUALIFIER (field
));
11227 /* Same for scalar types. */
11228 else if (TREE_CODE (*type_p
) == BOOLEAN_TYPE
11229 || TREE_CODE (*type_p
) == ENUMERAL_TYPE
11230 || TREE_CODE (*type_p
) == INTEGER_TYPE
11231 || TREE_CODE (*type_p
) == FIXED_POINT_TYPE
11232 || TREE_CODE (*type_p
) == REAL_TYPE
)
11234 WALK_SUBTREE (TYPE_MIN_VALUE (*type_p
));
11235 WALK_SUBTREE (TYPE_MAX_VALUE (*type_p
));
11238 WALK_SUBTREE (TYPE_SIZE (*type_p
));
11239 WALK_SUBTREE_TAIL (TYPE_SIZE_UNIT (*type_p
));
11244 if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (code
)))
11248 /* Walk over all the sub-trees of this operand. */
11249 len
= TREE_OPERAND_LENGTH (*tp
);
11251 /* Go through the subtrees. We need to do this in forward order so
11252 that the scope of a FOR_EXPR is handled properly. */
11255 for (i
= 0; i
< len
- 1; ++i
)
11256 WALK_SUBTREE (TREE_OPERAND (*tp
, i
));
11257 WALK_SUBTREE_TAIL (TREE_OPERAND (*tp
, len
- 1));
11260 /* If this is a type, walk the needed fields in the type. */
11261 else if (TYPE_P (*tp
))
11262 return walk_type_fields (*tp
, func
, data
, pset
, lh
);
11266 /* We didn't find what we were looking for. */
11269 #undef WALK_SUBTREE_TAIL
11271 #undef WALK_SUBTREE
11273 /* Like walk_tree, but does not walk duplicate nodes more than once. */
11276 walk_tree_without_duplicates_1 (tree
*tp
, walk_tree_fn func
, void *data
,
11280 struct pointer_set_t
*pset
;
11282 pset
= pointer_set_create ();
11283 result
= walk_tree_1 (tp
, func
, data
, pset
, lh
);
11284 pointer_set_destroy (pset
);
11290 tree_block (tree t
)
11292 const enum tree_code_class c
= TREE_CODE_CLASS (TREE_CODE (t
));
11294 if (IS_EXPR_CODE_CLASS (c
))
11295 return LOCATION_BLOCK (t
->exp
.locus
);
11296 gcc_unreachable ();
11301 tree_set_block (tree t
, tree b
)
11303 const enum tree_code_class c
= TREE_CODE_CLASS (TREE_CODE (t
));
11305 if (IS_EXPR_CODE_CLASS (c
))
11308 t
->exp
.locus
= COMBINE_LOCATION_DATA (line_table
, t
->exp
.locus
, b
);
11310 t
->exp
.locus
= LOCATION_LOCUS (t
->exp
.locus
);
11313 gcc_unreachable ();
11316 /* Create a nameless artificial label and put it in the current
11317 function context. The label has a location of LOC. Returns the
11318 newly created label. */
11321 create_artificial_label (location_t loc
)
11323 tree lab
= build_decl (loc
,
11324 LABEL_DECL
, NULL_TREE
, void_type_node
);
11326 DECL_ARTIFICIAL (lab
) = 1;
11327 DECL_IGNORED_P (lab
) = 1;
11328 DECL_CONTEXT (lab
) = current_function_decl
;
11332 /* Given a tree, try to return a useful variable name that we can use
11333 to prefix a temporary that is being assigned the value of the tree.
11334 I.E. given <temp> = &A, return A. */
11339 tree stripped_decl
;
11342 STRIP_NOPS (stripped_decl
);
11343 if (DECL_P (stripped_decl
) && DECL_NAME (stripped_decl
))
11344 return IDENTIFIER_POINTER (DECL_NAME (stripped_decl
));
11345 else if (TREE_CODE (stripped_decl
) == SSA_NAME
)
11347 tree name
= SSA_NAME_IDENTIFIER (stripped_decl
);
11350 return IDENTIFIER_POINTER (name
);
11354 switch (TREE_CODE (stripped_decl
))
11357 return get_name (TREE_OPERAND (stripped_decl
, 0));
11364 /* Return true if TYPE has a variable argument list. */
11367 stdarg_p (const_tree fntype
)
11369 function_args_iterator args_iter
;
11370 tree n
= NULL_TREE
, t
;
11375 FOREACH_FUNCTION_ARGS (fntype
, t
, args_iter
)
11380 return n
!= NULL_TREE
&& n
!= void_type_node
;
11383 /* Return true if TYPE has a prototype. */
11386 prototype_p (tree fntype
)
11390 gcc_assert (fntype
!= NULL_TREE
);
11392 t
= TYPE_ARG_TYPES (fntype
);
11393 return (t
!= NULL_TREE
);
11396 /* If BLOCK is inlined from an __attribute__((__artificial__))
11397 routine, return pointer to location from where it has been
11400 block_nonartificial_location (tree block
)
11402 location_t
*ret
= NULL
;
11404 while (block
&& TREE_CODE (block
) == BLOCK
11405 && BLOCK_ABSTRACT_ORIGIN (block
))
11407 tree ao
= BLOCK_ABSTRACT_ORIGIN (block
);
11409 while (TREE_CODE (ao
) == BLOCK
11410 && BLOCK_ABSTRACT_ORIGIN (ao
)
11411 && BLOCK_ABSTRACT_ORIGIN (ao
) != ao
)
11412 ao
= BLOCK_ABSTRACT_ORIGIN (ao
);
11414 if (TREE_CODE (ao
) == FUNCTION_DECL
)
11416 /* If AO is an artificial inline, point RET to the
11417 call site locus at which it has been inlined and continue
11418 the loop, in case AO's caller is also an artificial
11420 if (DECL_DECLARED_INLINE_P (ao
)
11421 && lookup_attribute ("artificial", DECL_ATTRIBUTES (ao
)))
11422 ret
= &BLOCK_SOURCE_LOCATION (block
);
11426 else if (TREE_CODE (ao
) != BLOCK
)
11429 block
= BLOCK_SUPERCONTEXT (block
);
11435 /* If EXP is inlined from an __attribute__((__artificial__))
11436 function, return the location of the original call expression. */
11439 tree_nonartificial_location (tree exp
)
11441 location_t
*loc
= block_nonartificial_location (TREE_BLOCK (exp
));
11446 return EXPR_LOCATION (exp
);
11450 /* These are the hash table functions for the hash table of OPTIMIZATION_NODEq
11453 /* Return the hash code code X, an OPTIMIZATION_NODE or TARGET_OPTION code. */
11456 cl_option_hash_hash (const void *x
)
11458 const_tree
const t
= (const_tree
) x
;
11462 hashval_t hash
= 0;
11464 if (TREE_CODE (t
) == OPTIMIZATION_NODE
)
11466 p
= (const char *)TREE_OPTIMIZATION (t
);
11467 len
= sizeof (struct cl_optimization
);
11470 else if (TREE_CODE (t
) == TARGET_OPTION_NODE
)
11472 p
= (const char *)TREE_TARGET_OPTION (t
);
11473 len
= sizeof (struct cl_target_option
);
11477 gcc_unreachable ();
11479 /* assume most opt flags are just 0/1, some are 2-3, and a few might be
11481 for (i
= 0; i
< len
; i
++)
11483 hash
= (hash
<< 4) ^ ((i
<< 2) | p
[i
]);
11488 /* Return nonzero if the value represented by *X (an OPTIMIZATION or
11489 TARGET_OPTION tree node) is the same as that given by *Y, which is the
11493 cl_option_hash_eq (const void *x
, const void *y
)
11495 const_tree
const xt
= (const_tree
) x
;
11496 const_tree
const yt
= (const_tree
) y
;
11501 if (TREE_CODE (xt
) != TREE_CODE (yt
))
11504 if (TREE_CODE (xt
) == OPTIMIZATION_NODE
)
11506 xp
= (const char *)TREE_OPTIMIZATION (xt
);
11507 yp
= (const char *)TREE_OPTIMIZATION (yt
);
11508 len
= sizeof (struct cl_optimization
);
11511 else if (TREE_CODE (xt
) == TARGET_OPTION_NODE
)
11513 xp
= (const char *)TREE_TARGET_OPTION (xt
);
11514 yp
= (const char *)TREE_TARGET_OPTION (yt
);
11515 len
= sizeof (struct cl_target_option
);
11519 gcc_unreachable ();
11521 return (memcmp (xp
, yp
, len
) == 0);
11524 /* Build an OPTIMIZATION_NODE based on the options in OPTS. */
11527 build_optimization_node (struct gcc_options
*opts
)
11532 /* Use the cache of optimization nodes. */
11534 cl_optimization_save (TREE_OPTIMIZATION (cl_optimization_node
),
11537 slot
= htab_find_slot (cl_option_hash_table
, cl_optimization_node
, INSERT
);
11541 /* Insert this one into the hash table. */
11542 t
= cl_optimization_node
;
11545 /* Make a new node for next time round. */
11546 cl_optimization_node
= make_node (OPTIMIZATION_NODE
);
11552 /* Build a TARGET_OPTION_NODE based on the options in OPTS. */
11555 build_target_option_node (struct gcc_options
*opts
)
11560 /* Use the cache of optimization nodes. */
11562 cl_target_option_save (TREE_TARGET_OPTION (cl_target_option_node
),
11565 slot
= htab_find_slot (cl_option_hash_table
, cl_target_option_node
, INSERT
);
11569 /* Insert this one into the hash table. */
11570 t
= cl_target_option_node
;
11573 /* Make a new node for next time round. */
11574 cl_target_option_node
= make_node (TARGET_OPTION_NODE
);
11580 /* Reset TREE_TARGET_GLOBALS cache for TARGET_OPTION_NODE.
11581 Called through htab_traverse. */
11584 prepare_target_option_node_for_pch (void **slot
, void *)
11586 tree node
= (tree
) *slot
;
11587 if (TREE_CODE (node
) == TARGET_OPTION_NODE
)
11588 TREE_TARGET_GLOBALS (node
) = NULL
;
11592 /* Clear TREE_TARGET_GLOBALS of all TARGET_OPTION_NODE trees,
11593 so that they aren't saved during PCH writing. */
11596 prepare_target_option_nodes_for_pch (void)
11598 htab_traverse (cl_option_hash_table
, prepare_target_option_node_for_pch
,
11602 /* Determine the "ultimate origin" of a block. The block may be an inlined
11603 instance of an inlined instance of a block which is local to an inline
11604 function, so we have to trace all of the way back through the origin chain
11605 to find out what sort of node actually served as the original seed for the
11609 block_ultimate_origin (const_tree block
)
11611 tree immediate_origin
= BLOCK_ABSTRACT_ORIGIN (block
);
11613 /* output_inline_function sets BLOCK_ABSTRACT_ORIGIN for all the
11614 nodes in the function to point to themselves; ignore that if
11615 we're trying to output the abstract instance of this function. */
11616 if (BLOCK_ABSTRACT (block
) && immediate_origin
== block
)
11619 if (immediate_origin
== NULL_TREE
)
11624 tree lookahead
= immediate_origin
;
11628 ret_val
= lookahead
;
11629 lookahead
= (TREE_CODE (ret_val
) == BLOCK
11630 ? BLOCK_ABSTRACT_ORIGIN (ret_val
) : NULL
);
11632 while (lookahead
!= NULL
&& lookahead
!= ret_val
);
11634 /* The block's abstract origin chain may not be the *ultimate* origin of
11635 the block. It could lead to a DECL that has an abstract origin set.
11636 If so, we want that DECL's abstract origin (which is what DECL_ORIGIN
11637 will give us if it has one). Note that DECL's abstract origins are
11638 supposed to be the most distant ancestor (or so decl_ultimate_origin
11639 claims), so we don't need to loop following the DECL origins. */
11640 if (DECL_P (ret_val
))
11641 return DECL_ORIGIN (ret_val
);
11647 /* Return true iff conversion in EXP generates no instruction. Mark
11648 it inline so that we fully inline into the stripping functions even
11649 though we have two uses of this function. */
11652 tree_nop_conversion (const_tree exp
)
11654 tree outer_type
, inner_type
;
11655 int outer_is_pts_p
, inner_is_pts_p
;
11657 if (!CONVERT_EXPR_P (exp
)
11658 && TREE_CODE (exp
) != NON_LVALUE_EXPR
)
11660 if (TREE_OPERAND (exp
, 0) == error_mark_node
)
11663 outer_type
= TREE_TYPE (exp
);
11664 inner_type
= TREE_TYPE (TREE_OPERAND (exp
, 0));
11669 outer_is_pts_p
= (POINTER_TYPE_P (outer_type
)
11670 && upc_shared_type_p (TREE_TYPE (outer_type
)));
11671 inner_is_pts_p
= (POINTER_TYPE_P (inner_type
)
11672 && upc_shared_type_p (TREE_TYPE (inner_type
)));
11674 /* UPC pointer-to-shared types have special
11675 equivalence rules that must be checked. */
11676 if (outer_is_pts_p
&& inner_is_pts_p
11677 && lang_hooks
.types_compatible_p
)
11678 return lang_hooks
.types_compatible_p (outer_type
, inner_type
);
11680 /* UPC pointer-to-shared types are not interchangeable
11681 with integral types. */
11682 if (outer_is_pts_p
|| inner_is_pts_p
)
11685 /* Use precision rather then machine mode when we can, which gives
11686 the correct answer even for submode (bit-field) types. */
11687 if ((INTEGRAL_TYPE_P (outer_type
)
11688 || POINTER_TYPE_P (outer_type
)
11689 || TREE_CODE (outer_type
) == OFFSET_TYPE
)
11690 && (INTEGRAL_TYPE_P (inner_type
)
11691 || POINTER_TYPE_P (inner_type
)
11692 || TREE_CODE (inner_type
) == OFFSET_TYPE
))
11693 return TYPE_PRECISION (outer_type
) == TYPE_PRECISION (inner_type
);
11695 /* Otherwise fall back on comparing machine modes (e.g. for
11696 aggregate types, floats). */
11697 return TYPE_MODE (outer_type
) == TYPE_MODE (inner_type
);
11700 /* Return true iff conversion in EXP generates no instruction. Don't
11701 consider conversions changing the signedness. */
11704 tree_sign_nop_conversion (const_tree exp
)
11706 tree outer_type
, inner_type
;
11708 if (!tree_nop_conversion (exp
))
11711 outer_type
= TREE_TYPE (exp
);
11712 inner_type
= TREE_TYPE (TREE_OPERAND (exp
, 0));
11714 return (TYPE_UNSIGNED (outer_type
) == TYPE_UNSIGNED (inner_type
)
11715 && POINTER_TYPE_P (outer_type
) == POINTER_TYPE_P (inner_type
));
11718 /* Strip conversions from EXP according to tree_nop_conversion and
11719 return the resulting expression. */
11722 tree_strip_nop_conversions (tree exp
)
11724 while (tree_nop_conversion (exp
))
11725 exp
= TREE_OPERAND (exp
, 0);
11729 /* Strip conversions from EXP according to tree_sign_nop_conversion
11730 and return the resulting expression. */
11733 tree_strip_sign_nop_conversions (tree exp
)
11735 while (tree_sign_nop_conversion (exp
))
11736 exp
= TREE_OPERAND (exp
, 0);
11740 /* Avoid any floating point extensions from EXP. */
11742 strip_float_extensions (tree exp
)
11744 tree sub
, expt
, subt
;
11746 /* For floating point constant look up the narrowest type that can hold
11747 it properly and handle it like (type)(narrowest_type)constant.
11748 This way we can optimize for instance a=a*2.0 where "a" is float
11749 but 2.0 is double constant. */
11750 if (TREE_CODE (exp
) == REAL_CST
&& !DECIMAL_FLOAT_TYPE_P (TREE_TYPE (exp
)))
11752 REAL_VALUE_TYPE orig
;
11755 orig
= TREE_REAL_CST (exp
);
11756 if (TYPE_PRECISION (TREE_TYPE (exp
)) > TYPE_PRECISION (float_type_node
)
11757 && exact_real_truncate (TYPE_MODE (float_type_node
), &orig
))
11758 type
= float_type_node
;
11759 else if (TYPE_PRECISION (TREE_TYPE (exp
))
11760 > TYPE_PRECISION (double_type_node
)
11761 && exact_real_truncate (TYPE_MODE (double_type_node
), &orig
))
11762 type
= double_type_node
;
11764 return build_real (type
, real_value_truncate (TYPE_MODE (type
), orig
));
11767 if (!CONVERT_EXPR_P (exp
))
11770 sub
= TREE_OPERAND (exp
, 0);
11771 subt
= TREE_TYPE (sub
);
11772 expt
= TREE_TYPE (exp
);
11774 if (!FLOAT_TYPE_P (subt
))
11777 if (DECIMAL_FLOAT_TYPE_P (expt
) != DECIMAL_FLOAT_TYPE_P (subt
))
11780 if (TYPE_PRECISION (subt
) > TYPE_PRECISION (expt
))
11783 return strip_float_extensions (sub
);
11786 /* Strip out all handled components that produce invariant
11790 strip_invariant_refs (const_tree op
)
11792 while (handled_component_p (op
))
11794 switch (TREE_CODE (op
))
11797 case ARRAY_RANGE_REF
:
11798 if (!is_gimple_constant (TREE_OPERAND (op
, 1))
11799 || TREE_OPERAND (op
, 2) != NULL_TREE
11800 || TREE_OPERAND (op
, 3) != NULL_TREE
)
11804 case COMPONENT_REF
:
11805 if (TREE_OPERAND (op
, 2) != NULL_TREE
)
11811 op
= TREE_OPERAND (op
, 0);
11817 static GTY(()) tree gcc_eh_personality_decl
;
11819 /* Return the GCC personality function decl. */
11822 lhd_gcc_personality (void)
11824 if (!gcc_eh_personality_decl
)
11825 gcc_eh_personality_decl
= build_personality_function ("gcc");
11826 return gcc_eh_personality_decl
;
11829 /* For languages with One Definition Rule, work out if
11830 trees are actually the same even if the tree representation
11831 differs. This handles only decls appearing in TYPE_NAME
11832 and TYPE_CONTEXT. That is NAMESPACE_DECL, TYPE_DECL,
11833 RECORD_TYPE and IDENTIFIER_NODE. */
11836 same_for_odr (tree t1
, tree t2
)
11842 /* C and C++ FEs differ by using IDENTIFIER_NODE and TYPE_DECL. */
11843 if (TREE_CODE (t1
) == IDENTIFIER_NODE
11844 && TREE_CODE (t2
) == TYPE_DECL
11845 && DECL_FILE_SCOPE_P (t1
))
11847 t2
= DECL_NAME (t2
);
11848 gcc_assert (TREE_CODE (t2
) == IDENTIFIER_NODE
);
11850 if (TREE_CODE (t2
) == IDENTIFIER_NODE
11851 && TREE_CODE (t1
) == TYPE_DECL
11852 && DECL_FILE_SCOPE_P (t2
))
11854 t1
= DECL_NAME (t1
);
11855 gcc_assert (TREE_CODE (t1
) == IDENTIFIER_NODE
);
11857 if (TREE_CODE (t1
) != TREE_CODE (t2
))
11860 return types_same_for_odr (t1
, t2
);
11862 return decls_same_for_odr (t1
, t2
);
11866 /* For languages with One Definition Rule, work out if
11867 decls are actually the same even if the tree representation
11868 differs. This handles only decls appearing in TYPE_NAME
11869 and TYPE_CONTEXT. That is NAMESPACE_DECL, TYPE_DECL,
11870 RECORD_TYPE and IDENTIFIER_NODE. */
11873 decls_same_for_odr (tree decl1
, tree decl2
)
11875 if (decl1
&& TREE_CODE (decl1
) == TYPE_DECL
11876 && DECL_ORIGINAL_TYPE (decl1
))
11877 decl1
= DECL_ORIGINAL_TYPE (decl1
);
11878 if (decl2
&& TREE_CODE (decl2
) == TYPE_DECL
11879 && DECL_ORIGINAL_TYPE (decl2
))
11880 decl2
= DECL_ORIGINAL_TYPE (decl2
);
11881 if (decl1
== decl2
)
11883 if (!decl1
|| !decl2
)
11885 gcc_checking_assert (DECL_P (decl1
) && DECL_P (decl2
));
11886 if (TREE_CODE (decl1
) != TREE_CODE (decl2
))
11888 if (TREE_CODE (decl1
) == TRANSLATION_UNIT_DECL
)
11890 if (TREE_CODE (decl1
) != NAMESPACE_DECL
11891 && TREE_CODE (decl1
) != TYPE_DECL
)
11893 if (!DECL_NAME (decl1
))
11895 gcc_checking_assert (TREE_CODE (DECL_NAME (decl1
)) == IDENTIFIER_NODE
);
11896 gcc_checking_assert (!DECL_NAME (decl2
)
11897 || TREE_CODE (DECL_NAME (decl2
)) == IDENTIFIER_NODE
);
11898 if (DECL_NAME (decl1
) != DECL_NAME (decl2
))
11900 return same_for_odr (DECL_CONTEXT (decl1
),
11901 DECL_CONTEXT (decl2
));
11904 /* For languages with One Definition Rule, work out if
11905 types are same even if the tree representation differs.
11906 This is non-trivial for LTO where minnor differences in
11907 the type representation may have prevented type merging
11908 to merge two copies of otherwise equivalent type. */
11911 types_same_for_odr (tree type1
, tree type2
)
11913 gcc_checking_assert (TYPE_P (type1
) && TYPE_P (type2
));
11914 type1
= TYPE_MAIN_VARIANT (type1
);
11915 type2
= TYPE_MAIN_VARIANT (type2
);
11916 if (type1
== type2
)
11919 #ifndef ENABLE_CHECKING
11924 /* Check for anonymous namespaces. Those have !TREE_PUBLIC
11925 on the corresponding TYPE_STUB_DECL. */
11926 if (type_in_anonymous_namespace_p (type1
)
11927 || type_in_anonymous_namespace_p (type2
))
11929 /* When assembler name of virtual table is available, it is
11930 easy to compare types for equivalence. */
11931 if (TYPE_BINFO (type1
) && TYPE_BINFO (type2
)
11932 && BINFO_VTABLE (TYPE_BINFO (type1
))
11933 && BINFO_VTABLE (TYPE_BINFO (type2
)))
11935 tree v1
= BINFO_VTABLE (TYPE_BINFO (type1
));
11936 tree v2
= BINFO_VTABLE (TYPE_BINFO (type2
));
11938 if (TREE_CODE (v1
) == POINTER_PLUS_EXPR
)
11940 if (TREE_CODE (v2
) != POINTER_PLUS_EXPR
11941 || !operand_equal_p (TREE_OPERAND (v1
, 1),
11942 TREE_OPERAND (v2
, 1), 0))
11944 v1
= TREE_OPERAND (TREE_OPERAND (v1
, 0), 0);
11945 v2
= TREE_OPERAND (TREE_OPERAND (v2
, 0), 0);
11947 v1
= DECL_ASSEMBLER_NAME (v1
);
11948 v2
= DECL_ASSEMBLER_NAME (v2
);
11952 /* FIXME: the code comparing type names consider all instantiations of the
11953 same template to have same name. This is because we have no access
11954 to template parameters. For types with no virtual method tables
11955 we thus can return false positives. At the moment we do not need
11956 to compare types in other scenarios than devirtualization. */
11958 /* If types are not structuraly same, do not bother to contnue.
11959 Match in the remainder of code would mean ODR violation. */
11960 if (!types_compatible_p (type1
, type2
))
11962 if (!TYPE_NAME (type1
))
11964 if (!decls_same_for_odr (TYPE_NAME (type1
), TYPE_NAME (type2
)))
11966 if (!same_for_odr (TYPE_CONTEXT (type1
), TYPE_CONTEXT (type2
)))
11968 /* When not in LTO the MAIN_VARIANT check should be the same. */
11969 gcc_assert (in_lto_p
);
11974 /* TARGET is a call target of GIMPLE call statement
11975 (obtained by gimple_call_fn). Return true if it is
11976 OBJ_TYPE_REF representing an virtual call of C++ method.
11977 (As opposed to OBJ_TYPE_REF representing objc calls
11978 through a cast where middle-end devirtualization machinery
11982 virtual_method_call_p (tree target
)
11984 if (TREE_CODE (target
) != OBJ_TYPE_REF
)
11986 target
= TREE_TYPE (target
);
11987 gcc_checking_assert (TREE_CODE (target
) == POINTER_TYPE
);
11988 target
= TREE_TYPE (target
);
11989 if (TREE_CODE (target
) == FUNCTION_TYPE
)
11991 gcc_checking_assert (TREE_CODE (target
) == METHOD_TYPE
);
11995 /* REF is OBJ_TYPE_REF, return the class the ref corresponds to. */
11998 obj_type_ref_class (tree ref
)
12000 gcc_checking_assert (TREE_CODE (ref
) == OBJ_TYPE_REF
);
12001 ref
= TREE_TYPE (ref
);
12002 gcc_checking_assert (TREE_CODE (ref
) == POINTER_TYPE
);
12003 ref
= TREE_TYPE (ref
);
12004 /* We look for type THIS points to. ObjC also builds
12005 OBJ_TYPE_REF with non-method calls, Their first parameter
12006 ID however also corresponds to class type. */
12007 gcc_checking_assert (TREE_CODE (ref
) == METHOD_TYPE
12008 || TREE_CODE (ref
) == FUNCTION_TYPE
);
12009 ref
= TREE_VALUE (TYPE_ARG_TYPES (ref
));
12010 gcc_checking_assert (TREE_CODE (ref
) == POINTER_TYPE
);
12011 return TREE_TYPE (ref
);
12014 /* Return true if T is in anonymous namespace. */
12017 type_in_anonymous_namespace_p (tree t
)
12019 return (TYPE_STUB_DECL (t
) && !TREE_PUBLIC (TYPE_STUB_DECL (t
)));
12022 /* Try to find a base info of BINFO that would have its field decl at offset
12023 OFFSET within the BINFO type and which is of EXPECTED_TYPE. If it can be
12024 found, return, otherwise return NULL_TREE. */
12027 get_binfo_at_offset (tree binfo
, HOST_WIDE_INT offset
, tree expected_type
)
12029 tree type
= BINFO_TYPE (binfo
);
12033 HOST_WIDE_INT pos
, size
;
12037 if (types_same_for_odr (type
, expected_type
))
12042 for (fld
= TYPE_FIELDS (type
); fld
; fld
= DECL_CHAIN (fld
))
12044 if (TREE_CODE (fld
) != FIELD_DECL
)
12047 pos
= int_bit_position (fld
);
12048 size
= tree_to_uhwi (DECL_SIZE (fld
));
12049 if (pos
<= offset
&& (pos
+ size
) > offset
)
12052 if (!fld
|| TREE_CODE (TREE_TYPE (fld
)) != RECORD_TYPE
)
12055 if (!DECL_ARTIFICIAL (fld
))
12057 binfo
= TYPE_BINFO (TREE_TYPE (fld
));
12061 /* Offset 0 indicates the primary base, whose vtable contents are
12062 represented in the binfo for the derived class. */
12063 else if (offset
!= 0)
12065 tree base_binfo
, binfo2
= binfo
;
12067 /* Find BINFO corresponding to FLD. This is bit harder
12068 by a fact that in virtual inheritance we may need to walk down
12069 the non-virtual inheritance chain. */
12072 tree containing_binfo
= NULL
, found_binfo
= NULL
;
12073 for (i
= 0; BINFO_BASE_ITERATE (binfo2
, i
, base_binfo
); i
++)
12074 if (types_same_for_odr (TREE_TYPE (base_binfo
), TREE_TYPE (fld
)))
12076 found_binfo
= base_binfo
;
12080 if ((tree_to_shwi (BINFO_OFFSET (base_binfo
))
12081 - tree_to_shwi (BINFO_OFFSET (binfo
)))
12082 * BITS_PER_UNIT
< pos
12083 /* Rule out types with no virtual methods or we can get confused
12084 here by zero sized bases. */
12085 && BINFO_VTABLE (TYPE_BINFO (BINFO_TYPE (base_binfo
)))
12086 && (!containing_binfo
12087 || (tree_to_shwi (BINFO_OFFSET (containing_binfo
))
12088 < tree_to_shwi (BINFO_OFFSET (base_binfo
)))))
12089 containing_binfo
= base_binfo
;
12092 binfo
= found_binfo
;
12095 if (!containing_binfo
)
12097 binfo2
= containing_binfo
;
12101 type
= TREE_TYPE (fld
);
12106 /* Returns true if X is a typedef decl. */
12109 is_typedef_decl (tree x
)
12111 return (x
&& TREE_CODE (x
) == TYPE_DECL
12112 && DECL_ORIGINAL_TYPE (x
) != NULL_TREE
);
12115 /* Returns true iff TYPE is a type variant created for a typedef. */
12118 typedef_variant_p (tree type
)
12120 return is_typedef_decl (TYPE_NAME (type
));
12123 /* Warn about a use of an identifier which was marked deprecated. */
12125 warn_deprecated_use (tree node
, tree attr
)
12129 if (node
== 0 || !warn_deprecated_decl
)
12135 attr
= DECL_ATTRIBUTES (node
);
12136 else if (TYPE_P (node
))
12138 tree decl
= TYPE_STUB_DECL (node
);
12140 attr
= lookup_attribute ("deprecated",
12141 TYPE_ATTRIBUTES (TREE_TYPE (decl
)));
12146 attr
= lookup_attribute ("deprecated", attr
);
12149 msg
= TREE_STRING_POINTER (TREE_VALUE (TREE_VALUE (attr
)));
12155 expanded_location xloc
= expand_location (DECL_SOURCE_LOCATION (node
));
12157 warning (OPT_Wdeprecated_declarations
,
12158 "%qD is deprecated (declared at %r%s:%d%R): %s",
12159 node
, "locus", xloc
.file
, xloc
.line
, msg
);
12161 warning (OPT_Wdeprecated_declarations
,
12162 "%qD is deprecated (declared at %r%s:%d%R)",
12163 node
, "locus", xloc
.file
, xloc
.line
);
12165 else if (TYPE_P (node
))
12167 tree what
= NULL_TREE
;
12168 tree decl
= TYPE_STUB_DECL (node
);
12170 if (TYPE_NAME (node
))
12172 if (TREE_CODE (TYPE_NAME (node
)) == IDENTIFIER_NODE
)
12173 what
= TYPE_NAME (node
);
12174 else if (TREE_CODE (TYPE_NAME (node
)) == TYPE_DECL
12175 && DECL_NAME (TYPE_NAME (node
)))
12176 what
= DECL_NAME (TYPE_NAME (node
));
12181 expanded_location xloc
12182 = expand_location (DECL_SOURCE_LOCATION (decl
));
12186 warning (OPT_Wdeprecated_declarations
,
12187 "%qE is deprecated (declared at %r%s:%d%R): %s",
12188 what
, "locus", xloc
.file
, xloc
.line
, msg
);
12190 warning (OPT_Wdeprecated_declarations
,
12191 "%qE is deprecated (declared at %r%s:%d%R)",
12192 what
, "locus", xloc
.file
, xloc
.line
);
12197 warning (OPT_Wdeprecated_declarations
,
12198 "type is deprecated (declared at %r%s:%d%R): %s",
12199 "locus", xloc
.file
, xloc
.line
, msg
);
12201 warning (OPT_Wdeprecated_declarations
,
12202 "type is deprecated (declared at %r%s:%d%R)",
12203 "locus", xloc
.file
, xloc
.line
);
12211 warning (OPT_Wdeprecated_declarations
, "%qE is deprecated: %s",
12214 warning (OPT_Wdeprecated_declarations
, "%qE is deprecated", what
);
12219 warning (OPT_Wdeprecated_declarations
, "type is deprecated: %s",
12222 warning (OPT_Wdeprecated_declarations
, "type is deprecated");
12228 /* Return true if REF has a COMPONENT_REF with a bit-field field declaration
12229 somewhere in it. */
12232 contains_bitfld_component_ref_p (const_tree ref
)
12234 while (handled_component_p (ref
))
12236 if (TREE_CODE (ref
) == COMPONENT_REF
12237 && DECL_BIT_FIELD (TREE_OPERAND (ref
, 1)))
12239 ref
= TREE_OPERAND (ref
, 0);
12245 /* Try to determine whether a TRY_CATCH expression can fall through.
12246 This is a subroutine of block_may_fallthru. */
12249 try_catch_may_fallthru (const_tree stmt
)
12251 tree_stmt_iterator i
;
12253 /* If the TRY block can fall through, the whole TRY_CATCH can
12255 if (block_may_fallthru (TREE_OPERAND (stmt
, 0)))
12258 i
= tsi_start (TREE_OPERAND (stmt
, 1));
12259 switch (TREE_CODE (tsi_stmt (i
)))
12262 /* We expect to see a sequence of CATCH_EXPR trees, each with a
12263 catch expression and a body. The whole TRY_CATCH may fall
12264 through iff any of the catch bodies falls through. */
12265 for (; !tsi_end_p (i
); tsi_next (&i
))
12267 if (block_may_fallthru (CATCH_BODY (tsi_stmt (i
))))
12272 case EH_FILTER_EXPR
:
12273 /* The exception filter expression only matters if there is an
12274 exception. If the exception does not match EH_FILTER_TYPES,
12275 we will execute EH_FILTER_FAILURE, and we will fall through
12276 if that falls through. If the exception does match
12277 EH_FILTER_TYPES, the stack unwinder will continue up the
12278 stack, so we will not fall through. We don't know whether we
12279 will throw an exception which matches EH_FILTER_TYPES or not,
12280 so we just ignore EH_FILTER_TYPES and assume that we might
12281 throw an exception which doesn't match. */
12282 return block_may_fallthru (EH_FILTER_FAILURE (tsi_stmt (i
)));
12285 /* This case represents statements to be executed when an
12286 exception occurs. Those statements are implicitly followed
12287 by a RESX statement to resume execution after the exception.
12288 So in this case the TRY_CATCH never falls through. */
12293 /* Try to determine if we can fall out of the bottom of BLOCK. This guess
12294 need not be 100% accurate; simply be conservative and return true if we
12295 don't know. This is used only to avoid stupidly generating extra code.
12296 If we're wrong, we'll just delete the extra code later. */
12299 block_may_fallthru (const_tree block
)
12301 /* This CONST_CAST is okay because expr_last returns its argument
12302 unmodified and we assign it to a const_tree. */
12303 const_tree stmt
= expr_last (CONST_CAST_TREE (block
));
12305 switch (stmt
? TREE_CODE (stmt
) : ERROR_MARK
)
12309 /* Easy cases. If the last statement of the block implies
12310 control transfer, then we can't fall through. */
12314 /* If SWITCH_LABELS is set, this is lowered, and represents a
12315 branch to a selected label and hence can not fall through.
12316 Otherwise SWITCH_BODY is set, and the switch can fall
12318 return SWITCH_LABELS (stmt
) == NULL_TREE
;
12321 if (block_may_fallthru (COND_EXPR_THEN (stmt
)))
12323 return block_may_fallthru (COND_EXPR_ELSE (stmt
));
12326 return block_may_fallthru (BIND_EXPR_BODY (stmt
));
12328 case TRY_CATCH_EXPR
:
12329 return try_catch_may_fallthru (stmt
);
12331 case TRY_FINALLY_EXPR
:
12332 /* The finally clause is always executed after the try clause,
12333 so if it does not fall through, then the try-finally will not
12334 fall through. Otherwise, if the try clause does not fall
12335 through, then when the finally clause falls through it will
12336 resume execution wherever the try clause was going. So the
12337 whole try-finally will only fall through if both the try
12338 clause and the finally clause fall through. */
12339 return (block_may_fallthru (TREE_OPERAND (stmt
, 0))
12340 && block_may_fallthru (TREE_OPERAND (stmt
, 1)));
12343 if (TREE_CODE (TREE_OPERAND (stmt
, 1)) == CALL_EXPR
)
12344 stmt
= TREE_OPERAND (stmt
, 1);
12350 /* Functions that do not return do not fall through. */
12351 return (call_expr_flags (stmt
) & ECF_NORETURN
) == 0;
12353 case CLEANUP_POINT_EXPR
:
12354 return block_may_fallthru (TREE_OPERAND (stmt
, 0));
12357 return block_may_fallthru (TREE_OPERAND (stmt
, 1));
12363 return lang_hooks
.block_may_fallthru (stmt
);
12367 /* Garbage collection support for tree_type_common. */
12369 extern void gt_ggc_mx (tree
&);
12370 extern void gt_ggc_mx_die_struct (void *);
12372 void gt_ggc_mx (tree_type_common
*tt
)
12374 tree t
= (tree
) tt
;
12375 tree block_factor
= TYPE_UPC_BLOCK_FACTOR (t
);
12377 gt_ggc_mx (tt
->common
.typed
.type
);
12378 gt_ggc_mx (tt
->common
.chain
);
12379 gt_ggc_mx (tt
->size
);
12380 gt_ggc_mx (tt
->size_unit
);
12381 gt_ggc_mx (tt
->attributes
);
12382 gt_ggc_mx (tt
->pointer_to
);
12383 gt_ggc_mx (tt
->reference_to
);
12384 switch (debug_hooks
->tree_type_symtab_field
)
12386 case TYPE_SYMTAB_IS_ADDRESS
:
12388 case TYPE_SYMTAB_IS_POINTER
:
12389 gt_ggc_m_S (tt
->symtab
.pointer
);
12391 case TYPE_SYMTAB_IS_DIE
:
12392 gt_ggc_mx_die_struct (tt
->symtab
.die
);
12397 gt_ggc_mx (tt
->name
);
12398 gt_ggc_mx (tt
->next_variant
);
12399 gt_ggc_mx (tt
->main_variant
);
12400 gt_ggc_mx (tt
->context
);
12401 gt_ggc_mx (tt
->canonical
);
12403 if (TYPE_HAS_UPC_BLOCK_FACTOR_X (t
))
12404 gt_ggc_mx (block_factor
);
12407 /* PCH support for tree_type_common. */
12409 extern void gt_pch_nx (tree
&);
12410 extern void gt_ggc_nx_die_struct (void *);
12412 void gt_pch_nx (tree_type_common
*tt
)
12414 tree t
= (tree
) tt
;
12415 tree block_factor
= TYPE_UPC_BLOCK_FACTOR (t
);
12417 gt_pch_nx (tt
->common
.typed
.type
);
12418 gt_pch_nx (tt
->common
.chain
);
12419 gt_pch_nx (tt
->size
);
12420 gt_pch_nx (tt
->size_unit
);
12421 gt_pch_nx (tt
->attributes
);
12422 gt_pch_nx (tt
->pointer_to
);
12423 gt_pch_nx (tt
->reference_to
);
12424 switch (debug_hooks
->tree_type_symtab_field
)
12426 case TYPE_SYMTAB_IS_ADDRESS
:
12428 case TYPE_SYMTAB_IS_POINTER
:
12429 gt_pch_n_S (tt
->symtab
.pointer
);
12431 case TYPE_SYMTAB_IS_DIE
:
12432 gt_pch_nx_die_struct (tt
->symtab
.die
);
12437 gt_pch_nx (tt
->name
);
12438 gt_pch_nx (tt
->next_variant
);
12439 gt_pch_nx (tt
->main_variant
);
12440 gt_pch_nx (tt
->context
);
12441 gt_pch_nx (tt
->canonical
);
12443 if (TYPE_HAS_UPC_BLOCK_FACTOR_X (t
))
12444 gt_pch_nx (block_factor
);
12447 void gt_pch_nx (tree_type_common
*tt
, gt_pointer_operator op
, void *cookie
)
12449 tree t
= (tree
) tt
;
12450 tree block_factor
= TYPE_UPC_BLOCK_FACTOR (t
);
12452 op (&(tt
->common
.typed
.type
), cookie
);
12453 op (&(tt
->common
.chain
), cookie
);
12454 op (&(tt
->size
), cookie
);
12455 op (&(tt
->size_unit
), cookie
);
12456 op (&(tt
->attributes
), cookie
);
12457 op (&(tt
->pointer_to
), cookie
);
12458 op (&(tt
->reference_to
), cookie
);
12459 switch (debug_hooks
->tree_type_symtab_field
)
12461 case TYPE_SYMTAB_IS_ADDRESS
:
12463 case TYPE_SYMTAB_IS_POINTER
:
12464 op (&(tt
->symtab
.pointer
), cookie
);
12466 case TYPE_SYMTAB_IS_DIE
:
12467 op (&(tt
->symtab
.die
), cookie
);
12472 op (&(tt
->name
), cookie
);
12473 op (&(tt
->next_variant
), cookie
);
12474 op (&(tt
->main_variant
), cookie
);
12475 op (&(tt
->context
), cookie
);
12476 op (&(tt
->canonical
), cookie
);
12478 if (TYPE_HAS_UPC_BLOCK_FACTOR_X (t
))
12479 op (&(block_factor
), cookie
);
12482 /* True if we are using EH to handle cleanups. */
12483 static bool using_eh_for_cleanups_flag
= false;
12485 /* This routine is called from front ends to indicate eh should be used for
12488 using_eh_for_cleanups (void)
12490 using_eh_for_cleanups_flag
= true;
12493 /* Query whether EH is used for cleanups. */
12495 using_eh_for_cleanups_p (void)
12497 return using_eh_for_cleanups_flag
;
12500 /* Wrapper for tree_code_name to ensure that tree code is valid */
12502 get_tree_code_name (enum tree_code code
)
12504 const char *invalid
= "<invalid tree code>";
12506 if (code
>= MAX_TREE_CODES
)
12509 return tree_code_name
[code
];
12512 /* Drops the TREE_OVERFLOW flag from T. */
12515 drop_tree_overflow (tree t
)
12517 gcc_checking_assert (TREE_OVERFLOW (t
));
12519 /* For tree codes with a sharing machinery re-build the result. */
12520 if (TREE_CODE (t
) == INTEGER_CST
)
12521 return build_int_cst_wide (TREE_TYPE (t
),
12522 TREE_INT_CST_LOW (t
), TREE_INT_CST_HIGH (t
));
12524 /* Otherwise, as all tcc_constants are possibly shared, copy the node
12525 and drop the flag. */
12527 TREE_OVERFLOW (t
) = 0;
12531 /* Given a memory reference expression T, return its base address.
12532 The base address of a memory reference expression is the main
12533 object being referenced. For instance, the base address for
12534 'array[i].fld[j]' is 'array'. You can think of this as stripping
12535 away the offset part from a memory address.
12537 This function calls handled_component_p to strip away all the inner
12538 parts of the memory reference until it reaches the base object. */
12541 get_base_address (tree t
)
12543 while (handled_component_p (t
))
12544 t
= TREE_OPERAND (t
, 0);
12546 if ((TREE_CODE (t
) == MEM_REF
12547 || TREE_CODE (t
) == TARGET_MEM_REF
)
12548 && TREE_CODE (TREE_OPERAND (t
, 0)) == ADDR_EXPR
)
12549 t
= TREE_OPERAND (TREE_OPERAND (t
, 0), 0);
12551 /* ??? Either the alias oracle or all callers need to properly deal
12552 with WITH_SIZE_EXPRs before we can look through those. */
12553 if (TREE_CODE (t
) == WITH_SIZE_EXPR
)
12559 #include "gt-tree.h"