1 /* Language-independent node constructors for parse phase of GNU compiler.
2 Copyright (C) 1987-2017 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 can occasionally
28 calls language-dependent routines. */
32 #include "coretypes.h"
37 #include "tree-pass.h"
40 #include "diagnostic.h"
43 #include "fold-const.h"
44 #include "stor-layout.h"
47 #include "toplev.h" /* get_random_seed */
49 #include "common/common-target.h"
50 #include "langhooks.h"
51 #include "tree-inline.h"
52 #include "tree-iterator.h"
53 #include "internal-fn.h"
54 #include "gimple-iterator.h"
58 #include "langhooks-def.h"
59 #include "tree-diagnostic.h"
62 #include "print-tree.h"
63 #include "ipa-utils.h"
65 #include "stringpool.h"
70 /* Tree code classes. */
72 #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) TYPE,
73 #define END_OF_BASE_TREE_CODES tcc_exceptional,
75 const enum tree_code_class tree_code_type
[] = {
76 #include "all-tree.def"
80 #undef END_OF_BASE_TREE_CODES
82 /* Table indexed by tree code giving number of expression
83 operands beyond the fixed part of the node structure.
84 Not used for types or decls. */
86 #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) LENGTH,
87 #define END_OF_BASE_TREE_CODES 0,
89 const unsigned char tree_code_length
[] = {
90 #include "all-tree.def"
94 #undef END_OF_BASE_TREE_CODES
96 /* Names of tree components.
97 Used for printing out the tree and error messages. */
98 #define DEFTREECODE(SYM, NAME, TYPE, LEN) NAME,
99 #define END_OF_BASE_TREE_CODES "@dummy",
101 static const char *const tree_code_name
[] = {
102 #include "all-tree.def"
106 #undef END_OF_BASE_TREE_CODES
108 /* Each tree code class has an associated string representation.
109 These must correspond to the tree_code_class entries. */
111 const char *const tree_code_class_strings
[] =
126 /* obstack.[ch] explicitly declined to prototype this. */
127 extern int _obstack_allocated_p (struct obstack
*h
, void *obj
);
129 /* Statistics-gathering stuff. */
131 static int tree_code_counts
[MAX_TREE_CODES
];
132 int tree_node_counts
[(int) all_kinds
];
133 int tree_node_sizes
[(int) all_kinds
];
135 /* Keep in sync with tree.h:enum tree_node_kind. */
136 static const char * const tree_node_kind_names
[] = {
155 /* Unique id for next decl created. */
156 static GTY(()) int next_decl_uid
;
157 /* Unique id for next type created. */
158 static GTY(()) unsigned next_type_uid
= 1;
159 /* Unique id for next debug decl created. Use negative numbers,
160 to catch erroneous uses. */
161 static GTY(()) int next_debug_decl_uid
;
163 /* Since we cannot rehash a type after it is in the table, we have to
164 keep the hash code. */
166 struct GTY((for_user
)) type_hash
{
171 /* Initial size of the hash table (rounded to next prime). */
172 #define TYPE_HASH_INITIAL_SIZE 1000
174 struct type_cache_hasher
: ggc_cache_ptr_hash
<type_hash
>
176 static hashval_t
hash (type_hash
*t
) { return t
->hash
; }
177 static bool equal (type_hash
*a
, type_hash
*b
);
180 keep_cache_entry (type_hash
*&t
)
182 return ggc_marked_p (t
->type
);
186 /* Now here is the hash table. When recording a type, it is added to
187 the slot whose index is the hash code. Note that the hash table is
188 used for several kinds of types (function types, array types and
189 array index range types, for now). While all these live in the
190 same table, they are completely independent, and the hash code is
191 computed differently for each of these. */
193 static GTY ((cache
)) hash_table
<type_cache_hasher
> *type_hash_table
;
195 /* Hash table and temporary node for larger integer const values. */
196 static GTY (()) tree int_cst_node
;
198 struct int_cst_hasher
: ggc_cache_ptr_hash
<tree_node
>
200 static hashval_t
hash (tree t
);
201 static bool equal (tree x
, tree y
);
204 static GTY ((cache
)) hash_table
<int_cst_hasher
> *int_cst_hash_table
;
206 /* Hash table for optimization flags and target option flags. Use the same
207 hash table for both sets of options. Nodes for building the current
208 optimization and target option nodes. The assumption is most of the time
209 the options created will already be in the hash table, so we avoid
210 allocating and freeing up a node repeatably. */
211 static GTY (()) tree cl_optimization_node
;
212 static GTY (()) tree cl_target_option_node
;
214 struct cl_option_hasher
: ggc_cache_ptr_hash
<tree_node
>
216 static hashval_t
hash (tree t
);
217 static bool equal (tree x
, tree y
);
220 static GTY ((cache
)) hash_table
<cl_option_hasher
> *cl_option_hash_table
;
222 /* General tree->tree mapping structure for use in hash tables. */
226 hash_table
<tree_decl_map_cache_hasher
> *debug_expr_for_decl
;
229 hash_table
<tree_decl_map_cache_hasher
> *value_expr_for_decl
;
231 struct tree_vec_map_cache_hasher
: ggc_cache_ptr_hash
<tree_vec_map
>
233 static hashval_t
hash (tree_vec_map
*m
) { return DECL_UID (m
->base
.from
); }
236 equal (tree_vec_map
*a
, tree_vec_map
*b
)
238 return a
->base
.from
== b
->base
.from
;
242 keep_cache_entry (tree_vec_map
*&m
)
244 return ggc_marked_p (m
->base
.from
);
249 hash_table
<tree_vec_map_cache_hasher
> *debug_args_for_decl
;
251 static void set_type_quals (tree
, int);
252 static void print_type_hash_statistics (void);
253 static void print_debug_expr_statistics (void);
254 static void print_value_expr_statistics (void);
256 tree global_trees
[TI_MAX
];
257 tree integer_types
[itk_none
];
259 bool int_n_enabled_p
[NUM_INT_N_ENTS
];
260 struct int_n_trees_t int_n_trees
[NUM_INT_N_ENTS
];
262 bool tree_contains_struct
[MAX_TREE_CODES
][64];
264 /* Number of operands for each OpenMP clause. */
265 unsigned const char omp_clause_num_ops
[] =
267 0, /* OMP_CLAUSE_ERROR */
268 1, /* OMP_CLAUSE_PRIVATE */
269 1, /* OMP_CLAUSE_SHARED */
270 1, /* OMP_CLAUSE_FIRSTPRIVATE */
271 2, /* OMP_CLAUSE_LASTPRIVATE */
272 5, /* OMP_CLAUSE_REDUCTION */
273 1, /* OMP_CLAUSE_COPYIN */
274 1, /* OMP_CLAUSE_COPYPRIVATE */
275 3, /* OMP_CLAUSE_LINEAR */
276 2, /* OMP_CLAUSE_ALIGNED */
277 1, /* OMP_CLAUSE_DEPEND */
278 1, /* OMP_CLAUSE_UNIFORM */
279 1, /* OMP_CLAUSE_TO_DECLARE */
280 1, /* OMP_CLAUSE_LINK */
281 2, /* OMP_CLAUSE_FROM */
282 2, /* OMP_CLAUSE_TO */
283 2, /* OMP_CLAUSE_MAP */
284 1, /* OMP_CLAUSE_USE_DEVICE_PTR */
285 1, /* OMP_CLAUSE_IS_DEVICE_PTR */
286 2, /* OMP_CLAUSE__CACHE_ */
287 2, /* OMP_CLAUSE_GANG */
288 1, /* OMP_CLAUSE_ASYNC */
289 1, /* OMP_CLAUSE_WAIT */
290 0, /* OMP_CLAUSE_AUTO */
291 0, /* OMP_CLAUSE_SEQ */
292 1, /* OMP_CLAUSE__LOOPTEMP_ */
293 1, /* OMP_CLAUSE_IF */
294 1, /* OMP_CLAUSE_NUM_THREADS */
295 1, /* OMP_CLAUSE_SCHEDULE */
296 0, /* OMP_CLAUSE_NOWAIT */
297 1, /* OMP_CLAUSE_ORDERED */
298 0, /* OMP_CLAUSE_DEFAULT */
299 3, /* OMP_CLAUSE_COLLAPSE */
300 0, /* OMP_CLAUSE_UNTIED */
301 1, /* OMP_CLAUSE_FINAL */
302 0, /* OMP_CLAUSE_MERGEABLE */
303 1, /* OMP_CLAUSE_DEVICE */
304 1, /* OMP_CLAUSE_DIST_SCHEDULE */
305 0, /* OMP_CLAUSE_INBRANCH */
306 0, /* OMP_CLAUSE_NOTINBRANCH */
307 1, /* OMP_CLAUSE_NUM_TEAMS */
308 1, /* OMP_CLAUSE_THREAD_LIMIT */
309 0, /* OMP_CLAUSE_PROC_BIND */
310 1, /* OMP_CLAUSE_SAFELEN */
311 1, /* OMP_CLAUSE_SIMDLEN */
312 0, /* OMP_CLAUSE_FOR */
313 0, /* OMP_CLAUSE_PARALLEL */
314 0, /* OMP_CLAUSE_SECTIONS */
315 0, /* OMP_CLAUSE_TASKGROUP */
316 1, /* OMP_CLAUSE_PRIORITY */
317 1, /* OMP_CLAUSE_GRAINSIZE */
318 1, /* OMP_CLAUSE_NUM_TASKS */
319 0, /* OMP_CLAUSE_NOGROUP */
320 0, /* OMP_CLAUSE_THREADS */
321 0, /* OMP_CLAUSE_SIMD */
322 1, /* OMP_CLAUSE_HINT */
323 0, /* OMP_CLAUSE_DEFALTMAP */
324 1, /* OMP_CLAUSE__SIMDUID_ */
325 0, /* OMP_CLAUSE__SIMT_ */
326 0, /* OMP_CLAUSE_INDEPENDENT */
327 1, /* OMP_CLAUSE_WORKER */
328 1, /* OMP_CLAUSE_VECTOR */
329 1, /* OMP_CLAUSE_NUM_GANGS */
330 1, /* OMP_CLAUSE_NUM_WORKERS */
331 1, /* OMP_CLAUSE_VECTOR_LENGTH */
332 3, /* OMP_CLAUSE_TILE */
333 2, /* OMP_CLAUSE__GRIDDIM_ */
336 const char * const omp_clause_code_name
[] =
408 /* Return the tree node structure used by tree code CODE. */
410 static inline enum tree_node_structure_enum
411 tree_node_structure_for_code (enum tree_code code
)
413 switch (TREE_CODE_CLASS (code
))
415 case tcc_declaration
:
420 return TS_FIELD_DECL
;
426 return TS_LABEL_DECL
;
428 return TS_RESULT_DECL
;
429 case DEBUG_EXPR_DECL
:
432 return TS_CONST_DECL
;
436 return TS_FUNCTION_DECL
;
437 case TRANSLATION_UNIT_DECL
:
438 return TS_TRANSLATION_UNIT_DECL
;
440 return TS_DECL_NON_COMMON
;
444 return TS_TYPE_NON_COMMON
;
453 default: /* tcc_constant and tcc_exceptional */
458 /* tcc_constant cases. */
459 case VOID_CST
: return TS_TYPED
;
460 case INTEGER_CST
: return TS_INT_CST
;
461 case REAL_CST
: return TS_REAL_CST
;
462 case FIXED_CST
: return TS_FIXED_CST
;
463 case COMPLEX_CST
: return TS_COMPLEX
;
464 case VECTOR_CST
: return TS_VECTOR
;
465 case STRING_CST
: return TS_STRING
;
466 /* tcc_exceptional cases. */
467 case ERROR_MARK
: return TS_COMMON
;
468 case IDENTIFIER_NODE
: return TS_IDENTIFIER
;
469 case TREE_LIST
: return TS_LIST
;
470 case TREE_VEC
: return TS_VEC
;
471 case SSA_NAME
: return TS_SSA_NAME
;
472 case PLACEHOLDER_EXPR
: return TS_COMMON
;
473 case STATEMENT_LIST
: return TS_STATEMENT_LIST
;
474 case BLOCK
: return TS_BLOCK
;
475 case CONSTRUCTOR
: return TS_CONSTRUCTOR
;
476 case TREE_BINFO
: return TS_BINFO
;
477 case OMP_CLAUSE
: return TS_OMP_CLAUSE
;
478 case OPTIMIZATION_NODE
: return TS_OPTIMIZATION
;
479 case TARGET_OPTION_NODE
: return TS_TARGET_OPTION
;
487 /* Initialize tree_contains_struct to describe the hierarchy of tree
491 initialize_tree_contains_struct (void)
495 for (i
= ERROR_MARK
; i
< LAST_AND_UNUSED_TREE_CODE
; i
++)
498 enum tree_node_structure_enum ts_code
;
500 code
= (enum tree_code
) i
;
501 ts_code
= tree_node_structure_for_code (code
);
503 /* Mark the TS structure itself. */
504 tree_contains_struct
[code
][ts_code
] = 1;
506 /* Mark all the structures that TS is derived from. */
511 case TS_OPTIMIZATION
:
512 case TS_TARGET_OPTION
:
526 case TS_STATEMENT_LIST
:
527 MARK_TS_TYPED (code
);
531 case TS_DECL_MINIMAL
:
537 MARK_TS_COMMON (code
);
540 case TS_TYPE_WITH_LANG_SPECIFIC
:
541 MARK_TS_TYPE_COMMON (code
);
544 case TS_TYPE_NON_COMMON
:
545 MARK_TS_TYPE_WITH_LANG_SPECIFIC (code
);
549 MARK_TS_DECL_MINIMAL (code
);
554 MARK_TS_DECL_COMMON (code
);
557 case TS_DECL_NON_COMMON
:
558 MARK_TS_DECL_WITH_VIS (code
);
561 case TS_DECL_WITH_VIS
:
565 MARK_TS_DECL_WRTL (code
);
569 MARK_TS_DECL_COMMON (code
);
573 MARK_TS_DECL_WITH_VIS (code
);
577 case TS_FUNCTION_DECL
:
578 MARK_TS_DECL_NON_COMMON (code
);
581 case TS_TRANSLATION_UNIT_DECL
:
582 MARK_TS_DECL_COMMON (code
);
590 /* Basic consistency checks for attributes used in fold. */
591 gcc_assert (tree_contains_struct
[FUNCTION_DECL
][TS_DECL_NON_COMMON
]);
592 gcc_assert (tree_contains_struct
[TYPE_DECL
][TS_DECL_NON_COMMON
]);
593 gcc_assert (tree_contains_struct
[CONST_DECL
][TS_DECL_COMMON
]);
594 gcc_assert (tree_contains_struct
[VAR_DECL
][TS_DECL_COMMON
]);
595 gcc_assert (tree_contains_struct
[PARM_DECL
][TS_DECL_COMMON
]);
596 gcc_assert (tree_contains_struct
[RESULT_DECL
][TS_DECL_COMMON
]);
597 gcc_assert (tree_contains_struct
[FUNCTION_DECL
][TS_DECL_COMMON
]);
598 gcc_assert (tree_contains_struct
[TYPE_DECL
][TS_DECL_COMMON
]);
599 gcc_assert (tree_contains_struct
[TRANSLATION_UNIT_DECL
][TS_DECL_COMMON
]);
600 gcc_assert (tree_contains_struct
[LABEL_DECL
][TS_DECL_COMMON
]);
601 gcc_assert (tree_contains_struct
[FIELD_DECL
][TS_DECL_COMMON
]);
602 gcc_assert (tree_contains_struct
[VAR_DECL
][TS_DECL_WRTL
]);
603 gcc_assert (tree_contains_struct
[PARM_DECL
][TS_DECL_WRTL
]);
604 gcc_assert (tree_contains_struct
[RESULT_DECL
][TS_DECL_WRTL
]);
605 gcc_assert (tree_contains_struct
[FUNCTION_DECL
][TS_DECL_WRTL
]);
606 gcc_assert (tree_contains_struct
[LABEL_DECL
][TS_DECL_WRTL
]);
607 gcc_assert (tree_contains_struct
[CONST_DECL
][TS_DECL_MINIMAL
]);
608 gcc_assert (tree_contains_struct
[VAR_DECL
][TS_DECL_MINIMAL
]);
609 gcc_assert (tree_contains_struct
[PARM_DECL
][TS_DECL_MINIMAL
]);
610 gcc_assert (tree_contains_struct
[RESULT_DECL
][TS_DECL_MINIMAL
]);
611 gcc_assert (tree_contains_struct
[FUNCTION_DECL
][TS_DECL_MINIMAL
]);
612 gcc_assert (tree_contains_struct
[TYPE_DECL
][TS_DECL_MINIMAL
]);
613 gcc_assert (tree_contains_struct
[TRANSLATION_UNIT_DECL
][TS_DECL_MINIMAL
]);
614 gcc_assert (tree_contains_struct
[LABEL_DECL
][TS_DECL_MINIMAL
]);
615 gcc_assert (tree_contains_struct
[FIELD_DECL
][TS_DECL_MINIMAL
]);
616 gcc_assert (tree_contains_struct
[VAR_DECL
][TS_DECL_WITH_VIS
]);
617 gcc_assert (tree_contains_struct
[FUNCTION_DECL
][TS_DECL_WITH_VIS
]);
618 gcc_assert (tree_contains_struct
[TYPE_DECL
][TS_DECL_WITH_VIS
]);
619 gcc_assert (tree_contains_struct
[VAR_DECL
][TS_VAR_DECL
]);
620 gcc_assert (tree_contains_struct
[FIELD_DECL
][TS_FIELD_DECL
]);
621 gcc_assert (tree_contains_struct
[PARM_DECL
][TS_PARM_DECL
]);
622 gcc_assert (tree_contains_struct
[LABEL_DECL
][TS_LABEL_DECL
]);
623 gcc_assert (tree_contains_struct
[RESULT_DECL
][TS_RESULT_DECL
]);
624 gcc_assert (tree_contains_struct
[CONST_DECL
][TS_CONST_DECL
]);
625 gcc_assert (tree_contains_struct
[TYPE_DECL
][TS_TYPE_DECL
]);
626 gcc_assert (tree_contains_struct
[FUNCTION_DECL
][TS_FUNCTION_DECL
]);
627 gcc_assert (tree_contains_struct
[IMPORTED_DECL
][TS_DECL_MINIMAL
]);
628 gcc_assert (tree_contains_struct
[IMPORTED_DECL
][TS_DECL_COMMON
]);
629 gcc_assert (tree_contains_struct
[NAMELIST_DECL
][TS_DECL_MINIMAL
]);
630 gcc_assert (tree_contains_struct
[NAMELIST_DECL
][TS_DECL_COMMON
]);
639 /* Initialize the hash table of types. */
641 = hash_table
<type_cache_hasher
>::create_ggc (TYPE_HASH_INITIAL_SIZE
);
644 = hash_table
<tree_decl_map_cache_hasher
>::create_ggc (512);
647 = hash_table
<tree_decl_map_cache_hasher
>::create_ggc (512);
649 int_cst_hash_table
= hash_table
<int_cst_hasher
>::create_ggc (1024);
651 int_cst_node
= make_int_cst (1, 1);
653 cl_option_hash_table
= hash_table
<cl_option_hasher
>::create_ggc (64);
655 cl_optimization_node
= make_node (OPTIMIZATION_NODE
);
656 cl_target_option_node
= make_node (TARGET_OPTION_NODE
);
658 /* Initialize the tree_contains_struct array. */
659 initialize_tree_contains_struct ();
660 lang_hooks
.init_ts ();
664 /* The name of the object as the assembler will see it (but before any
665 translations made by ASM_OUTPUT_LABELREF). Often this is the same
666 as DECL_NAME. It is an IDENTIFIER_NODE. */
668 decl_assembler_name (tree decl
)
670 if (!DECL_ASSEMBLER_NAME_SET_P (decl
))
671 lang_hooks
.set_decl_assembler_name (decl
);
672 return DECL_ASSEMBLER_NAME_RAW (decl
);
675 /* The DECL_ASSEMBLER_NAME_RAW of DECL is being explicitly set to NAME
676 (either of which may be NULL). Inform the FE, if this changes the
680 overwrite_decl_assembler_name (tree decl
, tree name
)
682 if (DECL_ASSEMBLER_NAME_RAW (decl
) != name
)
683 lang_hooks
.overwrite_decl_assembler_name (decl
, name
);
686 /* When the target supports COMDAT groups, this indicates which group the
687 DECL is associated with. This can be either an IDENTIFIER_NODE or a
688 decl, in which case its DECL_ASSEMBLER_NAME identifies the group. */
690 decl_comdat_group (const_tree node
)
692 struct symtab_node
*snode
= symtab_node::get (node
);
695 return snode
->get_comdat_group ();
698 /* Likewise, but make sure it's been reduced to an IDENTIFIER_NODE. */
700 decl_comdat_group_id (const_tree node
)
702 struct symtab_node
*snode
= symtab_node::get (node
);
705 return snode
->get_comdat_group_id ();
708 /* When the target supports named section, return its name as IDENTIFIER_NODE
709 or NULL if it is in no section. */
711 decl_section_name (const_tree node
)
713 struct symtab_node
*snode
= symtab_node::get (node
);
716 return snode
->get_section ();
719 /* Set section name of NODE to VALUE (that is expected to be
722 set_decl_section_name (tree node
, const char *value
)
724 struct symtab_node
*snode
;
728 snode
= symtab_node::get (node
);
732 else if (VAR_P (node
))
733 snode
= varpool_node::get_create (node
);
735 snode
= cgraph_node::get_create (node
);
736 snode
->set_section (value
);
739 /* Return TLS model of a variable NODE. */
741 decl_tls_model (const_tree node
)
743 struct varpool_node
*snode
= varpool_node::get (node
);
745 return TLS_MODEL_NONE
;
746 return snode
->tls_model
;
749 /* Set TLS model of variable NODE to MODEL. */
751 set_decl_tls_model (tree node
, enum tls_model model
)
753 struct varpool_node
*vnode
;
755 if (model
== TLS_MODEL_NONE
)
757 vnode
= varpool_node::get (node
);
762 vnode
= varpool_node::get_create (node
);
763 vnode
->tls_model
= model
;
766 /* Compute the number of bytes occupied by a tree with code CODE.
767 This function cannot be used for nodes that have variable sizes,
768 including TREE_VEC, INTEGER_CST, STRING_CST, and CALL_EXPR. */
770 tree_code_size (enum tree_code code
)
772 switch (TREE_CODE_CLASS (code
))
774 case tcc_declaration
: /* A decl node */
777 case FIELD_DECL
: return sizeof (tree_field_decl
);
778 case PARM_DECL
: return sizeof (tree_parm_decl
);
779 case VAR_DECL
: return sizeof (tree_var_decl
);
780 case LABEL_DECL
: return sizeof (tree_label_decl
);
781 case RESULT_DECL
: return sizeof (tree_result_decl
);
782 case CONST_DECL
: return sizeof (tree_const_decl
);
783 case TYPE_DECL
: return sizeof (tree_type_decl
);
784 case FUNCTION_DECL
: return sizeof (tree_function_decl
);
785 case DEBUG_EXPR_DECL
: return sizeof (tree_decl_with_rtl
);
786 case TRANSLATION_UNIT_DECL
: return sizeof (tree_translation_unit_decl
);
789 case NAMELIST_DECL
: return sizeof (tree_decl_non_common
);
791 gcc_checking_assert (code
>= NUM_TREE_CODES
);
792 return lang_hooks
.tree_size (code
);
795 case tcc_type
: /* a type node */
806 case FIXED_POINT_TYPE
:
812 case QUAL_UNION_TYPE
:
814 case POINTER_BOUNDS_TYPE
:
817 case LANG_TYPE
: return sizeof (tree_type_non_common
);
819 gcc_checking_assert (code
>= NUM_TREE_CODES
);
820 return lang_hooks
.tree_size (code
);
823 case tcc_reference
: /* a reference */
824 case tcc_expression
: /* an expression */
825 case tcc_statement
: /* an expression with side effects */
826 case tcc_comparison
: /* a comparison expression */
827 case tcc_unary
: /* a unary arithmetic expression */
828 case tcc_binary
: /* a binary arithmetic expression */
829 return (sizeof (struct tree_exp
)
830 + (TREE_CODE_LENGTH (code
) - 1) * sizeof (tree
));
832 case tcc_constant
: /* a constant */
835 case VOID_CST
: return sizeof (tree_typed
);
836 case INTEGER_CST
: gcc_unreachable ();
837 case REAL_CST
: return sizeof (tree_real_cst
);
838 case FIXED_CST
: return sizeof (tree_fixed_cst
);
839 case COMPLEX_CST
: return sizeof (tree_complex
);
840 case VECTOR_CST
: return sizeof (tree_vector
);
841 case STRING_CST
: gcc_unreachable ();
843 gcc_checking_assert (code
>= NUM_TREE_CODES
);
844 return lang_hooks
.tree_size (code
);
847 case tcc_exceptional
: /* something random, like an identifier. */
850 case IDENTIFIER_NODE
: return lang_hooks
.identifier_size
;
851 case TREE_LIST
: return sizeof (tree_list
);
854 case PLACEHOLDER_EXPR
: return sizeof (tree_common
);
856 case TREE_VEC
: gcc_unreachable ();
857 case OMP_CLAUSE
: gcc_unreachable ();
859 case SSA_NAME
: return sizeof (tree_ssa_name
);
861 case STATEMENT_LIST
: return sizeof (tree_statement_list
);
862 case BLOCK
: return sizeof (struct tree_block
);
863 case CONSTRUCTOR
: return sizeof (tree_constructor
);
864 case OPTIMIZATION_NODE
: return sizeof (tree_optimization_option
);
865 case TARGET_OPTION_NODE
: return sizeof (tree_target_option
);
868 gcc_checking_assert (code
>= NUM_TREE_CODES
);
869 return lang_hooks
.tree_size (code
);
877 /* Compute the number of bytes occupied by NODE. This routine only
878 looks at TREE_CODE, except for those nodes that have variable sizes. */
880 tree_size (const_tree node
)
882 const enum tree_code code
= TREE_CODE (node
);
886 return (sizeof (struct tree_int_cst
)
887 + (TREE_INT_CST_EXT_NUNITS (node
) - 1) * sizeof (HOST_WIDE_INT
));
890 return (offsetof (struct tree_binfo
, base_binfos
)
892 ::embedded_size (BINFO_N_BASE_BINFOS (node
)));
895 return (sizeof (struct tree_vec
)
896 + (TREE_VEC_LENGTH (node
) - 1) * sizeof (tree
));
899 return (sizeof (struct tree_vector
)
900 + (VECTOR_CST_NELTS (node
) - 1) * sizeof (tree
));
903 return TREE_STRING_LENGTH (node
) + offsetof (struct tree_string
, str
) + 1;
906 return (sizeof (struct tree_omp_clause
)
907 + (omp_clause_num_ops
[OMP_CLAUSE_CODE (node
)] - 1)
911 if (TREE_CODE_CLASS (code
) == tcc_vl_exp
)
912 return (sizeof (struct tree_exp
)
913 + (VL_EXP_OPERAND_LENGTH (node
) - 1) * sizeof (tree
));
915 return tree_code_size (code
);
919 /* Record interesting allocation statistics for a tree node with CODE
923 record_node_allocation_statistics (enum tree_code code ATTRIBUTE_UNUSED
,
924 size_t length ATTRIBUTE_UNUSED
)
926 enum tree_code_class type
= TREE_CODE_CLASS (code
);
929 if (!GATHER_STATISTICS
)
934 case tcc_declaration
: /* A decl node */
938 case tcc_type
: /* a type node */
942 case tcc_statement
: /* an expression with side effects */
946 case tcc_reference
: /* a reference */
950 case tcc_expression
: /* an expression */
951 case tcc_comparison
: /* a comparison expression */
952 case tcc_unary
: /* a unary arithmetic expression */
953 case tcc_binary
: /* a binary arithmetic expression */
957 case tcc_constant
: /* a constant */
961 case tcc_exceptional
: /* something random, like an identifier. */
964 case IDENTIFIER_NODE
:
977 kind
= ssa_name_kind
;
989 kind
= omp_clause_kind
;
1006 tree_code_counts
[(int) code
]++;
1007 tree_node_counts
[(int) kind
]++;
1008 tree_node_sizes
[(int) kind
] += length
;
1011 /* Allocate and return a new UID from the DECL_UID namespace. */
1014 allocate_decl_uid (void)
1016 return next_decl_uid
++;
1019 /* Return a newly allocated node of code CODE. For decl and type
1020 nodes, some other fields are initialized. The rest of the node is
1021 initialized to zero. This function cannot be used for TREE_VEC,
1022 INTEGER_CST or OMP_CLAUSE nodes, which is enforced by asserts in
1025 Achoo! I got a code in the node. */
1028 make_node (enum tree_code code MEM_STAT_DECL
)
1031 enum tree_code_class type
= TREE_CODE_CLASS (code
);
1032 size_t length
= tree_code_size (code
);
1034 record_node_allocation_statistics (code
, length
);
1036 t
= ggc_alloc_cleared_tree_node_stat (length PASS_MEM_STAT
);
1037 TREE_SET_CODE (t
, code
);
1042 TREE_SIDE_EFFECTS (t
) = 1;
1045 case tcc_declaration
:
1046 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_COMMON
))
1048 if (code
== FUNCTION_DECL
)
1050 SET_DECL_ALIGN (t
, FUNCTION_ALIGNMENT (FUNCTION_BOUNDARY
));
1051 SET_DECL_MODE (t
, FUNCTION_MODE
);
1054 SET_DECL_ALIGN (t
, 1);
1056 DECL_SOURCE_LOCATION (t
) = input_location
;
1057 if (TREE_CODE (t
) == DEBUG_EXPR_DECL
)
1058 DECL_UID (t
) = --next_debug_decl_uid
;
1061 DECL_UID (t
) = allocate_decl_uid ();
1062 SET_DECL_PT_UID (t
, -1);
1064 if (TREE_CODE (t
) == LABEL_DECL
)
1065 LABEL_DECL_UID (t
) = -1;
1070 TYPE_UID (t
) = next_type_uid
++;
1071 SET_TYPE_ALIGN (t
, BITS_PER_UNIT
);
1072 TYPE_USER_ALIGN (t
) = 0;
1073 TYPE_MAIN_VARIANT (t
) = t
;
1074 TYPE_CANONICAL (t
) = t
;
1076 /* Default to no attributes for type, but let target change that. */
1077 TYPE_ATTRIBUTES (t
) = NULL_TREE
;
1078 targetm
.set_default_type_attributes (t
);
1080 /* We have not yet computed the alias set for this type. */
1081 TYPE_ALIAS_SET (t
) = -1;
1085 TREE_CONSTANT (t
) = 1;
1088 case tcc_expression
:
1094 case PREDECREMENT_EXPR
:
1095 case PREINCREMENT_EXPR
:
1096 case POSTDECREMENT_EXPR
:
1097 case POSTINCREMENT_EXPR
:
1098 /* All of these have side-effects, no matter what their
1100 TREE_SIDE_EFFECTS (t
) = 1;
1108 case tcc_exceptional
:
1111 case TARGET_OPTION_NODE
:
1112 TREE_TARGET_OPTION(t
)
1113 = ggc_cleared_alloc
<struct cl_target_option
> ();
1116 case OPTIMIZATION_NODE
:
1117 TREE_OPTIMIZATION (t
)
1118 = ggc_cleared_alloc
<struct cl_optimization
> ();
1127 /* Other classes need no special treatment. */
1134 /* Free tree node. */
1137 free_node (tree node
)
1139 enum tree_code code
= TREE_CODE (node
);
1140 if (GATHER_STATISTICS
)
1142 tree_code_counts
[(int) TREE_CODE (node
)]--;
1143 tree_node_counts
[(int) t_kind
]--;
1144 tree_node_sizes
[(int) t_kind
] -= tree_size (node
);
1146 if (CODE_CONTAINS_STRUCT (code
, TS_CONSTRUCTOR
))
1147 vec_free (CONSTRUCTOR_ELTS (node
));
1148 else if (code
== BLOCK
)
1149 vec_free (BLOCK_NONLOCALIZED_VARS (node
));
1150 else if (code
== TREE_BINFO
)
1151 vec_free (BINFO_BASE_ACCESSES (node
));
1155 /* Return a new node with the same contents as NODE except that its
1156 TREE_CHAIN, if it has one, is zero and it has a fresh uid. */
1159 copy_node (tree node MEM_STAT_DECL
)
1162 enum tree_code code
= TREE_CODE (node
);
1165 gcc_assert (code
!= STATEMENT_LIST
);
1167 length
= tree_size (node
);
1168 record_node_allocation_statistics (code
, length
);
1169 t
= ggc_alloc_tree_node_stat (length PASS_MEM_STAT
);
1170 memcpy (t
, node
, length
);
1172 if (CODE_CONTAINS_STRUCT (code
, TS_COMMON
))
1174 TREE_ASM_WRITTEN (t
) = 0;
1175 TREE_VISITED (t
) = 0;
1177 if (TREE_CODE_CLASS (code
) == tcc_declaration
)
1179 if (code
== DEBUG_EXPR_DECL
)
1180 DECL_UID (t
) = --next_debug_decl_uid
;
1183 DECL_UID (t
) = allocate_decl_uid ();
1184 if (DECL_PT_UID_SET_P (node
))
1185 SET_DECL_PT_UID (t
, DECL_PT_UID (node
));
1187 if ((TREE_CODE (node
) == PARM_DECL
|| VAR_P (node
))
1188 && DECL_HAS_VALUE_EXPR_P (node
))
1190 SET_DECL_VALUE_EXPR (t
, DECL_VALUE_EXPR (node
));
1191 DECL_HAS_VALUE_EXPR_P (t
) = 1;
1193 /* DECL_DEBUG_EXPR is copied explicitely by callers. */
1196 DECL_HAS_DEBUG_EXPR_P (t
) = 0;
1197 t
->decl_with_vis
.symtab_node
= NULL
;
1199 if (VAR_P (node
) && DECL_HAS_INIT_PRIORITY_P (node
))
1201 SET_DECL_INIT_PRIORITY (t
, DECL_INIT_PRIORITY (node
));
1202 DECL_HAS_INIT_PRIORITY_P (t
) = 1;
1204 if (TREE_CODE (node
) == FUNCTION_DECL
)
1206 DECL_STRUCT_FUNCTION (t
) = NULL
;
1207 t
->decl_with_vis
.symtab_node
= NULL
;
1210 else if (TREE_CODE_CLASS (code
) == tcc_type
)
1212 TYPE_UID (t
) = next_type_uid
++;
1213 /* The following is so that the debug code for
1214 the copy is different from the original type.
1215 The two statements usually duplicate each other
1216 (because they clear fields of the same union),
1217 but the optimizer should catch that. */
1218 TYPE_SYMTAB_ADDRESS (t
) = 0;
1219 TYPE_SYMTAB_DIE (t
) = 0;
1221 /* Do not copy the values cache. */
1222 if (TYPE_CACHED_VALUES_P (t
))
1224 TYPE_CACHED_VALUES_P (t
) = 0;
1225 TYPE_CACHED_VALUES (t
) = NULL_TREE
;
1228 else if (code
== TARGET_OPTION_NODE
)
1230 TREE_TARGET_OPTION (t
) = ggc_alloc
<struct cl_target_option
>();
1231 memcpy (TREE_TARGET_OPTION (t
), TREE_TARGET_OPTION (node
),
1232 sizeof (struct cl_target_option
));
1234 else if (code
== OPTIMIZATION_NODE
)
1236 TREE_OPTIMIZATION (t
) = ggc_alloc
<struct cl_optimization
>();
1237 memcpy (TREE_OPTIMIZATION (t
), TREE_OPTIMIZATION (node
),
1238 sizeof (struct cl_optimization
));
1244 /* Return a copy of a chain of nodes, chained through the TREE_CHAIN field.
1245 For example, this can copy a list made of TREE_LIST nodes. */
1248 copy_list (tree list
)
1256 head
= prev
= copy_node (list
);
1257 next
= TREE_CHAIN (list
);
1260 TREE_CHAIN (prev
) = copy_node (next
);
1261 prev
= TREE_CHAIN (prev
);
1262 next
= TREE_CHAIN (next
);
1268 /* Return the value that TREE_INT_CST_EXT_NUNITS should have for an
1269 INTEGER_CST with value CST and type TYPE. */
1272 get_int_cst_ext_nunits (tree type
, const wide_int
&cst
)
1274 gcc_checking_assert (cst
.get_precision () == TYPE_PRECISION (type
));
1275 /* We need extra HWIs if CST is an unsigned integer with its
1277 if (TYPE_UNSIGNED (type
) && wi::neg_p (cst
))
1278 return cst
.get_precision () / HOST_BITS_PER_WIDE_INT
+ 1;
1279 return cst
.get_len ();
1282 /* Return a new INTEGER_CST with value CST and type TYPE. */
1285 build_new_int_cst (tree type
, const wide_int
&cst
)
1287 unsigned int len
= cst
.get_len ();
1288 unsigned int ext_len
= get_int_cst_ext_nunits (type
, cst
);
1289 tree nt
= make_int_cst (len
, ext_len
);
1294 TREE_INT_CST_ELT (nt
, ext_len
)
1295 = zext_hwi (-1, cst
.get_precision () % HOST_BITS_PER_WIDE_INT
);
1296 for (unsigned int i
= len
; i
< ext_len
; ++i
)
1297 TREE_INT_CST_ELT (nt
, i
) = -1;
1299 else if (TYPE_UNSIGNED (type
)
1300 && cst
.get_precision () < len
* HOST_BITS_PER_WIDE_INT
)
1303 TREE_INT_CST_ELT (nt
, len
)
1304 = zext_hwi (cst
.elt (len
),
1305 cst
.get_precision () % HOST_BITS_PER_WIDE_INT
);
1308 for (unsigned int i
= 0; i
< len
; i
++)
1309 TREE_INT_CST_ELT (nt
, i
) = cst
.elt (i
);
1310 TREE_TYPE (nt
) = type
;
1314 /* Create an INT_CST node with a LOW value sign extended to TYPE. */
1317 build_int_cst (tree type
, HOST_WIDE_INT low
)
1319 /* Support legacy code. */
1321 type
= integer_type_node
;
1323 return wide_int_to_tree (type
, wi::shwi (low
, TYPE_PRECISION (type
)));
1327 build_int_cstu (tree type
, unsigned HOST_WIDE_INT cst
)
1329 return wide_int_to_tree (type
, wi::uhwi (cst
, TYPE_PRECISION (type
)));
1332 /* Create an INT_CST node with a LOW value sign extended to TYPE. */
1335 build_int_cst_type (tree type
, HOST_WIDE_INT low
)
1338 return wide_int_to_tree (type
, wi::shwi (low
, TYPE_PRECISION (type
)));
1341 /* Constructs tree in type TYPE from with value given by CST. Signedness
1342 of CST is assumed to be the same as the signedness of TYPE. */
1345 double_int_to_tree (tree type
, double_int cst
)
1347 return wide_int_to_tree (type
, widest_int::from (cst
, TYPE_SIGN (type
)));
1350 /* We force the wide_int CST to the range of the type TYPE by sign or
1351 zero extending it. OVERFLOWABLE indicates if we are interested in
1352 overflow of the value, when >0 we are only interested in signed
1353 overflow, for <0 we are interested in any overflow. OVERFLOWED
1354 indicates whether overflow has already occurred. CONST_OVERFLOWED
1355 indicates whether constant overflow has already occurred. We force
1356 T's value to be within range of T's type (by setting to 0 or 1 all
1357 the bits outside the type's range). We set TREE_OVERFLOWED if,
1358 OVERFLOWED is nonzero,
1359 or OVERFLOWABLE is >0 and signed overflow occurs
1360 or OVERFLOWABLE is <0 and any overflow occurs
1361 We return a new tree node for the extended wide_int. The node
1362 is shared if no overflow flags are set. */
1366 force_fit_type (tree type
, const wide_int_ref
&cst
,
1367 int overflowable
, bool overflowed
)
1369 signop sign
= TYPE_SIGN (type
);
1371 /* If we need to set overflow flags, return a new unshared node. */
1372 if (overflowed
|| !wi::fits_to_tree_p (cst
, type
))
1376 || (overflowable
> 0 && sign
== SIGNED
))
1378 wide_int tmp
= wide_int::from (cst
, TYPE_PRECISION (type
), sign
);
1379 tree t
= build_new_int_cst (type
, tmp
);
1380 TREE_OVERFLOW (t
) = 1;
1385 /* Else build a shared node. */
1386 return wide_int_to_tree (type
, cst
);
1389 /* These are the hash table functions for the hash table of INTEGER_CST
1390 nodes of a sizetype. */
1392 /* Return the hash code X, an INTEGER_CST. */
1395 int_cst_hasher::hash (tree x
)
1397 const_tree
const t
= x
;
1398 hashval_t code
= TYPE_UID (TREE_TYPE (t
));
1401 for (i
= 0; i
< TREE_INT_CST_NUNITS (t
); i
++)
1402 code
= iterative_hash_host_wide_int (TREE_INT_CST_ELT(t
, i
), code
);
1407 /* Return nonzero if the value represented by *X (an INTEGER_CST tree node)
1408 is the same as that given by *Y, which is the same. */
1411 int_cst_hasher::equal (tree x
, tree y
)
1413 const_tree
const xt
= x
;
1414 const_tree
const yt
= y
;
1416 if (TREE_TYPE (xt
) != TREE_TYPE (yt
)
1417 || TREE_INT_CST_NUNITS (xt
) != TREE_INT_CST_NUNITS (yt
)
1418 || TREE_INT_CST_EXT_NUNITS (xt
) != TREE_INT_CST_EXT_NUNITS (yt
))
1421 for (int i
= 0; i
< TREE_INT_CST_NUNITS (xt
); i
++)
1422 if (TREE_INT_CST_ELT (xt
, i
) != TREE_INT_CST_ELT (yt
, i
))
1428 /* Create an INT_CST node of TYPE and value CST.
1429 The returned node is always shared. For small integers we use a
1430 per-type vector cache, for larger ones we use a single hash table.
1431 The value is extended from its precision according to the sign of
1432 the type to be a multiple of HOST_BITS_PER_WIDE_INT. This defines
1433 the upper bits and ensures that hashing and value equality based
1434 upon the underlying HOST_WIDE_INTs works without masking. */
1437 wide_int_to_tree (tree type
, const wide_int_ref
&pcst
)
1444 unsigned int prec
= TYPE_PRECISION (type
);
1445 signop sgn
= TYPE_SIGN (type
);
1447 /* Verify that everything is canonical. */
1448 int l
= pcst
.get_len ();
1451 if (pcst
.elt (l
- 1) == 0)
1452 gcc_checking_assert (pcst
.elt (l
- 2) < 0);
1453 if (pcst
.elt (l
- 1) == HOST_WIDE_INT_M1
)
1454 gcc_checking_assert (pcst
.elt (l
- 2) >= 0);
1457 wide_int cst
= wide_int::from (pcst
, prec
, sgn
);
1458 unsigned int ext_len
= get_int_cst_ext_nunits (type
, cst
);
1462 /* We just need to store a single HOST_WIDE_INT. */
1464 if (TYPE_UNSIGNED (type
))
1465 hwi
= cst
.to_uhwi ();
1467 hwi
= cst
.to_shwi ();
1469 switch (TREE_CODE (type
))
1472 gcc_assert (hwi
== 0);
1476 case REFERENCE_TYPE
:
1477 case POINTER_BOUNDS_TYPE
:
1478 /* Cache NULL pointer and zero bounds. */
1487 /* Cache false or true. */
1489 if (IN_RANGE (hwi
, 0, 1))
1495 if (TYPE_SIGN (type
) == UNSIGNED
)
1498 limit
= INTEGER_SHARE_LIMIT
;
1499 if (IN_RANGE (hwi
, 0, INTEGER_SHARE_LIMIT
- 1))
1504 /* Cache [-1, N). */
1505 limit
= INTEGER_SHARE_LIMIT
+ 1;
1506 if (IN_RANGE (hwi
, -1, INTEGER_SHARE_LIMIT
- 1))
1520 /* Look for it in the type's vector of small shared ints. */
1521 if (!TYPE_CACHED_VALUES_P (type
))
1523 TYPE_CACHED_VALUES_P (type
) = 1;
1524 TYPE_CACHED_VALUES (type
) = make_tree_vec (limit
);
1527 t
= TREE_VEC_ELT (TYPE_CACHED_VALUES (type
), ix
);
1529 /* Make sure no one is clobbering the shared constant. */
1530 gcc_checking_assert (TREE_TYPE (t
) == type
1531 && TREE_INT_CST_NUNITS (t
) == 1
1532 && TREE_INT_CST_OFFSET_NUNITS (t
) == 1
1533 && TREE_INT_CST_EXT_NUNITS (t
) == 1
1534 && TREE_INT_CST_ELT (t
, 0) == hwi
);
1537 /* Create a new shared int. */
1538 t
= build_new_int_cst (type
, cst
);
1539 TREE_VEC_ELT (TYPE_CACHED_VALUES (type
), ix
) = t
;
1544 /* Use the cache of larger shared ints, using int_cst_node as
1547 TREE_INT_CST_ELT (int_cst_node
, 0) = hwi
;
1548 TREE_TYPE (int_cst_node
) = type
;
1550 tree
*slot
= int_cst_hash_table
->find_slot (int_cst_node
, INSERT
);
1554 /* Insert this one into the hash table. */
1557 /* Make a new node for next time round. */
1558 int_cst_node
= make_int_cst (1, 1);
1564 /* The value either hashes properly or we drop it on the floor
1565 for the gc to take care of. There will not be enough of them
1568 tree nt
= build_new_int_cst (type
, cst
);
1569 tree
*slot
= int_cst_hash_table
->find_slot (nt
, INSERT
);
1573 /* Insert this one into the hash table. */
1585 cache_integer_cst (tree t
)
1587 tree type
= TREE_TYPE (t
);
1590 int prec
= TYPE_PRECISION (type
);
1592 gcc_assert (!TREE_OVERFLOW (t
));
1594 switch (TREE_CODE (type
))
1597 gcc_assert (integer_zerop (t
));
1601 case REFERENCE_TYPE
:
1602 /* Cache NULL pointer. */
1603 if (integer_zerop (t
))
1611 /* Cache false or true. */
1613 if (wi::ltu_p (wi::to_wide (t
), 2))
1614 ix
= TREE_INT_CST_ELT (t
, 0);
1619 if (TYPE_UNSIGNED (type
))
1622 limit
= INTEGER_SHARE_LIMIT
;
1624 /* This is a little hokie, but if the prec is smaller than
1625 what is necessary to hold INTEGER_SHARE_LIMIT, then the
1626 obvious test will not get the correct answer. */
1627 if (prec
< HOST_BITS_PER_WIDE_INT
)
1629 if (tree_to_uhwi (t
) < (unsigned HOST_WIDE_INT
) INTEGER_SHARE_LIMIT
)
1630 ix
= tree_to_uhwi (t
);
1632 else if (wi::ltu_p (wi::to_wide (t
), INTEGER_SHARE_LIMIT
))
1633 ix
= tree_to_uhwi (t
);
1638 limit
= INTEGER_SHARE_LIMIT
+ 1;
1640 if (integer_minus_onep (t
))
1642 else if (!wi::neg_p (wi::to_wide (t
)))
1644 if (prec
< HOST_BITS_PER_WIDE_INT
)
1646 if (tree_to_shwi (t
) < INTEGER_SHARE_LIMIT
)
1647 ix
= tree_to_shwi (t
) + 1;
1649 else if (wi::ltu_p (wi::to_wide (t
), INTEGER_SHARE_LIMIT
))
1650 ix
= tree_to_shwi (t
) + 1;
1664 /* Look for it in the type's vector of small shared ints. */
1665 if (!TYPE_CACHED_VALUES_P (type
))
1667 TYPE_CACHED_VALUES_P (type
) = 1;
1668 TYPE_CACHED_VALUES (type
) = make_tree_vec (limit
);
1671 gcc_assert (TREE_VEC_ELT (TYPE_CACHED_VALUES (type
), ix
) == NULL_TREE
);
1672 TREE_VEC_ELT (TYPE_CACHED_VALUES (type
), ix
) = t
;
1676 /* Use the cache of larger shared ints. */
1677 tree
*slot
= int_cst_hash_table
->find_slot (t
, INSERT
);
1678 /* If there is already an entry for the number verify it's the
1681 gcc_assert (wi::to_wide (tree (*slot
)) == wi::to_wide (t
));
1683 /* Otherwise insert this one into the hash table. */
1689 /* Builds an integer constant in TYPE such that lowest BITS bits are ones
1690 and the rest are zeros. */
1693 build_low_bits_mask (tree type
, unsigned bits
)
1695 gcc_assert (bits
<= TYPE_PRECISION (type
));
1697 return wide_int_to_tree (type
, wi::mask (bits
, false,
1698 TYPE_PRECISION (type
)));
1701 /* Checks that X is integer constant that can be expressed in (unsigned)
1702 HOST_WIDE_INT without loss of precision. */
1705 cst_and_fits_in_hwi (const_tree x
)
1707 return (TREE_CODE (x
) == INTEGER_CST
1708 && (tree_fits_shwi_p (x
) || tree_fits_uhwi_p (x
)));
1711 /* Build a newly constructed VECTOR_CST node of length LEN. */
1714 make_vector (unsigned len MEM_STAT_DECL
)
1717 unsigned length
= (len
- 1) * sizeof (tree
) + sizeof (struct tree_vector
);
1719 record_node_allocation_statistics (VECTOR_CST
, length
);
1721 t
= ggc_alloc_cleared_tree_node_stat (length PASS_MEM_STAT
);
1723 TREE_SET_CODE (t
, VECTOR_CST
);
1724 TREE_CONSTANT (t
) = 1;
1725 VECTOR_CST_NELTS (t
) = len
;
1730 /* Return a new VECTOR_CST node whose type is TYPE and whose values
1731 are given by VALS. */
1734 build_vector (tree type
, vec
<tree
> vals MEM_STAT_DECL
)
1736 unsigned int nelts
= vals
.length ();
1737 gcc_assert (nelts
== TYPE_VECTOR_SUBPARTS (type
));
1740 tree v
= make_vector (nelts
);
1741 TREE_TYPE (v
) = type
;
1743 /* Iterate through elements and check for overflow. */
1744 for (cnt
= 0; cnt
< nelts
; ++cnt
)
1746 tree value
= vals
[cnt
];
1748 VECTOR_CST_ELT (v
, cnt
) = value
;
1750 /* Don't crash if we get an address constant. */
1751 if (!CONSTANT_CLASS_P (value
))
1754 over
|= TREE_OVERFLOW (value
);
1757 TREE_OVERFLOW (v
) = over
;
1761 /* Return a new VECTOR_CST node whose type is TYPE and whose values
1762 are extracted from V, a vector of CONSTRUCTOR_ELT. */
1765 build_vector_from_ctor (tree type
, vec
<constructor_elt
, va_gc
> *v
)
1767 unsigned int nelts
= TYPE_VECTOR_SUBPARTS (type
);
1768 unsigned HOST_WIDE_INT idx
;
1771 auto_vec
<tree
, 32> vec (nelts
);
1772 FOR_EACH_CONSTRUCTOR_VALUE (v
, idx
, value
)
1774 if (TREE_CODE (value
) == VECTOR_CST
)
1775 for (unsigned i
= 0; i
< VECTOR_CST_NELTS (value
); ++i
)
1776 vec
.quick_push (VECTOR_CST_ELT (value
, i
));
1778 vec
.quick_push (value
);
1780 while (vec
.length () < nelts
)
1781 vec
.quick_push (build_zero_cst (TREE_TYPE (type
)));
1783 return build_vector (type
, vec
);
1786 /* Build a vector of type VECTYPE where all the elements are SCs. */
1788 build_vector_from_val (tree vectype
, tree sc
)
1790 int i
, nunits
= TYPE_VECTOR_SUBPARTS (vectype
);
1792 if (sc
== error_mark_node
)
1795 /* Verify that the vector type is suitable for SC. Note that there
1796 is some inconsistency in the type-system with respect to restrict
1797 qualifications of pointers. Vector types always have a main-variant
1798 element type and the qualification is applied to the vector-type.
1799 So TREE_TYPE (vector-type) does not return a properly qualified
1800 vector element-type. */
1801 gcc_checking_assert (types_compatible_p (TYPE_MAIN_VARIANT (TREE_TYPE (sc
)),
1802 TREE_TYPE (vectype
)));
1804 if (CONSTANT_CLASS_P (sc
))
1806 auto_vec
<tree
, 32> v (nunits
);
1807 for (i
= 0; i
< nunits
; ++i
)
1809 return build_vector (vectype
, v
);
1813 vec
<constructor_elt
, va_gc
> *v
;
1814 vec_alloc (v
, nunits
);
1815 for (i
= 0; i
< nunits
; ++i
)
1816 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, sc
);
1817 return build_constructor (vectype
, v
);
1821 /* Something has messed with the elements of CONSTRUCTOR C after it was built;
1822 calculate TREE_CONSTANT and TREE_SIDE_EFFECTS. */
1825 recompute_constructor_flags (tree c
)
1829 bool constant_p
= true;
1830 bool side_effects_p
= false;
1831 vec
<constructor_elt
, va_gc
> *vals
= CONSTRUCTOR_ELTS (c
);
1833 FOR_EACH_CONSTRUCTOR_VALUE (vals
, i
, val
)
1835 /* Mostly ctors will have elts that don't have side-effects, so
1836 the usual case is to scan all the elements. Hence a single
1837 loop for both const and side effects, rather than one loop
1838 each (with early outs). */
1839 if (!TREE_CONSTANT (val
))
1841 if (TREE_SIDE_EFFECTS (val
))
1842 side_effects_p
= true;
1845 TREE_SIDE_EFFECTS (c
) = side_effects_p
;
1846 TREE_CONSTANT (c
) = constant_p
;
1849 /* Make sure that TREE_CONSTANT and TREE_SIDE_EFFECTS are correct for
1853 verify_constructor_flags (tree c
)
1857 bool constant_p
= TREE_CONSTANT (c
);
1858 bool side_effects_p
= TREE_SIDE_EFFECTS (c
);
1859 vec
<constructor_elt
, va_gc
> *vals
= CONSTRUCTOR_ELTS (c
);
1861 FOR_EACH_CONSTRUCTOR_VALUE (vals
, i
, val
)
1863 if (constant_p
&& !TREE_CONSTANT (val
))
1864 internal_error ("non-constant element in constant CONSTRUCTOR");
1865 if (!side_effects_p
&& TREE_SIDE_EFFECTS (val
))
1866 internal_error ("side-effects element in no-side-effects CONSTRUCTOR");
1870 /* Return a new CONSTRUCTOR node whose type is TYPE and whose values
1871 are in the vec pointed to by VALS. */
1873 build_constructor (tree type
, vec
<constructor_elt
, va_gc
> *vals
)
1875 tree c
= make_node (CONSTRUCTOR
);
1877 TREE_TYPE (c
) = type
;
1878 CONSTRUCTOR_ELTS (c
) = vals
;
1880 recompute_constructor_flags (c
);
1885 /* Build a CONSTRUCTOR node made of a single initializer, with the specified
1888 build_constructor_single (tree type
, tree index
, tree value
)
1890 vec
<constructor_elt
, va_gc
> *v
;
1891 constructor_elt elt
= {index
, value
};
1894 v
->quick_push (elt
);
1896 return build_constructor (type
, v
);
1900 /* Return a new CONSTRUCTOR node whose type is TYPE and whose values
1901 are in a list pointed to by VALS. */
1903 build_constructor_from_list (tree type
, tree vals
)
1906 vec
<constructor_elt
, va_gc
> *v
= NULL
;
1910 vec_alloc (v
, list_length (vals
));
1911 for (t
= vals
; t
; t
= TREE_CHAIN (t
))
1912 CONSTRUCTOR_APPEND_ELT (v
, TREE_PURPOSE (t
), TREE_VALUE (t
));
1915 return build_constructor (type
, v
);
1918 /* Return a new CONSTRUCTOR node whose type is TYPE. NELTS is the number
1919 of elements, provided as index/value pairs. */
1922 build_constructor_va (tree type
, int nelts
, ...)
1924 vec
<constructor_elt
, va_gc
> *v
= NULL
;
1927 va_start (p
, nelts
);
1928 vec_alloc (v
, nelts
);
1931 tree index
= va_arg (p
, tree
);
1932 tree value
= va_arg (p
, tree
);
1933 CONSTRUCTOR_APPEND_ELT (v
, index
, value
);
1936 return build_constructor (type
, v
);
1939 /* Return a new FIXED_CST node whose type is TYPE and value is F. */
1942 build_fixed (tree type
, FIXED_VALUE_TYPE f
)
1945 FIXED_VALUE_TYPE
*fp
;
1947 v
= make_node (FIXED_CST
);
1948 fp
= ggc_alloc
<fixed_value
> ();
1949 memcpy (fp
, &f
, sizeof (FIXED_VALUE_TYPE
));
1951 TREE_TYPE (v
) = type
;
1952 TREE_FIXED_CST_PTR (v
) = fp
;
1956 /* Return a new REAL_CST node whose type is TYPE and value is D. */
1959 build_real (tree type
, REAL_VALUE_TYPE d
)
1962 REAL_VALUE_TYPE
*dp
;
1965 /* ??? Used to check for overflow here via CHECK_FLOAT_TYPE.
1966 Consider doing it via real_convert now. */
1968 v
= make_node (REAL_CST
);
1969 dp
= ggc_alloc
<real_value
> ();
1970 memcpy (dp
, &d
, sizeof (REAL_VALUE_TYPE
));
1972 TREE_TYPE (v
) = type
;
1973 TREE_REAL_CST_PTR (v
) = dp
;
1974 TREE_OVERFLOW (v
) = overflow
;
1978 /* Like build_real, but first truncate D to the type. */
1981 build_real_truncate (tree type
, REAL_VALUE_TYPE d
)
1983 return build_real (type
, real_value_truncate (TYPE_MODE (type
), d
));
1986 /* Return a new REAL_CST node whose type is TYPE
1987 and whose value is the integer value of the INTEGER_CST node I. */
1990 real_value_from_int_cst (const_tree type
, const_tree i
)
1994 /* Clear all bits of the real value type so that we can later do
1995 bitwise comparisons to see if two values are the same. */
1996 memset (&d
, 0, sizeof d
);
1998 real_from_integer (&d
, type
? TYPE_MODE (type
) : VOIDmode
, wi::to_wide (i
),
1999 TYPE_SIGN (TREE_TYPE (i
)));
2003 /* Given a tree representing an integer constant I, return a tree
2004 representing the same value as a floating-point constant of type TYPE. */
2007 build_real_from_int_cst (tree type
, const_tree i
)
2010 int overflow
= TREE_OVERFLOW (i
);
2012 v
= build_real (type
, real_value_from_int_cst (type
, i
));
2014 TREE_OVERFLOW (v
) |= overflow
;
2018 /* Return a newly constructed STRING_CST node whose value is
2019 the LEN characters at STR.
2020 Note that for a C string literal, LEN should include the trailing NUL.
2021 The TREE_TYPE is not initialized. */
2024 build_string (int len
, const char *str
)
2029 /* Do not waste bytes provided by padding of struct tree_string. */
2030 length
= len
+ offsetof (struct tree_string
, str
) + 1;
2032 record_node_allocation_statistics (STRING_CST
, length
);
2034 s
= (tree
) ggc_internal_alloc (length
);
2036 memset (s
, 0, sizeof (struct tree_typed
));
2037 TREE_SET_CODE (s
, STRING_CST
);
2038 TREE_CONSTANT (s
) = 1;
2039 TREE_STRING_LENGTH (s
) = len
;
2040 memcpy (s
->string
.str
, str
, len
);
2041 s
->string
.str
[len
] = '\0';
2046 /* Return a newly constructed COMPLEX_CST node whose value is
2047 specified by the real and imaginary parts REAL and IMAG.
2048 Both REAL and IMAG should be constant nodes. TYPE, if specified,
2049 will be the type of the COMPLEX_CST; otherwise a new type will be made. */
2052 build_complex (tree type
, tree real
, tree imag
)
2054 tree t
= make_node (COMPLEX_CST
);
2056 TREE_REALPART (t
) = real
;
2057 TREE_IMAGPART (t
) = imag
;
2058 TREE_TYPE (t
) = type
? type
: build_complex_type (TREE_TYPE (real
));
2059 TREE_OVERFLOW (t
) = TREE_OVERFLOW (real
) | TREE_OVERFLOW (imag
);
2063 /* Build a complex (inf +- 0i), such as for the result of cproj.
2064 TYPE is the complex tree type of the result. If NEG is true, the
2065 imaginary zero is negative. */
2068 build_complex_inf (tree type
, bool neg
)
2070 REAL_VALUE_TYPE rinf
, rzero
= dconst0
;
2074 return build_complex (type
, build_real (TREE_TYPE (type
), rinf
),
2075 build_real (TREE_TYPE (type
), rzero
));
2078 /* Return the constant 1 in type TYPE. If TYPE has several elements, each
2079 element is set to 1. In particular, this is 1 + i for complex types. */
2082 build_each_one_cst (tree type
)
2084 if (TREE_CODE (type
) == COMPLEX_TYPE
)
2086 tree scalar
= build_one_cst (TREE_TYPE (type
));
2087 return build_complex (type
, scalar
, scalar
);
2090 return build_one_cst (type
);
2093 /* Return a constant of arithmetic type TYPE which is the
2094 multiplicative identity of the set TYPE. */
2097 build_one_cst (tree type
)
2099 switch (TREE_CODE (type
))
2101 case INTEGER_TYPE
: case ENUMERAL_TYPE
: case BOOLEAN_TYPE
:
2102 case POINTER_TYPE
: case REFERENCE_TYPE
:
2104 return build_int_cst (type
, 1);
2107 return build_real (type
, dconst1
);
2109 case FIXED_POINT_TYPE
:
2110 /* We can only generate 1 for accum types. */
2111 gcc_assert (ALL_SCALAR_ACCUM_MODE_P (TYPE_MODE (type
)));
2112 return build_fixed (type
, FCONST1 (TYPE_MODE (type
)));
2116 tree scalar
= build_one_cst (TREE_TYPE (type
));
2118 return build_vector_from_val (type
, scalar
);
2122 return build_complex (type
,
2123 build_one_cst (TREE_TYPE (type
)),
2124 build_zero_cst (TREE_TYPE (type
)));
2131 /* Return an integer of type TYPE containing all 1's in as much precision as
2132 it contains, or a complex or vector whose subparts are such integers. */
2135 build_all_ones_cst (tree type
)
2137 if (TREE_CODE (type
) == COMPLEX_TYPE
)
2139 tree scalar
= build_all_ones_cst (TREE_TYPE (type
));
2140 return build_complex (type
, scalar
, scalar
);
2143 return build_minus_one_cst (type
);
2146 /* Return a constant of arithmetic type TYPE which is the
2147 opposite of the multiplicative identity of the set TYPE. */
2150 build_minus_one_cst (tree type
)
2152 switch (TREE_CODE (type
))
2154 case INTEGER_TYPE
: case ENUMERAL_TYPE
: case BOOLEAN_TYPE
:
2155 case POINTER_TYPE
: case REFERENCE_TYPE
:
2157 return build_int_cst (type
, -1);
2160 return build_real (type
, dconstm1
);
2162 case FIXED_POINT_TYPE
:
2163 /* We can only generate 1 for accum types. */
2164 gcc_assert (ALL_SCALAR_ACCUM_MODE_P (TYPE_MODE (type
)));
2165 return build_fixed (type
,
2166 fixed_from_double_int (double_int_minus_one
,
2167 SCALAR_TYPE_MODE (type
)));
2171 tree scalar
= build_minus_one_cst (TREE_TYPE (type
));
2173 return build_vector_from_val (type
, scalar
);
2177 return build_complex (type
,
2178 build_minus_one_cst (TREE_TYPE (type
)),
2179 build_zero_cst (TREE_TYPE (type
)));
2186 /* Build 0 constant of type TYPE. This is used by constructor folding
2187 and thus the constant should be represented in memory by
2191 build_zero_cst (tree type
)
2193 switch (TREE_CODE (type
))
2195 case INTEGER_TYPE
: case ENUMERAL_TYPE
: case BOOLEAN_TYPE
:
2196 case POINTER_TYPE
: case REFERENCE_TYPE
:
2197 case OFFSET_TYPE
: case NULLPTR_TYPE
:
2198 return build_int_cst (type
, 0);
2201 return build_real (type
, dconst0
);
2203 case FIXED_POINT_TYPE
:
2204 return build_fixed (type
, FCONST0 (TYPE_MODE (type
)));
2208 tree scalar
= build_zero_cst (TREE_TYPE (type
));
2210 return build_vector_from_val (type
, scalar
);
2215 tree zero
= build_zero_cst (TREE_TYPE (type
));
2217 return build_complex (type
, zero
, zero
);
2221 if (!AGGREGATE_TYPE_P (type
))
2222 return fold_convert (type
, integer_zero_node
);
2223 return build_constructor (type
, NULL
);
2228 /* Build a BINFO with LEN language slots. */
2231 make_tree_binfo (unsigned base_binfos MEM_STAT_DECL
)
2234 size_t length
= (offsetof (struct tree_binfo
, base_binfos
)
2235 + vec
<tree
, va_gc
>::embedded_size (base_binfos
));
2237 record_node_allocation_statistics (TREE_BINFO
, length
);
2239 t
= ggc_alloc_tree_node_stat (length PASS_MEM_STAT
);
2241 memset (t
, 0, offsetof (struct tree_binfo
, base_binfos
));
2243 TREE_SET_CODE (t
, TREE_BINFO
);
2245 BINFO_BASE_BINFOS (t
)->embedded_init (base_binfos
);
2250 /* Create a CASE_LABEL_EXPR tree node and return it. */
2253 build_case_label (tree low_value
, tree high_value
, tree label_decl
)
2255 tree t
= make_node (CASE_LABEL_EXPR
);
2257 TREE_TYPE (t
) = void_type_node
;
2258 SET_EXPR_LOCATION (t
, DECL_SOURCE_LOCATION (label_decl
));
2260 CASE_LOW (t
) = low_value
;
2261 CASE_HIGH (t
) = high_value
;
2262 CASE_LABEL (t
) = label_decl
;
2263 CASE_CHAIN (t
) = NULL_TREE
;
2268 /* Build a newly constructed INTEGER_CST node. LEN and EXT_LEN are the
2269 values of TREE_INT_CST_NUNITS and TREE_INT_CST_EXT_NUNITS respectively.
2270 The latter determines the length of the HOST_WIDE_INT vector. */
2273 make_int_cst (int len
, int ext_len MEM_STAT_DECL
)
2276 int length
= ((ext_len
- 1) * sizeof (HOST_WIDE_INT
)
2277 + sizeof (struct tree_int_cst
));
2280 record_node_allocation_statistics (INTEGER_CST
, length
);
2282 t
= ggc_alloc_cleared_tree_node_stat (length PASS_MEM_STAT
);
2284 TREE_SET_CODE (t
, INTEGER_CST
);
2285 TREE_INT_CST_NUNITS (t
) = len
;
2286 TREE_INT_CST_EXT_NUNITS (t
) = ext_len
;
2287 /* to_offset can only be applied to trees that are offset_int-sized
2288 or smaller. EXT_LEN is correct if it fits, otherwise the constant
2289 must be exactly the precision of offset_int and so LEN is correct. */
2290 if (ext_len
<= OFFSET_INT_ELTS
)
2291 TREE_INT_CST_OFFSET_NUNITS (t
) = ext_len
;
2293 TREE_INT_CST_OFFSET_NUNITS (t
) = len
;
2295 TREE_CONSTANT (t
) = 1;
2300 /* Build a newly constructed TREE_VEC node of length LEN. */
2303 make_tree_vec (int len MEM_STAT_DECL
)
2306 size_t length
= (len
- 1) * sizeof (tree
) + sizeof (struct tree_vec
);
2308 record_node_allocation_statistics (TREE_VEC
, length
);
2310 t
= ggc_alloc_cleared_tree_node_stat (length PASS_MEM_STAT
);
2312 TREE_SET_CODE (t
, TREE_VEC
);
2313 TREE_VEC_LENGTH (t
) = len
;
2318 /* Grow a TREE_VEC node to new length LEN. */
2321 grow_tree_vec (tree v
, int len MEM_STAT_DECL
)
2323 gcc_assert (TREE_CODE (v
) == TREE_VEC
);
2325 int oldlen
= TREE_VEC_LENGTH (v
);
2326 gcc_assert (len
> oldlen
);
2328 size_t oldlength
= (oldlen
- 1) * sizeof (tree
) + sizeof (struct tree_vec
);
2329 size_t length
= (len
- 1) * sizeof (tree
) + sizeof (struct tree_vec
);
2331 record_node_allocation_statistics (TREE_VEC
, length
- oldlength
);
2333 v
= (tree
) ggc_realloc (v
, length PASS_MEM_STAT
);
2335 TREE_VEC_LENGTH (v
) = len
;
2340 /* Return 1 if EXPR is the constant zero, whether it is integral, float or
2341 fixed, and scalar, complex or vector. */
2344 zerop (const_tree expr
)
2346 return (integer_zerop (expr
)
2347 || real_zerop (expr
)
2348 || fixed_zerop (expr
));
2351 /* Return 1 if EXPR is the integer constant zero or a complex constant
2355 integer_zerop (const_tree expr
)
2357 switch (TREE_CODE (expr
))
2360 return wi::to_wide (expr
) == 0;
2362 return (integer_zerop (TREE_REALPART (expr
))
2363 && integer_zerop (TREE_IMAGPART (expr
)));
2367 for (i
= 0; i
< VECTOR_CST_NELTS (expr
); ++i
)
2368 if (!integer_zerop (VECTOR_CST_ELT (expr
, i
)))
2377 /* Return 1 if EXPR is the integer constant one or the corresponding
2378 complex constant. */
2381 integer_onep (const_tree expr
)
2383 switch (TREE_CODE (expr
))
2386 return wi::eq_p (wi::to_widest (expr
), 1);
2388 return (integer_onep (TREE_REALPART (expr
))
2389 && integer_zerop (TREE_IMAGPART (expr
)));
2393 for (i
= 0; i
< VECTOR_CST_NELTS (expr
); ++i
)
2394 if (!integer_onep (VECTOR_CST_ELT (expr
, i
)))
2403 /* Return 1 if EXPR is the integer constant one. For complex and vector,
2404 return 1 if every piece is the integer constant one. */
2407 integer_each_onep (const_tree expr
)
2409 if (TREE_CODE (expr
) == COMPLEX_CST
)
2410 return (integer_onep (TREE_REALPART (expr
))
2411 && integer_onep (TREE_IMAGPART (expr
)));
2413 return integer_onep (expr
);
2416 /* Return 1 if EXPR is an integer containing all 1's in as much precision as
2417 it contains, or a complex or vector whose subparts are such integers. */
2420 integer_all_onesp (const_tree expr
)
2422 if (TREE_CODE (expr
) == COMPLEX_CST
2423 && integer_all_onesp (TREE_REALPART (expr
))
2424 && integer_all_onesp (TREE_IMAGPART (expr
)))
2427 else if (TREE_CODE (expr
) == VECTOR_CST
)
2430 for (i
= 0; i
< VECTOR_CST_NELTS (expr
); ++i
)
2431 if (!integer_all_onesp (VECTOR_CST_ELT (expr
, i
)))
2436 else if (TREE_CODE (expr
) != INTEGER_CST
)
2439 return (wi::max_value (TYPE_PRECISION (TREE_TYPE (expr
)), UNSIGNED
)
2440 == wi::to_wide (expr
));
2443 /* Return 1 if EXPR is the integer constant minus one. */
2446 integer_minus_onep (const_tree expr
)
2448 if (TREE_CODE (expr
) == COMPLEX_CST
)
2449 return (integer_all_onesp (TREE_REALPART (expr
))
2450 && integer_zerop (TREE_IMAGPART (expr
)));
2452 return integer_all_onesp (expr
);
2455 /* Return 1 if EXPR is an integer constant that is a power of 2 (i.e., has only
2459 integer_pow2p (const_tree expr
)
2461 if (TREE_CODE (expr
) == COMPLEX_CST
2462 && integer_pow2p (TREE_REALPART (expr
))
2463 && integer_zerop (TREE_IMAGPART (expr
)))
2466 if (TREE_CODE (expr
) != INTEGER_CST
)
2469 return wi::popcount (wi::to_wide (expr
)) == 1;
2472 /* Return 1 if EXPR is an integer constant other than zero or a
2473 complex constant other than zero. */
2476 integer_nonzerop (const_tree expr
)
2478 return ((TREE_CODE (expr
) == INTEGER_CST
2479 && wi::to_wide (expr
) != 0)
2480 || (TREE_CODE (expr
) == COMPLEX_CST
2481 && (integer_nonzerop (TREE_REALPART (expr
))
2482 || integer_nonzerop (TREE_IMAGPART (expr
)))));
2485 /* Return 1 if EXPR is the integer constant one. For vector,
2486 return 1 if every piece is the integer constant minus one
2487 (representing the value TRUE). */
2490 integer_truep (const_tree expr
)
2492 if (TREE_CODE (expr
) == VECTOR_CST
)
2493 return integer_all_onesp (expr
);
2494 return integer_onep (expr
);
2497 /* Return 1 if EXPR is the fixed-point constant zero. */
2500 fixed_zerop (const_tree expr
)
2502 return (TREE_CODE (expr
) == FIXED_CST
2503 && TREE_FIXED_CST (expr
).data
.is_zero ());
2506 /* Return the power of two represented by a tree node known to be a
2510 tree_log2 (const_tree expr
)
2512 if (TREE_CODE (expr
) == COMPLEX_CST
)
2513 return tree_log2 (TREE_REALPART (expr
));
2515 return wi::exact_log2 (wi::to_wide (expr
));
2518 /* Similar, but return the largest integer Y such that 2 ** Y is less
2519 than or equal to EXPR. */
2522 tree_floor_log2 (const_tree expr
)
2524 if (TREE_CODE (expr
) == COMPLEX_CST
)
2525 return tree_log2 (TREE_REALPART (expr
));
2527 return wi::floor_log2 (wi::to_wide (expr
));
2530 /* Return number of known trailing zero bits in EXPR, or, if the value of
2531 EXPR is known to be zero, the precision of it's type. */
2534 tree_ctz (const_tree expr
)
2536 if (!INTEGRAL_TYPE_P (TREE_TYPE (expr
))
2537 && !POINTER_TYPE_P (TREE_TYPE (expr
)))
2540 unsigned int ret1
, ret2
, prec
= TYPE_PRECISION (TREE_TYPE (expr
));
2541 switch (TREE_CODE (expr
))
2544 ret1
= wi::ctz (wi::to_wide (expr
));
2545 return MIN (ret1
, prec
);
2547 ret1
= wi::ctz (get_nonzero_bits (expr
));
2548 return MIN (ret1
, prec
);
2555 ret1
= tree_ctz (TREE_OPERAND (expr
, 0));
2558 ret2
= tree_ctz (TREE_OPERAND (expr
, 1));
2559 return MIN (ret1
, ret2
);
2560 case POINTER_PLUS_EXPR
:
2561 ret1
= tree_ctz (TREE_OPERAND (expr
, 0));
2562 ret2
= tree_ctz (TREE_OPERAND (expr
, 1));
2563 /* Second operand is sizetype, which could be in theory
2564 wider than pointer's precision. Make sure we never
2565 return more than prec. */
2566 ret2
= MIN (ret2
, prec
);
2567 return MIN (ret1
, ret2
);
2569 ret1
= tree_ctz (TREE_OPERAND (expr
, 0));
2570 ret2
= tree_ctz (TREE_OPERAND (expr
, 1));
2571 return MAX (ret1
, ret2
);
2573 ret1
= tree_ctz (TREE_OPERAND (expr
, 0));
2574 ret2
= tree_ctz (TREE_OPERAND (expr
, 1));
2575 return MIN (ret1
+ ret2
, prec
);
2577 ret1
= tree_ctz (TREE_OPERAND (expr
, 0));
2578 if (tree_fits_uhwi_p (TREE_OPERAND (expr
, 1))
2579 && (tree_to_uhwi (TREE_OPERAND (expr
, 1)) < prec
))
2581 ret2
= tree_to_uhwi (TREE_OPERAND (expr
, 1));
2582 return MIN (ret1
+ ret2
, prec
);
2586 if (tree_fits_uhwi_p (TREE_OPERAND (expr
, 1))
2587 && (tree_to_uhwi (TREE_OPERAND (expr
, 1)) < prec
))
2589 ret1
= tree_ctz (TREE_OPERAND (expr
, 0));
2590 ret2
= tree_to_uhwi (TREE_OPERAND (expr
, 1));
2595 case TRUNC_DIV_EXPR
:
2597 case FLOOR_DIV_EXPR
:
2598 case ROUND_DIV_EXPR
:
2599 case EXACT_DIV_EXPR
:
2600 if (TREE_CODE (TREE_OPERAND (expr
, 1)) == INTEGER_CST
2601 && tree_int_cst_sgn (TREE_OPERAND (expr
, 1)) == 1)
2603 int l
= tree_log2 (TREE_OPERAND (expr
, 1));
2606 ret1
= tree_ctz (TREE_OPERAND (expr
, 0));
2614 ret1
= tree_ctz (TREE_OPERAND (expr
, 0));
2615 if (ret1
&& ret1
== TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (expr
, 0))))
2617 return MIN (ret1
, prec
);
2619 return tree_ctz (TREE_OPERAND (expr
, 0));
2621 ret1
= tree_ctz (TREE_OPERAND (expr
, 1));
2624 ret2
= tree_ctz (TREE_OPERAND (expr
, 2));
2625 return MIN (ret1
, ret2
);
2627 return tree_ctz (TREE_OPERAND (expr
, 1));
2629 ret1
= get_pointer_alignment (CONST_CAST_TREE (expr
));
2630 if (ret1
> BITS_PER_UNIT
)
2632 ret1
= ctz_hwi (ret1
/ BITS_PER_UNIT
);
2633 return MIN (ret1
, prec
);
2641 /* Return 1 if EXPR is the real constant zero. Trailing zeroes matter for
2642 decimal float constants, so don't return 1 for them. */
2645 real_zerop (const_tree expr
)
2647 switch (TREE_CODE (expr
))
2650 return real_equal (&TREE_REAL_CST (expr
), &dconst0
)
2651 && !(DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (expr
))));
2653 return real_zerop (TREE_REALPART (expr
))
2654 && real_zerop (TREE_IMAGPART (expr
));
2658 for (i
= 0; i
< VECTOR_CST_NELTS (expr
); ++i
)
2659 if (!real_zerop (VECTOR_CST_ELT (expr
, i
)))
2668 /* Return 1 if EXPR is the real constant one in real or complex form.
2669 Trailing zeroes matter for decimal float constants, so don't return
2673 real_onep (const_tree expr
)
2675 switch (TREE_CODE (expr
))
2678 return real_equal (&TREE_REAL_CST (expr
), &dconst1
)
2679 && !(DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (expr
))));
2681 return real_onep (TREE_REALPART (expr
))
2682 && real_zerop (TREE_IMAGPART (expr
));
2686 for (i
= 0; i
< VECTOR_CST_NELTS (expr
); ++i
)
2687 if (!real_onep (VECTOR_CST_ELT (expr
, i
)))
2696 /* Return 1 if EXPR is the real constant minus one. Trailing zeroes
2697 matter for decimal float constants, so don't return 1 for them. */
2700 real_minus_onep (const_tree expr
)
2702 switch (TREE_CODE (expr
))
2705 return real_equal (&TREE_REAL_CST (expr
), &dconstm1
)
2706 && !(DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (expr
))));
2708 return real_minus_onep (TREE_REALPART (expr
))
2709 && real_zerop (TREE_IMAGPART (expr
));
2713 for (i
= 0; i
< VECTOR_CST_NELTS (expr
); ++i
)
2714 if (!real_minus_onep (VECTOR_CST_ELT (expr
, i
)))
2723 /* Nonzero if EXP is a constant or a cast of a constant. */
2726 really_constant_p (const_tree exp
)
2728 /* This is not quite the same as STRIP_NOPS. It does more. */
2729 while (CONVERT_EXPR_P (exp
)
2730 || TREE_CODE (exp
) == NON_LVALUE_EXPR
)
2731 exp
= TREE_OPERAND (exp
, 0);
2732 return TREE_CONSTANT (exp
);
2735 /* Return first list element whose TREE_VALUE is ELEM.
2736 Return 0 if ELEM is not in LIST. */
2739 value_member (tree elem
, tree list
)
2743 if (elem
== TREE_VALUE (list
))
2745 list
= TREE_CHAIN (list
);
2750 /* Return first list element whose TREE_PURPOSE is ELEM.
2751 Return 0 if ELEM is not in LIST. */
2754 purpose_member (const_tree elem
, tree list
)
2758 if (elem
== TREE_PURPOSE (list
))
2760 list
= TREE_CHAIN (list
);
2765 /* Return true if ELEM is in V. */
2768 vec_member (const_tree elem
, vec
<tree
, va_gc
> *v
)
2772 FOR_EACH_VEC_SAFE_ELT (v
, ix
, t
)
2778 /* Returns element number IDX (zero-origin) of chain CHAIN, or
2782 chain_index (int idx
, tree chain
)
2784 for (; chain
&& idx
> 0; --idx
)
2785 chain
= TREE_CHAIN (chain
);
2789 /* Return nonzero if ELEM is part of the chain CHAIN. */
2792 chain_member (const_tree elem
, const_tree chain
)
2798 chain
= DECL_CHAIN (chain
);
2804 /* Return the length of a chain of nodes chained through TREE_CHAIN.
2805 We expect a null pointer to mark the end of the chain.
2806 This is the Lisp primitive `length'. */
2809 list_length (const_tree t
)
2812 #ifdef ENABLE_TREE_CHECKING
2820 #ifdef ENABLE_TREE_CHECKING
2823 gcc_assert (p
!= q
);
2831 /* Returns the first FIELD_DECL in the TYPE_FIELDS of the RECORD_TYPE or
2832 UNION_TYPE TYPE, or NULL_TREE if none. */
2835 first_field (const_tree type
)
2837 tree t
= TYPE_FIELDS (type
);
2838 while (t
&& TREE_CODE (t
) != FIELD_DECL
)
2843 /* Concatenate two chains of nodes (chained through TREE_CHAIN)
2844 by modifying the last node in chain 1 to point to chain 2.
2845 This is the Lisp primitive `nconc'. */
2848 chainon (tree op1
, tree op2
)
2857 for (t1
= op1
; TREE_CHAIN (t1
); t1
= TREE_CHAIN (t1
))
2859 TREE_CHAIN (t1
) = op2
;
2861 #ifdef ENABLE_TREE_CHECKING
2864 for (t2
= op2
; t2
; t2
= TREE_CHAIN (t2
))
2865 gcc_assert (t2
!= t1
);
2872 /* Return the last node in a chain of nodes (chained through TREE_CHAIN). */
2875 tree_last (tree chain
)
2879 while ((next
= TREE_CHAIN (chain
)))
2884 /* Reverse the order of elements in the chain T,
2885 and return the new head of the chain (old last element). */
2890 tree prev
= 0, decl
, next
;
2891 for (decl
= t
; decl
; decl
= next
)
2893 /* We shouldn't be using this function to reverse BLOCK chains; we
2894 have blocks_nreverse for that. */
2895 gcc_checking_assert (TREE_CODE (decl
) != BLOCK
);
2896 next
= TREE_CHAIN (decl
);
2897 TREE_CHAIN (decl
) = prev
;
2903 /* Return a newly created TREE_LIST node whose
2904 purpose and value fields are PARM and VALUE. */
2907 build_tree_list (tree parm
, tree value MEM_STAT_DECL
)
2909 tree t
= make_node (TREE_LIST PASS_MEM_STAT
);
2910 TREE_PURPOSE (t
) = parm
;
2911 TREE_VALUE (t
) = value
;
2915 /* Build a chain of TREE_LIST nodes from a vector. */
2918 build_tree_list_vec (const vec
<tree
, va_gc
> *vec MEM_STAT_DECL
)
2920 tree ret
= NULL_TREE
;
2924 FOR_EACH_VEC_SAFE_ELT (vec
, i
, t
)
2926 *pp
= build_tree_list (NULL
, t PASS_MEM_STAT
);
2927 pp
= &TREE_CHAIN (*pp
);
2932 /* Return a newly created TREE_LIST node whose
2933 purpose and value fields are PURPOSE and VALUE
2934 and whose TREE_CHAIN is CHAIN. */
2937 tree_cons (tree purpose
, tree value
, tree chain MEM_STAT_DECL
)
2941 node
= ggc_alloc_tree_node_stat (sizeof (struct tree_list
) PASS_MEM_STAT
);
2942 memset (node
, 0, sizeof (struct tree_common
));
2944 record_node_allocation_statistics (TREE_LIST
, sizeof (struct tree_list
));
2946 TREE_SET_CODE (node
, TREE_LIST
);
2947 TREE_CHAIN (node
) = chain
;
2948 TREE_PURPOSE (node
) = purpose
;
2949 TREE_VALUE (node
) = value
;
2953 /* Return the values of the elements of a CONSTRUCTOR as a vector of
2957 ctor_to_vec (tree ctor
)
2959 vec
<tree
, va_gc
> *vec
;
2960 vec_alloc (vec
, CONSTRUCTOR_NELTS (ctor
));
2964 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (ctor
), ix
, val
)
2965 vec
->quick_push (val
);
2970 /* Return the size nominally occupied by an object of type TYPE
2971 when it resides in memory. The value is measured in units of bytes,
2972 and its data type is that normally used for type sizes
2973 (which is the first type created by make_signed_type or
2974 make_unsigned_type). */
2977 size_in_bytes_loc (location_t loc
, const_tree type
)
2981 if (type
== error_mark_node
)
2982 return integer_zero_node
;
2984 type
= TYPE_MAIN_VARIANT (type
);
2985 t
= TYPE_SIZE_UNIT (type
);
2989 lang_hooks
.types
.incomplete_type_error (loc
, NULL_TREE
, type
);
2990 return size_zero_node
;
2996 /* Return the size of TYPE (in bytes) as a wide integer
2997 or return -1 if the size can vary or is larger than an integer. */
3000 int_size_in_bytes (const_tree type
)
3004 if (type
== error_mark_node
)
3007 type
= TYPE_MAIN_VARIANT (type
);
3008 t
= TYPE_SIZE_UNIT (type
);
3010 if (t
&& tree_fits_uhwi_p (t
))
3011 return TREE_INT_CST_LOW (t
);
3016 /* Return the maximum size of TYPE (in bytes) as a wide integer
3017 or return -1 if the size can vary or is larger than an integer. */
3020 max_int_size_in_bytes (const_tree type
)
3022 HOST_WIDE_INT size
= -1;
3025 /* If this is an array type, check for a possible MAX_SIZE attached. */
3027 if (TREE_CODE (type
) == ARRAY_TYPE
)
3029 size_tree
= TYPE_ARRAY_MAX_SIZE (type
);
3031 if (size_tree
&& tree_fits_uhwi_p (size_tree
))
3032 size
= tree_to_uhwi (size_tree
);
3035 /* If we still haven't been able to get a size, see if the language
3036 can compute a maximum size. */
3040 size_tree
= lang_hooks
.types
.max_size (type
);
3042 if (size_tree
&& tree_fits_uhwi_p (size_tree
))
3043 size
= tree_to_uhwi (size_tree
);
3049 /* Return the bit position of FIELD, in bits from the start of the record.
3050 This is a tree of type bitsizetype. */
3053 bit_position (const_tree field
)
3055 return bit_from_pos (DECL_FIELD_OFFSET (field
),
3056 DECL_FIELD_BIT_OFFSET (field
));
3059 /* Return the byte position of FIELD, in bytes from the start of the record.
3060 This is a tree of type sizetype. */
3063 byte_position (const_tree field
)
3065 return byte_from_pos (DECL_FIELD_OFFSET (field
),
3066 DECL_FIELD_BIT_OFFSET (field
));
3069 /* Likewise, but return as an integer. It must be representable in
3070 that way (since it could be a signed value, we don't have the
3071 option of returning -1 like int_size_in_byte can. */
3074 int_byte_position (const_tree field
)
3076 return tree_to_shwi (byte_position (field
));
3079 /* Return the strictest alignment, in bits, that T is known to have. */
3082 expr_align (const_tree t
)
3084 unsigned int align0
, align1
;
3086 switch (TREE_CODE (t
))
3088 CASE_CONVERT
: case NON_LVALUE_EXPR
:
3089 /* If we have conversions, we know that the alignment of the
3090 object must meet each of the alignments of the types. */
3091 align0
= expr_align (TREE_OPERAND (t
, 0));
3092 align1
= TYPE_ALIGN (TREE_TYPE (t
));
3093 return MAX (align0
, align1
);
3095 case SAVE_EXPR
: case COMPOUND_EXPR
: case MODIFY_EXPR
:
3096 case INIT_EXPR
: case TARGET_EXPR
: case WITH_CLEANUP_EXPR
:
3097 case CLEANUP_POINT_EXPR
:
3098 /* These don't change the alignment of an object. */
3099 return expr_align (TREE_OPERAND (t
, 0));
3102 /* The best we can do is say that the alignment is the least aligned
3104 align0
= expr_align (TREE_OPERAND (t
, 1));
3105 align1
= expr_align (TREE_OPERAND (t
, 2));
3106 return MIN (align0
, align1
);
3108 /* FIXME: LABEL_DECL and CONST_DECL never have DECL_ALIGN set
3109 meaningfully, it's always 1. */
3110 case LABEL_DECL
: case CONST_DECL
:
3111 case VAR_DECL
: case PARM_DECL
: case RESULT_DECL
:
3113 gcc_assert (DECL_ALIGN (t
) != 0);
3114 return DECL_ALIGN (t
);
3120 /* Otherwise take the alignment from that of the type. */
3121 return TYPE_ALIGN (TREE_TYPE (t
));
3124 /* Return, as a tree node, the number of elements for TYPE (which is an
3125 ARRAY_TYPE) minus one. This counts only elements of the top array. */
3128 array_type_nelts (const_tree type
)
3130 tree index_type
, min
, max
;
3132 /* If they did it with unspecified bounds, then we should have already
3133 given an error about it before we got here. */
3134 if (! TYPE_DOMAIN (type
))
3135 return error_mark_node
;
3137 index_type
= TYPE_DOMAIN (type
);
3138 min
= TYPE_MIN_VALUE (index_type
);
3139 max
= TYPE_MAX_VALUE (index_type
);
3141 /* TYPE_MAX_VALUE may not be set if the array has unknown length. */
3143 return error_mark_node
;
3145 return (integer_zerop (min
)
3147 : fold_build2 (MINUS_EXPR
, TREE_TYPE (max
), max
, min
));
3150 /* If arg is static -- a reference to an object in static storage -- then
3151 return the object. This is not the same as the C meaning of `static'.
3152 If arg isn't static, return NULL. */
3157 switch (TREE_CODE (arg
))
3160 /* Nested functions are static, even though taking their address will
3161 involve a trampoline as we unnest the nested function and create
3162 the trampoline on the tree level. */
3166 return ((TREE_STATIC (arg
) || DECL_EXTERNAL (arg
))
3167 && ! DECL_THREAD_LOCAL_P (arg
)
3168 && ! DECL_DLLIMPORT_P (arg
)
3172 return ((TREE_STATIC (arg
) || DECL_EXTERNAL (arg
))
3176 return TREE_STATIC (arg
) ? arg
: NULL
;
3183 /* If the thing being referenced is not a field, then it is
3184 something language specific. */
3185 gcc_assert (TREE_CODE (TREE_OPERAND (arg
, 1)) == FIELD_DECL
);
3187 /* If we are referencing a bitfield, we can't evaluate an
3188 ADDR_EXPR at compile time and so it isn't a constant. */
3189 if (DECL_BIT_FIELD (TREE_OPERAND (arg
, 1)))
3192 return staticp (TREE_OPERAND (arg
, 0));
3198 return TREE_CONSTANT (TREE_OPERAND (arg
, 0)) ? arg
: NULL
;
3201 case ARRAY_RANGE_REF
:
3202 if (TREE_CODE (TYPE_SIZE (TREE_TYPE (arg
))) == INTEGER_CST
3203 && TREE_CODE (TREE_OPERAND (arg
, 1)) == INTEGER_CST
)
3204 return staticp (TREE_OPERAND (arg
, 0));
3208 case COMPOUND_LITERAL_EXPR
:
3209 return TREE_STATIC (COMPOUND_LITERAL_EXPR_DECL (arg
)) ? arg
: NULL
;
3219 /* Return whether OP is a DECL whose address is function-invariant. */
3222 decl_address_invariant_p (const_tree op
)
3224 /* The conditions below are slightly less strict than the one in
3227 switch (TREE_CODE (op
))
3236 if ((TREE_STATIC (op
) || DECL_EXTERNAL (op
))
3237 || DECL_THREAD_LOCAL_P (op
)
3238 || DECL_CONTEXT (op
) == current_function_decl
3239 || decl_function_context (op
) == current_function_decl
)
3244 if ((TREE_STATIC (op
) || DECL_EXTERNAL (op
))
3245 || decl_function_context (op
) == current_function_decl
)
3256 /* Return whether OP is a DECL whose address is interprocedural-invariant. */
3259 decl_address_ip_invariant_p (const_tree op
)
3261 /* The conditions below are slightly less strict than the one in
3264 switch (TREE_CODE (op
))
3272 if (((TREE_STATIC (op
) || DECL_EXTERNAL (op
))
3273 && !DECL_DLLIMPORT_P (op
))
3274 || DECL_THREAD_LOCAL_P (op
))
3279 if ((TREE_STATIC (op
) || DECL_EXTERNAL (op
)))
3291 /* Return true if T is function-invariant (internal function, does
3292 not handle arithmetic; that's handled in skip_simple_arithmetic and
3293 tree_invariant_p). */
3296 tree_invariant_p_1 (tree t
)
3300 if (TREE_CONSTANT (t
)
3301 || (TREE_READONLY (t
) && !TREE_SIDE_EFFECTS (t
)))
3304 switch (TREE_CODE (t
))
3310 op
= TREE_OPERAND (t
, 0);
3311 while (handled_component_p (op
))
3313 switch (TREE_CODE (op
))
3316 case ARRAY_RANGE_REF
:
3317 if (!tree_invariant_p (TREE_OPERAND (op
, 1))
3318 || TREE_OPERAND (op
, 2) != NULL_TREE
3319 || TREE_OPERAND (op
, 3) != NULL_TREE
)
3324 if (TREE_OPERAND (op
, 2) != NULL_TREE
)
3330 op
= TREE_OPERAND (op
, 0);
3333 return CONSTANT_CLASS_P (op
) || decl_address_invariant_p (op
);
3342 /* Return true if T is function-invariant. */
3345 tree_invariant_p (tree t
)
3347 tree inner
= skip_simple_arithmetic (t
);
3348 return tree_invariant_p_1 (inner
);
3351 /* Wrap a SAVE_EXPR around EXPR, if appropriate.
3352 Do this to any expression which may be used in more than one place,
3353 but must be evaluated only once.
3355 Normally, expand_expr would reevaluate the expression each time.
3356 Calling save_expr produces something that is evaluated and recorded
3357 the first time expand_expr is called on it. Subsequent calls to
3358 expand_expr just reuse the recorded value.
3360 The call to expand_expr that generates code that actually computes
3361 the value is the first call *at compile time*. Subsequent calls
3362 *at compile time* generate code to use the saved value.
3363 This produces correct result provided that *at run time* control
3364 always flows through the insns made by the first expand_expr
3365 before reaching the other places where the save_expr was evaluated.
3366 You, the caller of save_expr, must make sure this is so.
3368 Constants, and certain read-only nodes, are returned with no
3369 SAVE_EXPR because that is safe. Expressions containing placeholders
3370 are not touched; see tree.def for an explanation of what these
3374 save_expr (tree expr
)
3378 /* If the tree evaluates to a constant, then we don't want to hide that
3379 fact (i.e. this allows further folding, and direct checks for constants).
3380 However, a read-only object that has side effects cannot be bypassed.
3381 Since it is no problem to reevaluate literals, we just return the
3383 inner
= skip_simple_arithmetic (expr
);
3384 if (TREE_CODE (inner
) == ERROR_MARK
)
3387 if (tree_invariant_p_1 (inner
))
3390 /* If INNER contains a PLACEHOLDER_EXPR, we must evaluate it each time, since
3391 it means that the size or offset of some field of an object depends on
3392 the value within another field.
3394 Note that it must not be the case that EXPR contains both a PLACEHOLDER_EXPR
3395 and some variable since it would then need to be both evaluated once and
3396 evaluated more than once. Front-ends must assure this case cannot
3397 happen by surrounding any such subexpressions in their own SAVE_EXPR
3398 and forcing evaluation at the proper time. */
3399 if (contains_placeholder_p (inner
))
3402 expr
= build1_loc (EXPR_LOCATION (expr
), SAVE_EXPR
, TREE_TYPE (expr
), expr
);
3404 /* This expression might be placed ahead of a jump to ensure that the
3405 value was computed on both sides of the jump. So make sure it isn't
3406 eliminated as dead. */
3407 TREE_SIDE_EFFECTS (expr
) = 1;
3411 /* Look inside EXPR into any simple arithmetic operations. Return the
3412 outermost non-arithmetic or non-invariant node. */
3415 skip_simple_arithmetic (tree expr
)
3417 /* We don't care about whether this can be used as an lvalue in this
3419 while (TREE_CODE (expr
) == NON_LVALUE_EXPR
)
3420 expr
= TREE_OPERAND (expr
, 0);
3422 /* If we have simple operations applied to a SAVE_EXPR or to a SAVE_EXPR and
3423 a constant, it will be more efficient to not make another SAVE_EXPR since
3424 it will allow better simplification and GCSE will be able to merge the
3425 computations if they actually occur. */
3428 if (UNARY_CLASS_P (expr
))
3429 expr
= TREE_OPERAND (expr
, 0);
3430 else if (BINARY_CLASS_P (expr
))
3432 if (tree_invariant_p (TREE_OPERAND (expr
, 1)))
3433 expr
= TREE_OPERAND (expr
, 0);
3434 else if (tree_invariant_p (TREE_OPERAND (expr
, 0)))
3435 expr
= TREE_OPERAND (expr
, 1);
3446 /* Look inside EXPR into simple arithmetic operations involving constants.
3447 Return the outermost non-arithmetic or non-constant node. */
3450 skip_simple_constant_arithmetic (tree expr
)
3452 while (TREE_CODE (expr
) == NON_LVALUE_EXPR
)
3453 expr
= TREE_OPERAND (expr
, 0);
3457 if (UNARY_CLASS_P (expr
))
3458 expr
= TREE_OPERAND (expr
, 0);
3459 else if (BINARY_CLASS_P (expr
))
3461 if (TREE_CONSTANT (TREE_OPERAND (expr
, 1)))
3462 expr
= TREE_OPERAND (expr
, 0);
3463 else if (TREE_CONSTANT (TREE_OPERAND (expr
, 0)))
3464 expr
= TREE_OPERAND (expr
, 1);
3475 /* Return which tree structure is used by T. */
3477 enum tree_node_structure_enum
3478 tree_node_structure (const_tree t
)
3480 const enum tree_code code
= TREE_CODE (t
);
3481 return tree_node_structure_for_code (code
);
3484 /* Set various status flags when building a CALL_EXPR object T. */
3487 process_call_operands (tree t
)
3489 bool side_effects
= TREE_SIDE_EFFECTS (t
);
3490 bool read_only
= false;
3491 int i
= call_expr_flags (t
);
3493 /* Calls have side-effects, except those to const or pure functions. */
3494 if ((i
& ECF_LOOPING_CONST_OR_PURE
) || !(i
& (ECF_CONST
| ECF_PURE
)))
3495 side_effects
= true;
3496 /* Propagate TREE_READONLY of arguments for const functions. */
3500 if (!side_effects
|| read_only
)
3501 for (i
= 1; i
< TREE_OPERAND_LENGTH (t
); i
++)
3503 tree op
= TREE_OPERAND (t
, i
);
3504 if (op
&& TREE_SIDE_EFFECTS (op
))
3505 side_effects
= true;
3506 if (op
&& !TREE_READONLY (op
) && !CONSTANT_CLASS_P (op
))
3510 TREE_SIDE_EFFECTS (t
) = side_effects
;
3511 TREE_READONLY (t
) = read_only
;
3514 /* Return true if EXP contains a PLACEHOLDER_EXPR, i.e. if it represents a
3515 size or offset that depends on a field within a record. */
3518 contains_placeholder_p (const_tree exp
)
3520 enum tree_code code
;
3525 code
= TREE_CODE (exp
);
3526 if (code
== PLACEHOLDER_EXPR
)
3529 switch (TREE_CODE_CLASS (code
))
3532 /* Don't look at any PLACEHOLDER_EXPRs that might be in index or bit
3533 position computations since they will be converted into a
3534 WITH_RECORD_EXPR involving the reference, which will assume
3535 here will be valid. */
3536 return CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp
, 0));
3538 case tcc_exceptional
:
3539 if (code
== TREE_LIST
)
3540 return (CONTAINS_PLACEHOLDER_P (TREE_VALUE (exp
))
3541 || CONTAINS_PLACEHOLDER_P (TREE_CHAIN (exp
)));
3546 case tcc_comparison
:
3547 case tcc_expression
:
3551 /* Ignoring the first operand isn't quite right, but works best. */
3552 return CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp
, 1));
3555 return (CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp
, 0))
3556 || CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp
, 1))
3557 || CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp
, 2)));
3560 /* The save_expr function never wraps anything containing
3561 a PLACEHOLDER_EXPR. */
3568 switch (TREE_CODE_LENGTH (code
))
3571 return CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp
, 0));
3573 return (CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp
, 0))
3574 || CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp
, 1)));
3585 const_call_expr_arg_iterator iter
;
3586 FOR_EACH_CONST_CALL_EXPR_ARG (arg
, iter
, exp
)
3587 if (CONTAINS_PLACEHOLDER_P (arg
))
3601 /* Return true if any part of the structure of TYPE involves a PLACEHOLDER_EXPR
3602 directly. This includes size, bounds, qualifiers (for QUAL_UNION_TYPE) and
3606 type_contains_placeholder_1 (const_tree type
)
3608 /* If the size contains a placeholder or the parent type (component type in
3609 the case of arrays) type involves a placeholder, this type does. */
3610 if (CONTAINS_PLACEHOLDER_P (TYPE_SIZE (type
))
3611 || CONTAINS_PLACEHOLDER_P (TYPE_SIZE_UNIT (type
))
3612 || (!POINTER_TYPE_P (type
)
3614 && type_contains_placeholder_p (TREE_TYPE (type
))))
3617 /* Now do type-specific checks. Note that the last part of the check above
3618 greatly limits what we have to do below. */
3619 switch (TREE_CODE (type
))
3622 case POINTER_BOUNDS_TYPE
:
3628 case REFERENCE_TYPE
:
3637 case FIXED_POINT_TYPE
:
3638 /* Here we just check the bounds. */
3639 return (CONTAINS_PLACEHOLDER_P (TYPE_MIN_VALUE (type
))
3640 || CONTAINS_PLACEHOLDER_P (TYPE_MAX_VALUE (type
)));
3643 /* We have already checked the component type above, so just check
3644 the domain type. Flexible array members have a null domain. */
3645 return TYPE_DOMAIN (type
) ?
3646 type_contains_placeholder_p (TYPE_DOMAIN (type
)) : false;
3650 case QUAL_UNION_TYPE
:
3654 for (field
= TYPE_FIELDS (type
); field
; field
= DECL_CHAIN (field
))
3655 if (TREE_CODE (field
) == FIELD_DECL
3656 && (CONTAINS_PLACEHOLDER_P (DECL_FIELD_OFFSET (field
))
3657 || (TREE_CODE (type
) == QUAL_UNION_TYPE
3658 && CONTAINS_PLACEHOLDER_P (DECL_QUALIFIER (field
)))
3659 || type_contains_placeholder_p (TREE_TYPE (field
))))
3670 /* Wrapper around above function used to cache its result. */
3673 type_contains_placeholder_p (tree type
)
3677 /* If the contains_placeholder_bits field has been initialized,
3678 then we know the answer. */
3679 if (TYPE_CONTAINS_PLACEHOLDER_INTERNAL (type
) > 0)
3680 return TYPE_CONTAINS_PLACEHOLDER_INTERNAL (type
) - 1;
3682 /* Indicate that we've seen this type node, and the answer is false.
3683 This is what we want to return if we run into recursion via fields. */
3684 TYPE_CONTAINS_PLACEHOLDER_INTERNAL (type
) = 1;
3686 /* Compute the real value. */
3687 result
= type_contains_placeholder_1 (type
);
3689 /* Store the real value. */
3690 TYPE_CONTAINS_PLACEHOLDER_INTERNAL (type
) = result
+ 1;
3695 /* Push tree EXP onto vector QUEUE if it is not already present. */
3698 push_without_duplicates (tree exp
, vec
<tree
> *queue
)
3703 FOR_EACH_VEC_ELT (*queue
, i
, iter
)
3704 if (simple_cst_equal (iter
, exp
) == 1)
3708 queue
->safe_push (exp
);
3711 /* Given a tree EXP, find all occurrences of references to fields
3712 in a PLACEHOLDER_EXPR and place them in vector REFS without
3713 duplicates. Also record VAR_DECLs and CONST_DECLs. Note that
3714 we assume here that EXP contains only arithmetic expressions
3715 or CALL_EXPRs with PLACEHOLDER_EXPRs occurring only in their
3719 find_placeholder_in_expr (tree exp
, vec
<tree
> *refs
)
3721 enum tree_code code
= TREE_CODE (exp
);
3725 /* We handle TREE_LIST and COMPONENT_REF separately. */
3726 if (code
== TREE_LIST
)
3728 FIND_PLACEHOLDER_IN_EXPR (TREE_CHAIN (exp
), refs
);
3729 FIND_PLACEHOLDER_IN_EXPR (TREE_VALUE (exp
), refs
);
3731 else if (code
== COMPONENT_REF
)
3733 for (inner
= TREE_OPERAND (exp
, 0);
3734 REFERENCE_CLASS_P (inner
);
3735 inner
= TREE_OPERAND (inner
, 0))
3738 if (TREE_CODE (inner
) == PLACEHOLDER_EXPR
)
3739 push_without_duplicates (exp
, refs
);
3741 FIND_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp
, 0), refs
);
3744 switch (TREE_CODE_CLASS (code
))
3749 case tcc_declaration
:
3750 /* Variables allocated to static storage can stay. */
3751 if (!TREE_STATIC (exp
))
3752 push_without_duplicates (exp
, refs
);
3755 case tcc_expression
:
3756 /* This is the pattern built in ada/make_aligning_type. */
3757 if (code
== ADDR_EXPR
3758 && TREE_CODE (TREE_OPERAND (exp
, 0)) == PLACEHOLDER_EXPR
)
3760 push_without_duplicates (exp
, refs
);
3766 case tcc_exceptional
:
3769 case tcc_comparison
:
3771 for (i
= 0; i
< TREE_CODE_LENGTH (code
); i
++)
3772 FIND_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp
, i
), refs
);
3776 for (i
= 1; i
< TREE_OPERAND_LENGTH (exp
); i
++)
3777 FIND_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp
, i
), refs
);
3785 /* Given a tree EXP, a FIELD_DECL F, and a replacement value R,
3786 return a tree with all occurrences of references to F in a
3787 PLACEHOLDER_EXPR replaced by R. Also handle VAR_DECLs and
3788 CONST_DECLs. Note that we assume here that EXP contains only
3789 arithmetic expressions or CALL_EXPRs with PLACEHOLDER_EXPRs
3790 occurring only in their argument list. */
3793 substitute_in_expr (tree exp
, tree f
, tree r
)
3795 enum tree_code code
= TREE_CODE (exp
);
3796 tree op0
, op1
, op2
, op3
;
3799 /* We handle TREE_LIST and COMPONENT_REF separately. */
3800 if (code
== TREE_LIST
)
3802 op0
= SUBSTITUTE_IN_EXPR (TREE_CHAIN (exp
), f
, r
);
3803 op1
= SUBSTITUTE_IN_EXPR (TREE_VALUE (exp
), f
, r
);
3804 if (op0
== TREE_CHAIN (exp
) && op1
== TREE_VALUE (exp
))
3807 return tree_cons (TREE_PURPOSE (exp
), op1
, op0
);
3809 else if (code
== COMPONENT_REF
)
3813 /* If this expression is getting a value from a PLACEHOLDER_EXPR
3814 and it is the right field, replace it with R. */
3815 for (inner
= TREE_OPERAND (exp
, 0);
3816 REFERENCE_CLASS_P (inner
);
3817 inner
= TREE_OPERAND (inner
, 0))
3821 op1
= TREE_OPERAND (exp
, 1);
3823 if (TREE_CODE (inner
) == PLACEHOLDER_EXPR
&& op1
== f
)
3826 /* If this expression hasn't been completed let, leave it alone. */
3827 if (TREE_CODE (inner
) == PLACEHOLDER_EXPR
&& !TREE_TYPE (inner
))
3830 op0
= SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp
, 0), f
, r
);
3831 if (op0
== TREE_OPERAND (exp
, 0))
3835 = fold_build3 (COMPONENT_REF
, TREE_TYPE (exp
), op0
, op1
, NULL_TREE
);
3838 switch (TREE_CODE_CLASS (code
))
3843 case tcc_declaration
:
3849 case tcc_expression
:
3855 case tcc_exceptional
:
3858 case tcc_comparison
:
3860 switch (TREE_CODE_LENGTH (code
))
3866 op0
= SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp
, 0), f
, r
);
3867 if (op0
== TREE_OPERAND (exp
, 0))
3870 new_tree
= fold_build1 (code
, TREE_TYPE (exp
), op0
);
3874 op0
= SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp
, 0), f
, r
);
3875 op1
= SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp
, 1), f
, r
);
3877 if (op0
== TREE_OPERAND (exp
, 0) && op1
== TREE_OPERAND (exp
, 1))
3880 new_tree
= fold_build2 (code
, TREE_TYPE (exp
), op0
, op1
);
3884 op0
= SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp
, 0), f
, r
);
3885 op1
= SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp
, 1), f
, r
);
3886 op2
= SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp
, 2), f
, r
);
3888 if (op0
== TREE_OPERAND (exp
, 0) && op1
== TREE_OPERAND (exp
, 1)
3889 && op2
== TREE_OPERAND (exp
, 2))
3892 new_tree
= fold_build3 (code
, TREE_TYPE (exp
), op0
, op1
, op2
);
3896 op0
= SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp
, 0), f
, r
);
3897 op1
= SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp
, 1), f
, r
);
3898 op2
= SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp
, 2), f
, r
);
3899 op3
= SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp
, 3), f
, r
);
3901 if (op0
== TREE_OPERAND (exp
, 0) && op1
== TREE_OPERAND (exp
, 1)
3902 && op2
== TREE_OPERAND (exp
, 2)
3903 && op3
== TREE_OPERAND (exp
, 3))
3907 = fold (build4 (code
, TREE_TYPE (exp
), op0
, op1
, op2
, op3
));
3919 new_tree
= NULL_TREE
;
3921 /* If we are trying to replace F with a constant or with another
3922 instance of one of the arguments of the call, inline back
3923 functions which do nothing else than computing a value from
3924 the arguments they are passed. This makes it possible to
3925 fold partially or entirely the replacement expression. */
3926 if (code
== CALL_EXPR
)
3928 bool maybe_inline
= false;
3929 if (CONSTANT_CLASS_P (r
))
3930 maybe_inline
= true;
3932 for (i
= 3; i
< TREE_OPERAND_LENGTH (exp
); i
++)
3933 if (operand_equal_p (TREE_OPERAND (exp
, i
), r
, 0))
3935 maybe_inline
= true;
3940 tree t
= maybe_inline_call_in_expr (exp
);
3942 return SUBSTITUTE_IN_EXPR (t
, f
, r
);
3946 for (i
= 1; i
< TREE_OPERAND_LENGTH (exp
); i
++)
3948 tree op
= TREE_OPERAND (exp
, i
);
3949 tree new_op
= SUBSTITUTE_IN_EXPR (op
, f
, r
);
3953 new_tree
= copy_node (exp
);
3954 TREE_OPERAND (new_tree
, i
) = new_op
;
3960 new_tree
= fold (new_tree
);
3961 if (TREE_CODE (new_tree
) == CALL_EXPR
)
3962 process_call_operands (new_tree
);
3973 TREE_READONLY (new_tree
) |= TREE_READONLY (exp
);
3975 if (code
== INDIRECT_REF
|| code
== ARRAY_REF
|| code
== ARRAY_RANGE_REF
)
3976 TREE_THIS_NOTRAP (new_tree
) |= TREE_THIS_NOTRAP (exp
);
3981 /* Similar, but look for a PLACEHOLDER_EXPR in EXP and find a replacement
3982 for it within OBJ, a tree that is an object or a chain of references. */
3985 substitute_placeholder_in_expr (tree exp
, tree obj
)
3987 enum tree_code code
= TREE_CODE (exp
);
3988 tree op0
, op1
, op2
, op3
;
3991 /* If this is a PLACEHOLDER_EXPR, see if we find a corresponding type
3992 in the chain of OBJ. */
3993 if (code
== PLACEHOLDER_EXPR
)
3995 tree need_type
= TYPE_MAIN_VARIANT (TREE_TYPE (exp
));
3998 for (elt
= obj
; elt
!= 0;
3999 elt
= ((TREE_CODE (elt
) == COMPOUND_EXPR
4000 || TREE_CODE (elt
) == COND_EXPR
)
4001 ? TREE_OPERAND (elt
, 1)
4002 : (REFERENCE_CLASS_P (elt
)
4003 || UNARY_CLASS_P (elt
)
4004 || BINARY_CLASS_P (elt
)
4005 || VL_EXP_CLASS_P (elt
)
4006 || EXPRESSION_CLASS_P (elt
))
4007 ? TREE_OPERAND (elt
, 0) : 0))
4008 if (TYPE_MAIN_VARIANT (TREE_TYPE (elt
)) == need_type
)
4011 for (elt
= obj
; elt
!= 0;
4012 elt
= ((TREE_CODE (elt
) == COMPOUND_EXPR
4013 || TREE_CODE (elt
) == COND_EXPR
)
4014 ? TREE_OPERAND (elt
, 1)
4015 : (REFERENCE_CLASS_P (elt
)
4016 || UNARY_CLASS_P (elt
)
4017 || BINARY_CLASS_P (elt
)
4018 || VL_EXP_CLASS_P (elt
)
4019 || EXPRESSION_CLASS_P (elt
))
4020 ? TREE_OPERAND (elt
, 0) : 0))
4021 if (POINTER_TYPE_P (TREE_TYPE (elt
))
4022 && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (elt
)))
4024 return fold_build1 (INDIRECT_REF
, need_type
, elt
);
4026 /* If we didn't find it, return the original PLACEHOLDER_EXPR. If it
4027 survives until RTL generation, there will be an error. */
4031 /* TREE_LIST is special because we need to look at TREE_VALUE
4032 and TREE_CHAIN, not TREE_OPERANDS. */
4033 else if (code
== TREE_LIST
)
4035 op0
= SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_CHAIN (exp
), obj
);
4036 op1
= SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_VALUE (exp
), obj
);
4037 if (op0
== TREE_CHAIN (exp
) && op1
== TREE_VALUE (exp
))
4040 return tree_cons (TREE_PURPOSE (exp
), op1
, op0
);
4043 switch (TREE_CODE_CLASS (code
))
4046 case tcc_declaration
:
4049 case tcc_exceptional
:
4052 case tcc_comparison
:
4053 case tcc_expression
:
4056 switch (TREE_CODE_LENGTH (code
))
4062 op0
= SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp
, 0), obj
);
4063 if (op0
== TREE_OPERAND (exp
, 0))
4066 new_tree
= fold_build1 (code
, TREE_TYPE (exp
), op0
);
4070 op0
= SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp
, 0), obj
);
4071 op1
= SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp
, 1), obj
);
4073 if (op0
== TREE_OPERAND (exp
, 0) && op1
== TREE_OPERAND (exp
, 1))
4076 new_tree
= fold_build2 (code
, TREE_TYPE (exp
), op0
, op1
);
4080 op0
= SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp
, 0), obj
);
4081 op1
= SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp
, 1), obj
);
4082 op2
= SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp
, 2), obj
);
4084 if (op0
== TREE_OPERAND (exp
, 0) && op1
== TREE_OPERAND (exp
, 1)
4085 && op2
== TREE_OPERAND (exp
, 2))
4088 new_tree
= fold_build3 (code
, TREE_TYPE (exp
), op0
, op1
, op2
);
4092 op0
= SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp
, 0), obj
);
4093 op1
= SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp
, 1), obj
);
4094 op2
= SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp
, 2), obj
);
4095 op3
= SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp
, 3), obj
);
4097 if (op0
== TREE_OPERAND (exp
, 0) && op1
== TREE_OPERAND (exp
, 1)
4098 && op2
== TREE_OPERAND (exp
, 2)
4099 && op3
== TREE_OPERAND (exp
, 3))
4103 = fold (build4 (code
, TREE_TYPE (exp
), op0
, op1
, op2
, op3
));
4115 new_tree
= NULL_TREE
;
4117 for (i
= 1; i
< TREE_OPERAND_LENGTH (exp
); i
++)
4119 tree op
= TREE_OPERAND (exp
, i
);
4120 tree new_op
= SUBSTITUTE_PLACEHOLDER_IN_EXPR (op
, obj
);
4124 new_tree
= copy_node (exp
);
4125 TREE_OPERAND (new_tree
, i
) = new_op
;
4131 new_tree
= fold (new_tree
);
4132 if (TREE_CODE (new_tree
) == CALL_EXPR
)
4133 process_call_operands (new_tree
);
4144 TREE_READONLY (new_tree
) |= TREE_READONLY (exp
);
4146 if (code
== INDIRECT_REF
|| code
== ARRAY_REF
|| code
== ARRAY_RANGE_REF
)
4147 TREE_THIS_NOTRAP (new_tree
) |= TREE_THIS_NOTRAP (exp
);
4153 /* Subroutine of stabilize_reference; this is called for subtrees of
4154 references. Any expression with side-effects must be put in a SAVE_EXPR
4155 to ensure that it is only evaluated once.
4157 We don't put SAVE_EXPR nodes around everything, because assigning very
4158 simple expressions to temporaries causes us to miss good opportunities
4159 for optimizations. Among other things, the opportunity to fold in the
4160 addition of a constant into an addressing mode often gets lost, e.g.
4161 "y[i+1] += x;". In general, we take the approach that we should not make
4162 an assignment unless we are forced into it - i.e., that any non-side effect
4163 operator should be allowed, and that cse should take care of coalescing
4164 multiple utterances of the same expression should that prove fruitful. */
4167 stabilize_reference_1 (tree e
)
4170 enum tree_code code
= TREE_CODE (e
);
4172 /* We cannot ignore const expressions because it might be a reference
4173 to a const array but whose index contains side-effects. But we can
4174 ignore things that are actual constant or that already have been
4175 handled by this function. */
4177 if (tree_invariant_p (e
))
4180 switch (TREE_CODE_CLASS (code
))
4182 case tcc_exceptional
:
4184 case tcc_declaration
:
4185 case tcc_comparison
:
4187 case tcc_expression
:
4190 /* If the expression has side-effects, then encase it in a SAVE_EXPR
4191 so that it will only be evaluated once. */
4192 /* The reference (r) and comparison (<) classes could be handled as
4193 below, but it is generally faster to only evaluate them once. */
4194 if (TREE_SIDE_EFFECTS (e
))
4195 return save_expr (e
);
4199 /* Constants need no processing. In fact, we should never reach
4204 /* Division is slow and tends to be compiled with jumps,
4205 especially the division by powers of 2 that is often
4206 found inside of an array reference. So do it just once. */
4207 if (code
== TRUNC_DIV_EXPR
|| code
== TRUNC_MOD_EXPR
4208 || code
== FLOOR_DIV_EXPR
|| code
== FLOOR_MOD_EXPR
4209 || code
== CEIL_DIV_EXPR
|| code
== CEIL_MOD_EXPR
4210 || code
== ROUND_DIV_EXPR
|| code
== ROUND_MOD_EXPR
)
4211 return save_expr (e
);
4212 /* Recursively stabilize each operand. */
4213 result
= build_nt (code
, stabilize_reference_1 (TREE_OPERAND (e
, 0)),
4214 stabilize_reference_1 (TREE_OPERAND (e
, 1)));
4218 /* Recursively stabilize each operand. */
4219 result
= build_nt (code
, stabilize_reference_1 (TREE_OPERAND (e
, 0)));
4226 TREE_TYPE (result
) = TREE_TYPE (e
);
4227 TREE_READONLY (result
) = TREE_READONLY (e
);
4228 TREE_SIDE_EFFECTS (result
) = TREE_SIDE_EFFECTS (e
);
4229 TREE_THIS_VOLATILE (result
) = TREE_THIS_VOLATILE (e
);
4234 /* Stabilize a reference so that we can use it any number of times
4235 without causing its operands to be evaluated more than once.
4236 Returns the stabilized reference. This works by means of save_expr,
4237 so see the caveats in the comments about save_expr.
4239 Also allows conversion expressions whose operands are references.
4240 Any other kind of expression is returned unchanged. */
4243 stabilize_reference (tree ref
)
4246 enum tree_code code
= TREE_CODE (ref
);
4253 /* No action is needed in this case. */
4258 case FIX_TRUNC_EXPR
:
4259 result
= build_nt (code
, stabilize_reference (TREE_OPERAND (ref
, 0)));
4263 result
= build_nt (INDIRECT_REF
,
4264 stabilize_reference_1 (TREE_OPERAND (ref
, 0)));
4268 result
= build_nt (COMPONENT_REF
,
4269 stabilize_reference (TREE_OPERAND (ref
, 0)),
4270 TREE_OPERAND (ref
, 1), NULL_TREE
);
4274 result
= build_nt (BIT_FIELD_REF
,
4275 stabilize_reference (TREE_OPERAND (ref
, 0)),
4276 TREE_OPERAND (ref
, 1), TREE_OPERAND (ref
, 2));
4277 REF_REVERSE_STORAGE_ORDER (result
) = REF_REVERSE_STORAGE_ORDER (ref
);
4281 result
= build_nt (ARRAY_REF
,
4282 stabilize_reference (TREE_OPERAND (ref
, 0)),
4283 stabilize_reference_1 (TREE_OPERAND (ref
, 1)),
4284 TREE_OPERAND (ref
, 2), TREE_OPERAND (ref
, 3));
4287 case ARRAY_RANGE_REF
:
4288 result
= build_nt (ARRAY_RANGE_REF
,
4289 stabilize_reference (TREE_OPERAND (ref
, 0)),
4290 stabilize_reference_1 (TREE_OPERAND (ref
, 1)),
4291 TREE_OPERAND (ref
, 2), TREE_OPERAND (ref
, 3));
4295 /* We cannot wrap the first expression in a SAVE_EXPR, as then
4296 it wouldn't be ignored. This matters when dealing with
4298 return stabilize_reference_1 (ref
);
4300 /* If arg isn't a kind of lvalue we recognize, make no change.
4301 Caller should recognize the error for an invalid lvalue. */
4306 return error_mark_node
;
4309 TREE_TYPE (result
) = TREE_TYPE (ref
);
4310 TREE_READONLY (result
) = TREE_READONLY (ref
);
4311 TREE_SIDE_EFFECTS (result
) = TREE_SIDE_EFFECTS (ref
);
4312 TREE_THIS_VOLATILE (result
) = TREE_THIS_VOLATILE (ref
);
4317 /* Low-level constructors for expressions. */
4319 /* A helper function for build1 and constant folders. Set TREE_CONSTANT,
4320 and TREE_SIDE_EFFECTS for an ADDR_EXPR. */
4323 recompute_tree_invariant_for_addr_expr (tree t
)
4326 bool tc
= true, se
= false;
4328 gcc_assert (TREE_CODE (t
) == ADDR_EXPR
);
4330 /* We started out assuming this address is both invariant and constant, but
4331 does not have side effects. Now go down any handled components and see if
4332 any of them involve offsets that are either non-constant or non-invariant.
4333 Also check for side-effects.
4335 ??? Note that this code makes no attempt to deal with the case where
4336 taking the address of something causes a copy due to misalignment. */
4338 #define UPDATE_FLAGS(NODE) \
4339 do { tree _node = (NODE); \
4340 if (_node && !TREE_CONSTANT (_node)) tc = false; \
4341 if (_node && TREE_SIDE_EFFECTS (_node)) se = true; } while (0)
4343 for (node
= TREE_OPERAND (t
, 0); handled_component_p (node
);
4344 node
= TREE_OPERAND (node
, 0))
4346 /* If the first operand doesn't have an ARRAY_TYPE, this is a bogus
4347 array reference (probably made temporarily by the G++ front end),
4348 so ignore all the operands. */
4349 if ((TREE_CODE (node
) == ARRAY_REF
4350 || TREE_CODE (node
) == ARRAY_RANGE_REF
)
4351 && TREE_CODE (TREE_TYPE (TREE_OPERAND (node
, 0))) == ARRAY_TYPE
)
4353 UPDATE_FLAGS (TREE_OPERAND (node
, 1));
4354 if (TREE_OPERAND (node
, 2))
4355 UPDATE_FLAGS (TREE_OPERAND (node
, 2));
4356 if (TREE_OPERAND (node
, 3))
4357 UPDATE_FLAGS (TREE_OPERAND (node
, 3));
4359 /* Likewise, just because this is a COMPONENT_REF doesn't mean we have a
4360 FIELD_DECL, apparently. The G++ front end can put something else
4361 there, at least temporarily. */
4362 else if (TREE_CODE (node
) == COMPONENT_REF
4363 && TREE_CODE (TREE_OPERAND (node
, 1)) == FIELD_DECL
)
4365 if (TREE_OPERAND (node
, 2))
4366 UPDATE_FLAGS (TREE_OPERAND (node
, 2));
4370 node
= lang_hooks
.expr_to_decl (node
, &tc
, &se
);
4372 /* Now see what's inside. If it's an INDIRECT_REF, copy our properties from
4373 the address, since &(*a)->b is a form of addition. If it's a constant, the
4374 address is constant too. If it's a decl, its address is constant if the
4375 decl is static. Everything else is not constant and, furthermore,
4376 taking the address of a volatile variable is not volatile. */
4377 if (TREE_CODE (node
) == INDIRECT_REF
4378 || TREE_CODE (node
) == MEM_REF
)
4379 UPDATE_FLAGS (TREE_OPERAND (node
, 0));
4380 else if (CONSTANT_CLASS_P (node
))
4382 else if (DECL_P (node
))
4383 tc
&= (staticp (node
) != NULL_TREE
);
4387 se
|= TREE_SIDE_EFFECTS (node
);
4391 TREE_CONSTANT (t
) = tc
;
4392 TREE_SIDE_EFFECTS (t
) = se
;
4396 /* Build an expression of code CODE, data type TYPE, and operands as
4397 specified. Expressions and reference nodes can be created this way.
4398 Constants, decls, types and misc nodes cannot be.
4400 We define 5 non-variadic functions, from 0 to 4 arguments. This is
4401 enough for all extant tree codes. */
4404 build0 (enum tree_code code
, tree tt MEM_STAT_DECL
)
4408 gcc_assert (TREE_CODE_LENGTH (code
) == 0);
4410 t
= make_node (code PASS_MEM_STAT
);
4417 build1 (enum tree_code code
, tree type
, tree node MEM_STAT_DECL
)
4419 int length
= sizeof (struct tree_exp
);
4422 record_node_allocation_statistics (code
, length
);
4424 gcc_assert (TREE_CODE_LENGTH (code
) == 1);
4426 t
= ggc_alloc_tree_node_stat (length PASS_MEM_STAT
);
4428 memset (t
, 0, sizeof (struct tree_common
));
4430 TREE_SET_CODE (t
, code
);
4432 TREE_TYPE (t
) = type
;
4433 SET_EXPR_LOCATION (t
, UNKNOWN_LOCATION
);
4434 TREE_OPERAND (t
, 0) = node
;
4435 if (node
&& !TYPE_P (node
))
4437 TREE_SIDE_EFFECTS (t
) = TREE_SIDE_EFFECTS (node
);
4438 TREE_READONLY (t
) = TREE_READONLY (node
);
4441 if (TREE_CODE_CLASS (code
) == tcc_statement
)
4442 TREE_SIDE_EFFECTS (t
) = 1;
4446 /* All of these have side-effects, no matter what their
4448 TREE_SIDE_EFFECTS (t
) = 1;
4449 TREE_READONLY (t
) = 0;
4453 /* Whether a dereference is readonly has nothing to do with whether
4454 its operand is readonly. */
4455 TREE_READONLY (t
) = 0;
4460 recompute_tree_invariant_for_addr_expr (t
);
4464 if ((TREE_CODE_CLASS (code
) == tcc_unary
|| code
== VIEW_CONVERT_EXPR
)
4465 && node
&& !TYPE_P (node
)
4466 && TREE_CONSTANT (node
))
4467 TREE_CONSTANT (t
) = 1;
4468 if (TREE_CODE_CLASS (code
) == tcc_reference
4469 && node
&& TREE_THIS_VOLATILE (node
))
4470 TREE_THIS_VOLATILE (t
) = 1;
4477 #define PROCESS_ARG(N) \
4479 TREE_OPERAND (t, N) = arg##N; \
4480 if (arg##N &&!TYPE_P (arg##N)) \
4482 if (TREE_SIDE_EFFECTS (arg##N)) \
4484 if (!TREE_READONLY (arg##N) \
4485 && !CONSTANT_CLASS_P (arg##N)) \
4486 (void) (read_only = 0); \
4487 if (!TREE_CONSTANT (arg##N)) \
4488 (void) (constant = 0); \
4493 build2 (enum tree_code code
, tree tt
, tree arg0
, tree arg1 MEM_STAT_DECL
)
4495 bool constant
, read_only
, side_effects
, div_by_zero
;
4498 gcc_assert (TREE_CODE_LENGTH (code
) == 2);
4500 if ((code
== MINUS_EXPR
|| code
== PLUS_EXPR
|| code
== MULT_EXPR
)
4501 && arg0
&& arg1
&& tt
&& POINTER_TYPE_P (tt
)
4502 /* When sizetype precision doesn't match that of pointers
4503 we need to be able to build explicit extensions or truncations
4504 of the offset argument. */
4505 && TYPE_PRECISION (sizetype
) == TYPE_PRECISION (tt
))
4506 gcc_assert (TREE_CODE (arg0
) == INTEGER_CST
4507 && TREE_CODE (arg1
) == INTEGER_CST
);
4509 if (code
== POINTER_PLUS_EXPR
&& arg0
&& arg1
&& tt
)
4510 gcc_assert (POINTER_TYPE_P (tt
) && POINTER_TYPE_P (TREE_TYPE (arg0
))
4511 && ptrofftype_p (TREE_TYPE (arg1
)));
4513 t
= make_node (code PASS_MEM_STAT
);
4516 /* Below, we automatically set TREE_SIDE_EFFECTS and TREE_READONLY for the
4517 result based on those same flags for the arguments. But if the
4518 arguments aren't really even `tree' expressions, we shouldn't be trying
4521 /* Expressions without side effects may be constant if their
4522 arguments are as well. */
4523 constant
= (TREE_CODE_CLASS (code
) == tcc_comparison
4524 || TREE_CODE_CLASS (code
) == tcc_binary
);
4526 side_effects
= TREE_SIDE_EFFECTS (t
);
4530 case TRUNC_DIV_EXPR
:
4532 case FLOOR_DIV_EXPR
:
4533 case ROUND_DIV_EXPR
:
4534 case EXACT_DIV_EXPR
:
4536 case FLOOR_MOD_EXPR
:
4537 case ROUND_MOD_EXPR
:
4538 case TRUNC_MOD_EXPR
:
4539 div_by_zero
= integer_zerop (arg1
);
4542 div_by_zero
= false;
4548 TREE_SIDE_EFFECTS (t
) = side_effects
;
4549 if (code
== MEM_REF
)
4551 if (arg0
&& TREE_CODE (arg0
) == ADDR_EXPR
)
4553 tree o
= TREE_OPERAND (arg0
, 0);
4554 TREE_READONLY (t
) = TREE_READONLY (o
);
4555 TREE_THIS_VOLATILE (t
) = TREE_THIS_VOLATILE (o
);
4560 TREE_READONLY (t
) = read_only
;
4561 /* Don't mark X / 0 as constant. */
4562 TREE_CONSTANT (t
) = constant
&& !div_by_zero
;
4563 TREE_THIS_VOLATILE (t
)
4564 = (TREE_CODE_CLASS (code
) == tcc_reference
4565 && arg0
&& TREE_THIS_VOLATILE (arg0
));
4573 build3 (enum tree_code code
, tree tt
, tree arg0
, tree arg1
,
4574 tree arg2 MEM_STAT_DECL
)
4576 bool constant
, read_only
, side_effects
;
4579 gcc_assert (TREE_CODE_LENGTH (code
) == 3);
4580 gcc_assert (TREE_CODE_CLASS (code
) != tcc_vl_exp
);
4582 t
= make_node (code PASS_MEM_STAT
);
4587 /* As a special exception, if COND_EXPR has NULL branches, we
4588 assume that it is a gimple statement and always consider
4589 it to have side effects. */
4590 if (code
== COND_EXPR
4591 && tt
== void_type_node
4592 && arg1
== NULL_TREE
4593 && arg2
== NULL_TREE
)
4594 side_effects
= true;
4596 side_effects
= TREE_SIDE_EFFECTS (t
);
4602 if (code
== COND_EXPR
)
4603 TREE_READONLY (t
) = read_only
;
4605 TREE_SIDE_EFFECTS (t
) = side_effects
;
4606 TREE_THIS_VOLATILE (t
)
4607 = (TREE_CODE_CLASS (code
) == tcc_reference
4608 && arg0
&& TREE_THIS_VOLATILE (arg0
));
4614 build4 (enum tree_code code
, tree tt
, tree arg0
, tree arg1
,
4615 tree arg2
, tree arg3 MEM_STAT_DECL
)
4617 bool constant
, read_only
, side_effects
;
4620 gcc_assert (TREE_CODE_LENGTH (code
) == 4);
4622 t
= make_node (code PASS_MEM_STAT
);
4625 side_effects
= TREE_SIDE_EFFECTS (t
);
4632 TREE_SIDE_EFFECTS (t
) = side_effects
;
4633 TREE_THIS_VOLATILE (t
)
4634 = (TREE_CODE_CLASS (code
) == tcc_reference
4635 && arg0
&& TREE_THIS_VOLATILE (arg0
));
4641 build5 (enum tree_code code
, tree tt
, tree arg0
, tree arg1
,
4642 tree arg2
, tree arg3
, tree arg4 MEM_STAT_DECL
)
4644 bool constant
, read_only
, side_effects
;
4647 gcc_assert (TREE_CODE_LENGTH (code
) == 5);
4649 t
= make_node (code PASS_MEM_STAT
);
4652 side_effects
= TREE_SIDE_EFFECTS (t
);
4660 TREE_SIDE_EFFECTS (t
) = side_effects
;
4661 if (code
== TARGET_MEM_REF
)
4663 if (arg0
&& TREE_CODE (arg0
) == ADDR_EXPR
)
4665 tree o
= TREE_OPERAND (arg0
, 0);
4666 TREE_READONLY (t
) = TREE_READONLY (o
);
4667 TREE_THIS_VOLATILE (t
) = TREE_THIS_VOLATILE (o
);
4671 TREE_THIS_VOLATILE (t
)
4672 = (TREE_CODE_CLASS (code
) == tcc_reference
4673 && arg0
&& TREE_THIS_VOLATILE (arg0
));
4678 /* Build a simple MEM_REF tree with the sematics of a plain INDIRECT_REF
4679 on the pointer PTR. */
4682 build_simple_mem_ref_loc (location_t loc
, tree ptr
)
4684 HOST_WIDE_INT offset
= 0;
4685 tree ptype
= TREE_TYPE (ptr
);
4687 /* For convenience allow addresses that collapse to a simple base
4689 if (TREE_CODE (ptr
) == ADDR_EXPR
4690 && (handled_component_p (TREE_OPERAND (ptr
, 0))
4691 || TREE_CODE (TREE_OPERAND (ptr
, 0)) == MEM_REF
))
4693 ptr
= get_addr_base_and_unit_offset (TREE_OPERAND (ptr
, 0), &offset
);
4695 ptr
= build_fold_addr_expr (ptr
);
4696 gcc_assert (is_gimple_reg (ptr
) || is_gimple_min_invariant (ptr
));
4698 tem
= build2 (MEM_REF
, TREE_TYPE (ptype
),
4699 ptr
, build_int_cst (ptype
, offset
));
4700 SET_EXPR_LOCATION (tem
, loc
);
4704 /* Return the constant offset of a MEM_REF or TARGET_MEM_REF tree T. */
4707 mem_ref_offset (const_tree t
)
4709 return offset_int::from (wi::to_wide (TREE_OPERAND (t
, 1)), SIGNED
);
4712 /* Return an invariant ADDR_EXPR of type TYPE taking the address of BASE
4713 offsetted by OFFSET units. */
4716 build_invariant_address (tree type
, tree base
, HOST_WIDE_INT offset
)
4718 tree ref
= fold_build2 (MEM_REF
, TREE_TYPE (type
),
4719 build_fold_addr_expr (base
),
4720 build_int_cst (ptr_type_node
, offset
));
4721 tree addr
= build1 (ADDR_EXPR
, type
, ref
);
4722 recompute_tree_invariant_for_addr_expr (addr
);
4726 /* Similar except don't specify the TREE_TYPE
4727 and leave the TREE_SIDE_EFFECTS as 0.
4728 It is permissible for arguments to be null,
4729 or even garbage if their values do not matter. */
4732 build_nt (enum tree_code code
, ...)
4739 gcc_assert (TREE_CODE_CLASS (code
) != tcc_vl_exp
);
4743 t
= make_node (code
);
4744 length
= TREE_CODE_LENGTH (code
);
4746 for (i
= 0; i
< length
; i
++)
4747 TREE_OPERAND (t
, i
) = va_arg (p
, tree
);
4753 /* Similar to build_nt, but for creating a CALL_EXPR object with a
4757 build_nt_call_vec (tree fn
, vec
<tree
, va_gc
> *args
)
4762 ret
= build_vl_exp (CALL_EXPR
, vec_safe_length (args
) + 3);
4763 CALL_EXPR_FN (ret
) = fn
;
4764 CALL_EXPR_STATIC_CHAIN (ret
) = NULL_TREE
;
4765 FOR_EACH_VEC_SAFE_ELT (args
, ix
, t
)
4766 CALL_EXPR_ARG (ret
, ix
) = t
;
4770 /* Create a DECL_... node of code CODE, name NAME and data type TYPE.
4771 We do NOT enter this node in any sort of symbol table.
4773 LOC is the location of the decl.
4775 layout_decl is used to set up the decl's storage layout.
4776 Other slots are initialized to 0 or null pointers. */
4779 build_decl (location_t loc
, enum tree_code code
, tree name
,
4780 tree type MEM_STAT_DECL
)
4784 t
= make_node (code PASS_MEM_STAT
);
4785 DECL_SOURCE_LOCATION (t
) = loc
;
4787 /* if (type == error_mark_node)
4788 type = integer_type_node; */
4789 /* That is not done, deliberately, so that having error_mark_node
4790 as the type can suppress useless errors in the use of this variable. */
4792 DECL_NAME (t
) = name
;
4793 TREE_TYPE (t
) = type
;
4795 if (code
== VAR_DECL
|| code
== PARM_DECL
|| code
== RESULT_DECL
)
4801 /* Builds and returns function declaration with NAME and TYPE. */
4804 build_fn_decl (const char *name
, tree type
)
4806 tree id
= get_identifier (name
);
4807 tree decl
= build_decl (input_location
, FUNCTION_DECL
, id
, type
);
4809 DECL_EXTERNAL (decl
) = 1;
4810 TREE_PUBLIC (decl
) = 1;
4811 DECL_ARTIFICIAL (decl
) = 1;
4812 TREE_NOTHROW (decl
) = 1;
4817 vec
<tree
, va_gc
> *all_translation_units
;
4819 /* Builds a new translation-unit decl with name NAME, queues it in the
4820 global list of translation-unit decls and returns it. */
4823 build_translation_unit_decl (tree name
)
4825 tree tu
= build_decl (UNKNOWN_LOCATION
, TRANSLATION_UNIT_DECL
,
4827 TRANSLATION_UNIT_LANGUAGE (tu
) = lang_hooks
.name
;
4828 vec_safe_push (all_translation_units
, tu
);
4833 /* BLOCK nodes are used to represent the structure of binding contours
4834 and declarations, once those contours have been exited and their contents
4835 compiled. This information is used for outputting debugging info. */
4838 build_block (tree vars
, tree subblocks
, tree supercontext
, tree chain
)
4840 tree block
= make_node (BLOCK
);
4842 BLOCK_VARS (block
) = vars
;
4843 BLOCK_SUBBLOCKS (block
) = subblocks
;
4844 BLOCK_SUPERCONTEXT (block
) = supercontext
;
4845 BLOCK_CHAIN (block
) = chain
;
4850 /* Like SET_EXPR_LOCATION, but make sure the tree can have a location.
4852 LOC is the location to use in tree T. */
4855 protected_set_expr_location (tree t
, location_t loc
)
4857 if (CAN_HAVE_LOCATION_P (t
))
4858 SET_EXPR_LOCATION (t
, loc
);
4861 /* Reset the expression *EXPR_P, a size or position.
4863 ??? We could reset all non-constant sizes or positions. But it's cheap
4864 enough to not do so and refrain from adding workarounds to dwarf2out.c.
4866 We need to reset self-referential sizes or positions because they cannot
4867 be gimplified and thus can contain a CALL_EXPR after the gimplification
4868 is finished, which will run afoul of LTO streaming. And they need to be
4869 reset to something essentially dummy but not constant, so as to preserve
4870 the properties of the object they are attached to. */
4873 free_lang_data_in_one_sizepos (tree
*expr_p
)
4875 tree expr
= *expr_p
;
4876 if (CONTAINS_PLACEHOLDER_P (expr
))
4877 *expr_p
= build0 (PLACEHOLDER_EXPR
, TREE_TYPE (expr
));
4881 /* Reset all the fields in a binfo node BINFO. We only keep
4882 BINFO_VTABLE, which is used by gimple_fold_obj_type_ref. */
4885 free_lang_data_in_binfo (tree binfo
)
4890 gcc_assert (TREE_CODE (binfo
) == TREE_BINFO
);
4892 BINFO_VIRTUALS (binfo
) = NULL_TREE
;
4893 BINFO_BASE_ACCESSES (binfo
) = NULL
;
4894 BINFO_INHERITANCE_CHAIN (binfo
) = NULL_TREE
;
4895 BINFO_SUBVTT_INDEX (binfo
) = NULL_TREE
;
4897 FOR_EACH_VEC_ELT (*BINFO_BASE_BINFOS (binfo
), i
, t
)
4898 free_lang_data_in_binfo (t
);
4902 /* Reset all language specific information still present in TYPE. */
4905 free_lang_data_in_type (tree type
)
4907 gcc_assert (TYPE_P (type
));
4909 /* Give the FE a chance to remove its own data first. */
4910 lang_hooks
.free_lang_data (type
);
4912 TREE_LANG_FLAG_0 (type
) = 0;
4913 TREE_LANG_FLAG_1 (type
) = 0;
4914 TREE_LANG_FLAG_2 (type
) = 0;
4915 TREE_LANG_FLAG_3 (type
) = 0;
4916 TREE_LANG_FLAG_4 (type
) = 0;
4917 TREE_LANG_FLAG_5 (type
) = 0;
4918 TREE_LANG_FLAG_6 (type
) = 0;
4920 if (TREE_CODE (type
) == FUNCTION_TYPE
)
4922 /* Remove the const and volatile qualifiers from arguments. The
4923 C++ front end removes them, but the C front end does not,
4924 leading to false ODR violation errors when merging two
4925 instances of the same function signature compiled by
4926 different front ends. */
4927 for (tree p
= TYPE_ARG_TYPES (type
); p
; p
= TREE_CHAIN (p
))
4929 tree arg_type
= TREE_VALUE (p
);
4931 if (TYPE_READONLY (arg_type
) || TYPE_VOLATILE (arg_type
))
4933 int quals
= TYPE_QUALS (arg_type
)
4935 & ~TYPE_QUAL_VOLATILE
;
4936 TREE_VALUE (p
) = build_qualified_type (arg_type
, quals
);
4937 free_lang_data_in_type (TREE_VALUE (p
));
4939 /* C++ FE uses TREE_PURPOSE to store initial values. */
4940 TREE_PURPOSE (p
) = NULL
;
4943 else if (TREE_CODE (type
) == METHOD_TYPE
)
4944 for (tree p
= TYPE_ARG_TYPES (type
); p
; p
= TREE_CHAIN (p
))
4945 /* C++ FE uses TREE_PURPOSE to store initial values. */
4946 TREE_PURPOSE (p
) = NULL
;
4947 else if (RECORD_OR_UNION_TYPE_P (type
))
4949 /* Remove members that are not FIELD_DECLs (and maybe
4950 TYPE_DECLs) from the field list of an aggregate. These occur
4952 for (tree
*prev
= &TYPE_FIELDS (type
), member
; (member
= *prev
);)
4953 if (TREE_CODE (member
) == FIELD_DECL
4954 || (TREE_CODE (member
) == TYPE_DECL
4955 && !DECL_IGNORED_P (member
)
4956 && debug_info_level
> DINFO_LEVEL_TERSE
4957 && !is_redundant_typedef (member
)))
4958 prev
= &DECL_CHAIN (member
);
4960 *prev
= DECL_CHAIN (member
);
4962 /* FIXME: C FE uses TYPE_VFIELD to record C_TYPE_INCOMPLETE_VARS
4963 and danagle the pointer from time to time. */
4964 if (TYPE_VFIELD (type
) && TREE_CODE (TYPE_VFIELD (type
)) != FIELD_DECL
)
4965 TYPE_VFIELD (type
) = NULL_TREE
;
4967 if (TYPE_BINFO (type
))
4969 free_lang_data_in_binfo (TYPE_BINFO (type
));
4970 /* We need to preserve link to bases and virtual table for all
4971 polymorphic types to make devirtualization machinery working.
4972 Debug output cares only about bases, but output also
4973 virtual table pointers so merging of -fdevirtualize and
4974 -fno-devirtualize units is easier. */
4975 if ((!BINFO_VTABLE (TYPE_BINFO (type
))
4976 || !flag_devirtualize
)
4977 && ((!BINFO_N_BASE_BINFOS (TYPE_BINFO (type
))
4978 && !BINFO_VTABLE (TYPE_BINFO (type
)))
4979 || debug_info_level
!= DINFO_LEVEL_NONE
))
4980 TYPE_BINFO (type
) = NULL
;
4983 else if (INTEGRAL_TYPE_P (type
)
4984 || SCALAR_FLOAT_TYPE_P (type
)
4985 || FIXED_POINT_TYPE_P (type
))
4987 free_lang_data_in_one_sizepos (&TYPE_MIN_VALUE (type
));
4988 free_lang_data_in_one_sizepos (&TYPE_MAX_VALUE (type
));
4991 TYPE_LANG_SLOT_1 (type
) = NULL_TREE
;
4993 free_lang_data_in_one_sizepos (&TYPE_SIZE (type
));
4994 free_lang_data_in_one_sizepos (&TYPE_SIZE_UNIT (type
));
4996 if (TYPE_CONTEXT (type
)
4997 && TREE_CODE (TYPE_CONTEXT (type
)) == BLOCK
)
4999 tree ctx
= TYPE_CONTEXT (type
);
5002 ctx
= BLOCK_SUPERCONTEXT (ctx
);
5004 while (ctx
&& TREE_CODE (ctx
) == BLOCK
);
5005 TYPE_CONTEXT (type
) = ctx
;
5010 /* Return true if DECL may need an assembler name to be set. */
5013 need_assembler_name_p (tree decl
)
5015 /* We use DECL_ASSEMBLER_NAME to hold mangled type names for One Definition
5016 Rule merging. This makes type_odr_p to return true on those types during
5017 LTO and by comparing the mangled name, we can say what types are intended
5018 to be equivalent across compilation unit.
5020 We do not store names of type_in_anonymous_namespace_p.
5022 Record, union and enumeration type have linkage that allows use
5023 to check type_in_anonymous_namespace_p. We do not mangle compound types
5024 that always can be compared structurally.
5026 Similarly for builtin types, we compare properties of their main variant.
5027 A special case are integer types where mangling do make differences
5028 between char/signed char/unsigned char etc. Storing name for these makes
5029 e.g. -fno-signed-char/-fsigned-char mismatches to be handled well.
5030 See cp/mangle.c:write_builtin_type for details. */
5032 if (flag_lto_odr_type_mering
5033 && TREE_CODE (decl
) == TYPE_DECL
5035 && decl
== TYPE_NAME (TREE_TYPE (decl
))
5036 && TYPE_MAIN_VARIANT (TREE_TYPE (decl
)) == TREE_TYPE (decl
)
5037 && !TYPE_ARTIFICIAL (TREE_TYPE (decl
))
5038 && (type_with_linkage_p (TREE_TYPE (decl
))
5039 || TREE_CODE (TREE_TYPE (decl
)) == INTEGER_TYPE
)
5040 && !variably_modified_type_p (TREE_TYPE (decl
), NULL_TREE
))
5041 return !DECL_ASSEMBLER_NAME_SET_P (decl
);
5042 /* Only FUNCTION_DECLs and VAR_DECLs are considered. */
5043 if (!VAR_OR_FUNCTION_DECL_P (decl
))
5046 /* If DECL already has its assembler name set, it does not need a
5048 if (!HAS_DECL_ASSEMBLER_NAME_P (decl
)
5049 || DECL_ASSEMBLER_NAME_SET_P (decl
))
5052 /* Abstract decls do not need an assembler name. */
5053 if (DECL_ABSTRACT_P (decl
))
5056 /* For VAR_DECLs, only static, public and external symbols need an
5059 && !TREE_STATIC (decl
)
5060 && !TREE_PUBLIC (decl
)
5061 && !DECL_EXTERNAL (decl
))
5064 if (TREE_CODE (decl
) == FUNCTION_DECL
)
5066 /* Do not set assembler name on builtins. Allow RTL expansion to
5067 decide whether to expand inline or via a regular call. */
5068 if (DECL_BUILT_IN (decl
)
5069 && DECL_BUILT_IN_CLASS (decl
) != BUILT_IN_FRONTEND
)
5072 /* Functions represented in the callgraph need an assembler name. */
5073 if (cgraph_node::get (decl
) != NULL
)
5076 /* Unused and not public functions don't need an assembler name. */
5077 if (!TREE_USED (decl
) && !TREE_PUBLIC (decl
))
5085 /* Reset all language specific information still present in symbol
5089 free_lang_data_in_decl (tree decl
)
5091 gcc_assert (DECL_P (decl
));
5093 /* Give the FE a chance to remove its own data first. */
5094 lang_hooks
.free_lang_data (decl
);
5096 TREE_LANG_FLAG_0 (decl
) = 0;
5097 TREE_LANG_FLAG_1 (decl
) = 0;
5098 TREE_LANG_FLAG_2 (decl
) = 0;
5099 TREE_LANG_FLAG_3 (decl
) = 0;
5100 TREE_LANG_FLAG_4 (decl
) = 0;
5101 TREE_LANG_FLAG_5 (decl
) = 0;
5102 TREE_LANG_FLAG_6 (decl
) = 0;
5104 free_lang_data_in_one_sizepos (&DECL_SIZE (decl
));
5105 free_lang_data_in_one_sizepos (&DECL_SIZE_UNIT (decl
));
5106 if (TREE_CODE (decl
) == FIELD_DECL
)
5108 free_lang_data_in_one_sizepos (&DECL_FIELD_OFFSET (decl
));
5109 if (TREE_CODE (DECL_CONTEXT (decl
)) == QUAL_UNION_TYPE
)
5110 DECL_QUALIFIER (decl
) = NULL_TREE
;
5113 if (TREE_CODE (decl
) == FUNCTION_DECL
)
5115 struct cgraph_node
*node
;
5116 if (!(node
= cgraph_node::get (decl
))
5117 || (!node
->definition
&& !node
->clones
))
5120 node
->release_body ();
5123 release_function_body (decl
);
5124 DECL_ARGUMENTS (decl
) = NULL
;
5125 DECL_RESULT (decl
) = NULL
;
5126 DECL_INITIAL (decl
) = error_mark_node
;
5129 if (gimple_has_body_p (decl
) || (node
&& node
->thunk
.thunk_p
))
5133 /* If DECL has a gimple body, then the context for its
5134 arguments must be DECL. Otherwise, it doesn't really
5135 matter, as we will not be emitting any code for DECL. In
5136 general, there may be other instances of DECL created by
5137 the front end and since PARM_DECLs are generally shared,
5138 their DECL_CONTEXT changes as the replicas of DECL are
5139 created. The only time where DECL_CONTEXT is important
5140 is for the FUNCTION_DECLs that have a gimple body (since
5141 the PARM_DECL will be used in the function's body). */
5142 for (t
= DECL_ARGUMENTS (decl
); t
; t
= TREE_CHAIN (t
))
5143 DECL_CONTEXT (t
) = decl
;
5144 if (!DECL_FUNCTION_SPECIFIC_TARGET (decl
))
5145 DECL_FUNCTION_SPECIFIC_TARGET (decl
)
5146 = target_option_default_node
;
5147 if (!DECL_FUNCTION_SPECIFIC_OPTIMIZATION (decl
))
5148 DECL_FUNCTION_SPECIFIC_OPTIMIZATION (decl
)
5149 = optimization_default_node
;
5152 /* DECL_SAVED_TREE holds the GENERIC representation for DECL.
5153 At this point, it is not needed anymore. */
5154 DECL_SAVED_TREE (decl
) = NULL_TREE
;
5156 /* Clear the abstract origin if it refers to a method.
5157 Otherwise dwarf2out.c will ICE as we splice functions out of
5158 TYPE_FIELDS and thus the origin will not be output
5160 if (DECL_ABSTRACT_ORIGIN (decl
)
5161 && DECL_CONTEXT (DECL_ABSTRACT_ORIGIN (decl
))
5162 && RECORD_OR_UNION_TYPE_P
5163 (DECL_CONTEXT (DECL_ABSTRACT_ORIGIN (decl
))))
5164 DECL_ABSTRACT_ORIGIN (decl
) = NULL_TREE
;
5166 /* Sometimes the C++ frontend doesn't manage to transform a temporary
5167 DECL_VINDEX referring to itself into a vtable slot number as it
5168 should. Happens with functions that are copied and then forgotten
5169 about. Just clear it, it won't matter anymore. */
5170 if (DECL_VINDEX (decl
) && !tree_fits_shwi_p (DECL_VINDEX (decl
)))
5171 DECL_VINDEX (decl
) = NULL_TREE
;
5173 else if (VAR_P (decl
))
5175 if ((DECL_EXTERNAL (decl
)
5176 && (!TREE_STATIC (decl
) || !TREE_READONLY (decl
)))
5177 || (decl_function_context (decl
) && !TREE_STATIC (decl
)))
5178 DECL_INITIAL (decl
) = NULL_TREE
;
5180 else if (TREE_CODE (decl
) == TYPE_DECL
)
5182 DECL_VISIBILITY (decl
) = VISIBILITY_DEFAULT
;
5183 DECL_VISIBILITY_SPECIFIED (decl
) = 0;
5184 DECL_INITIAL (decl
) = NULL_TREE
;
5186 else if (TREE_CODE (decl
) == FIELD_DECL
)
5187 DECL_INITIAL (decl
) = NULL_TREE
;
5188 else if (TREE_CODE (decl
) == TRANSLATION_UNIT_DECL
5189 && DECL_INITIAL (decl
)
5190 && TREE_CODE (DECL_INITIAL (decl
)) == BLOCK
)
5192 /* Strip builtins from the translation-unit BLOCK. We still have targets
5193 without builtin_decl_explicit support and also builtins are shared
5194 nodes and thus we can't use TREE_CHAIN in multiple lists. */
5195 tree
*nextp
= &BLOCK_VARS (DECL_INITIAL (decl
));
5199 if (TREE_CODE (var
) == FUNCTION_DECL
5200 && DECL_BUILT_IN (var
))
5201 *nextp
= TREE_CHAIN (var
);
5203 nextp
= &TREE_CHAIN (var
);
5209 /* Data used when collecting DECLs and TYPEs for language data removal. */
5211 struct free_lang_data_d
5213 free_lang_data_d () : decls (100), types (100) {}
5215 /* Worklist to avoid excessive recursion. */
5216 auto_vec
<tree
> worklist
;
5218 /* Set of traversed objects. Used to avoid duplicate visits. */
5219 hash_set
<tree
> pset
;
5221 /* Array of symbols to process with free_lang_data_in_decl. */
5222 auto_vec
<tree
> decls
;
5224 /* Array of types to process with free_lang_data_in_type. */
5225 auto_vec
<tree
> types
;
5229 /* Save all language fields needed to generate proper debug information
5230 for DECL. This saves most fields cleared out by free_lang_data_in_decl. */
5233 save_debug_info_for_decl (tree t
)
5235 /*struct saved_debug_info_d *sdi;*/
5237 gcc_assert (debug_info_level
> DINFO_LEVEL_TERSE
&& t
&& DECL_P (t
));
5239 /* FIXME. Partial implementation for saving debug info removed. */
5243 /* Save all language fields needed to generate proper debug information
5244 for TYPE. This saves most fields cleared out by free_lang_data_in_type. */
5247 save_debug_info_for_type (tree t
)
5249 /*struct saved_debug_info_d *sdi;*/
5251 gcc_assert (debug_info_level
> DINFO_LEVEL_TERSE
&& t
&& TYPE_P (t
));
5253 /* FIXME. Partial implementation for saving debug info removed. */
5257 /* Add type or decl T to one of the list of tree nodes that need their
5258 language data removed. The lists are held inside FLD. */
5261 add_tree_to_fld_list (tree t
, struct free_lang_data_d
*fld
)
5265 fld
->decls
.safe_push (t
);
5266 if (debug_info_level
> DINFO_LEVEL_TERSE
)
5267 save_debug_info_for_decl (t
);
5269 else if (TYPE_P (t
))
5271 fld
->types
.safe_push (t
);
5272 if (debug_info_level
> DINFO_LEVEL_TERSE
)
5273 save_debug_info_for_type (t
);
5279 /* Push tree node T into FLD->WORKLIST. */
5282 fld_worklist_push (tree t
, struct free_lang_data_d
*fld
)
5284 if (t
&& !is_lang_specific (t
) && !fld
->pset
.contains (t
))
5285 fld
->worklist
.safe_push ((t
));
5289 /* Operand callback helper for free_lang_data_in_node. *TP is the
5290 subtree operand being considered. */
5293 find_decls_types_r (tree
*tp
, int *ws
, void *data
)
5296 struct free_lang_data_d
*fld
= (struct free_lang_data_d
*) data
;
5298 if (TREE_CODE (t
) == TREE_LIST
)
5301 /* Language specific nodes will be removed, so there is no need
5302 to gather anything under them. */
5303 if (is_lang_specific (t
))
5311 /* Note that walk_tree does not traverse every possible field in
5312 decls, so we have to do our own traversals here. */
5313 add_tree_to_fld_list (t
, fld
);
5315 fld_worklist_push (DECL_NAME (t
), fld
);
5316 fld_worklist_push (DECL_CONTEXT (t
), fld
);
5317 fld_worklist_push (DECL_SIZE (t
), fld
);
5318 fld_worklist_push (DECL_SIZE_UNIT (t
), fld
);
5320 /* We are going to remove everything under DECL_INITIAL for
5321 TYPE_DECLs. No point walking them. */
5322 if (TREE_CODE (t
) != TYPE_DECL
)
5323 fld_worklist_push (DECL_INITIAL (t
), fld
);
5325 fld_worklist_push (DECL_ATTRIBUTES (t
), fld
);
5326 fld_worklist_push (DECL_ABSTRACT_ORIGIN (t
), fld
);
5328 if (TREE_CODE (t
) == FUNCTION_DECL
)
5330 fld_worklist_push (DECL_ARGUMENTS (t
), fld
);
5331 fld_worklist_push (DECL_RESULT (t
), fld
);
5333 else if (TREE_CODE (t
) == TYPE_DECL
)
5335 fld_worklist_push (DECL_ORIGINAL_TYPE (t
), fld
);
5337 else if (TREE_CODE (t
) == FIELD_DECL
)
5339 fld_worklist_push (DECL_FIELD_OFFSET (t
), fld
);
5340 fld_worklist_push (DECL_BIT_FIELD_TYPE (t
), fld
);
5341 fld_worklist_push (DECL_FIELD_BIT_OFFSET (t
), fld
);
5342 fld_worklist_push (DECL_FCONTEXT (t
), fld
);
5345 if ((VAR_P (t
) || TREE_CODE (t
) == PARM_DECL
)
5346 && DECL_HAS_VALUE_EXPR_P (t
))
5347 fld_worklist_push (DECL_VALUE_EXPR (t
), fld
);
5349 if (TREE_CODE (t
) != FIELD_DECL
5350 && TREE_CODE (t
) != TYPE_DECL
)
5351 fld_worklist_push (TREE_CHAIN (t
), fld
);
5354 else if (TYPE_P (t
))
5356 /* Note that walk_tree does not traverse every possible field in
5357 types, so we have to do our own traversals here. */
5358 add_tree_to_fld_list (t
, fld
);
5360 if (!RECORD_OR_UNION_TYPE_P (t
))
5361 fld_worklist_push (TYPE_CACHED_VALUES (t
), fld
);
5362 fld_worklist_push (TYPE_SIZE (t
), fld
);
5363 fld_worklist_push (TYPE_SIZE_UNIT (t
), fld
);
5364 fld_worklist_push (TYPE_ATTRIBUTES (t
), fld
);
5365 fld_worklist_push (TYPE_POINTER_TO (t
), fld
);
5366 fld_worklist_push (TYPE_REFERENCE_TO (t
), fld
);
5367 fld_worklist_push (TYPE_NAME (t
), fld
);
5368 /* Do not walk TYPE_NEXT_PTR_TO or TYPE_NEXT_REF_TO. We do not stream
5369 them and thus do not and want not to reach unused pointer types
5371 if (!POINTER_TYPE_P (t
))
5372 fld_worklist_push (TYPE_MIN_VALUE_RAW (t
), fld
);
5373 /* TYPE_MAX_VALUE_RAW is TYPE_BINFO for record types. */
5374 if (!RECORD_OR_UNION_TYPE_P (t
))
5375 fld_worklist_push (TYPE_MAX_VALUE_RAW (t
), fld
);
5376 fld_worklist_push (TYPE_MAIN_VARIANT (t
), fld
);
5377 /* Do not walk TYPE_NEXT_VARIANT. We do not stream it and thus
5378 do not and want not to reach unused variants this way. */
5379 if (TYPE_CONTEXT (t
))
5381 tree ctx
= TYPE_CONTEXT (t
);
5382 /* We adjust BLOCK TYPE_CONTEXTs to the innermost non-BLOCK one.
5383 So push that instead. */
5384 while (ctx
&& TREE_CODE (ctx
) == BLOCK
)
5385 ctx
= BLOCK_SUPERCONTEXT (ctx
);
5386 fld_worklist_push (ctx
, fld
);
5388 /* Do not walk TYPE_CANONICAL. We do not stream it and thus do not
5389 and want not to reach unused types this way. */
5391 if (RECORD_OR_UNION_TYPE_P (t
) && TYPE_BINFO (t
))
5395 FOR_EACH_VEC_ELT (*BINFO_BASE_BINFOS (TYPE_BINFO (t
)), i
, tem
)
5396 fld_worklist_push (TREE_TYPE (tem
), fld
);
5397 fld_worklist_push (BINFO_VIRTUALS (TYPE_BINFO (t
)), fld
);
5399 if (RECORD_OR_UNION_TYPE_P (t
))
5402 /* Push all TYPE_FIELDS - there can be interleaving interesting
5403 and non-interesting things. */
5404 tem
= TYPE_FIELDS (t
);
5407 if (TREE_CODE (tem
) == FIELD_DECL
5408 || (TREE_CODE (tem
) == TYPE_DECL
5409 && !DECL_IGNORED_P (tem
)
5410 && debug_info_level
> DINFO_LEVEL_TERSE
5411 && !is_redundant_typedef (tem
)))
5412 fld_worklist_push (tem
, fld
);
5413 tem
= TREE_CHAIN (tem
);
5417 fld_worklist_push (TYPE_STUB_DECL (t
), fld
);
5420 else if (TREE_CODE (t
) == BLOCK
)
5423 for (tem
= BLOCK_VARS (t
); tem
; tem
= TREE_CHAIN (tem
))
5424 fld_worklist_push (tem
, fld
);
5425 for (tem
= BLOCK_SUBBLOCKS (t
); tem
; tem
= BLOCK_CHAIN (tem
))
5426 fld_worklist_push (tem
, fld
);
5427 fld_worklist_push (BLOCK_ABSTRACT_ORIGIN (t
), fld
);
5430 if (TREE_CODE (t
) != IDENTIFIER_NODE
5431 && CODE_CONTAINS_STRUCT (TREE_CODE (t
), TS_TYPED
))
5432 fld_worklist_push (TREE_TYPE (t
), fld
);
5438 /* Find decls and types in T. */
5441 find_decls_types (tree t
, struct free_lang_data_d
*fld
)
5445 if (!fld
->pset
.contains (t
))
5446 walk_tree (&t
, find_decls_types_r
, fld
, &fld
->pset
);
5447 if (fld
->worklist
.is_empty ())
5449 t
= fld
->worklist
.pop ();
5453 /* Translate all the types in LIST with the corresponding runtime
5457 get_eh_types_for_runtime (tree list
)
5461 if (list
== NULL_TREE
)
5464 head
= build_tree_list (0, lookup_type_for_runtime (TREE_VALUE (list
)));
5466 list
= TREE_CHAIN (list
);
5469 tree n
= build_tree_list (0, lookup_type_for_runtime (TREE_VALUE (list
)));
5470 TREE_CHAIN (prev
) = n
;
5471 prev
= TREE_CHAIN (prev
);
5472 list
= TREE_CHAIN (list
);
5479 /* Find decls and types referenced in EH region R and store them in
5480 FLD->DECLS and FLD->TYPES. */
5483 find_decls_types_in_eh_region (eh_region r
, struct free_lang_data_d
*fld
)
5494 /* The types referenced in each catch must first be changed to the
5495 EH types used at runtime. This removes references to FE types
5497 for (c
= r
->u
.eh_try
.first_catch
; c
; c
= c
->next_catch
)
5499 c
->type_list
= get_eh_types_for_runtime (c
->type_list
);
5500 walk_tree (&c
->type_list
, find_decls_types_r
, fld
, &fld
->pset
);
5505 case ERT_ALLOWED_EXCEPTIONS
:
5506 r
->u
.allowed
.type_list
5507 = get_eh_types_for_runtime (r
->u
.allowed
.type_list
);
5508 walk_tree (&r
->u
.allowed
.type_list
, find_decls_types_r
, fld
, &fld
->pset
);
5511 case ERT_MUST_NOT_THROW
:
5512 walk_tree (&r
->u
.must_not_throw
.failure_decl
,
5513 find_decls_types_r
, fld
, &fld
->pset
);
5519 /* Find decls and types referenced in cgraph node N and store them in
5520 FLD->DECLS and FLD->TYPES. Unlike pass_referenced_vars, this will
5521 look for *every* kind of DECL and TYPE node reachable from N,
5522 including those embedded inside types and decls (i.e,, TYPE_DECLs,
5523 NAMESPACE_DECLs, etc). */
5526 find_decls_types_in_node (struct cgraph_node
*n
, struct free_lang_data_d
*fld
)
5529 struct function
*fn
;
5533 find_decls_types (n
->decl
, fld
);
5535 if (!gimple_has_body_p (n
->decl
))
5538 gcc_assert (current_function_decl
== NULL_TREE
&& cfun
== NULL
);
5540 fn
= DECL_STRUCT_FUNCTION (n
->decl
);
5542 /* Traverse locals. */
5543 FOR_EACH_LOCAL_DECL (fn
, ix
, t
)
5544 find_decls_types (t
, fld
);
5546 /* Traverse EH regions in FN. */
5549 FOR_ALL_EH_REGION_FN (r
, fn
)
5550 find_decls_types_in_eh_region (r
, fld
);
5553 /* Traverse every statement in FN. */
5554 FOR_EACH_BB_FN (bb
, fn
)
5557 gimple_stmt_iterator si
;
5560 for (psi
= gsi_start_phis (bb
); !gsi_end_p (psi
); gsi_next (&psi
))
5562 gphi
*phi
= psi
.phi ();
5564 for (i
= 0; i
< gimple_phi_num_args (phi
); i
++)
5566 tree
*arg_p
= gimple_phi_arg_def_ptr (phi
, i
);
5567 find_decls_types (*arg_p
, fld
);
5571 for (si
= gsi_start_bb (bb
); !gsi_end_p (si
); gsi_next (&si
))
5573 gimple
*stmt
= gsi_stmt (si
);
5575 if (is_gimple_call (stmt
))
5576 find_decls_types (gimple_call_fntype (stmt
), fld
);
5578 for (i
= 0; i
< gimple_num_ops (stmt
); i
++)
5580 tree arg
= gimple_op (stmt
, i
);
5581 find_decls_types (arg
, fld
);
5588 /* Find decls and types referenced in varpool node N and store them in
5589 FLD->DECLS and FLD->TYPES. Unlike pass_referenced_vars, this will
5590 look for *every* kind of DECL and TYPE node reachable from N,
5591 including those embedded inside types and decls (i.e,, TYPE_DECLs,
5592 NAMESPACE_DECLs, etc). */
5595 find_decls_types_in_var (varpool_node
*v
, struct free_lang_data_d
*fld
)
5597 find_decls_types (v
->decl
, fld
);
5600 /* If T needs an assembler name, have one created for it. */
5603 assign_assembler_name_if_needed (tree t
)
5605 if (need_assembler_name_p (t
))
5607 /* When setting DECL_ASSEMBLER_NAME, the C++ mangler may emit
5608 diagnostics that use input_location to show locus
5609 information. The problem here is that, at this point,
5610 input_location is generally anchored to the end of the file
5611 (since the parser is long gone), so we don't have a good
5612 position to pin it to.
5614 To alleviate this problem, this uses the location of T's
5615 declaration. Examples of this are
5616 testsuite/g++.dg/template/cond2.C and
5617 testsuite/g++.dg/template/pr35240.C. */
5618 location_t saved_location
= input_location
;
5619 input_location
= DECL_SOURCE_LOCATION (t
);
5621 decl_assembler_name (t
);
5623 input_location
= saved_location
;
5628 /* Free language specific information for every operand and expression
5629 in every node of the call graph. This process operates in three stages:
5631 1- Every callgraph node and varpool node is traversed looking for
5632 decls and types embedded in them. This is a more exhaustive
5633 search than that done by find_referenced_vars, because it will
5634 also collect individual fields, decls embedded in types, etc.
5636 2- All the decls found are sent to free_lang_data_in_decl.
5638 3- All the types found are sent to free_lang_data_in_type.
5640 The ordering between decls and types is important because
5641 free_lang_data_in_decl sets assembler names, which includes
5642 mangling. So types cannot be freed up until assembler names have
5646 free_lang_data_in_cgraph (void)
5648 struct cgraph_node
*n
;
5650 struct free_lang_data_d fld
;
5655 /* Find decls and types in the body of every function in the callgraph. */
5656 FOR_EACH_FUNCTION (n
)
5657 find_decls_types_in_node (n
, &fld
);
5659 FOR_EACH_VEC_SAFE_ELT (alias_pairs
, i
, p
)
5660 find_decls_types (p
->decl
, &fld
);
5662 /* Find decls and types in every varpool symbol. */
5663 FOR_EACH_VARIABLE (v
)
5664 find_decls_types_in_var (v
, &fld
);
5666 /* Set the assembler name on every decl found. We need to do this
5667 now because free_lang_data_in_decl will invalidate data needed
5668 for mangling. This breaks mangling on interdependent decls. */
5669 FOR_EACH_VEC_ELT (fld
.decls
, i
, t
)
5670 assign_assembler_name_if_needed (t
);
5672 /* Traverse every decl found freeing its language data. */
5673 FOR_EACH_VEC_ELT (fld
.decls
, i
, t
)
5674 free_lang_data_in_decl (t
);
5676 /* Traverse every type found freeing its language data. */
5677 FOR_EACH_VEC_ELT (fld
.types
, i
, t
)
5678 free_lang_data_in_type (t
);
5681 FOR_EACH_VEC_ELT (fld
.types
, i
, t
)
5687 /* Free resources that are used by FE but are not needed once they are done. */
5690 free_lang_data (void)
5694 /* If we are the LTO frontend we have freed lang-specific data already. */
5696 || (!flag_generate_lto
&& !flag_generate_offload
))
5699 /* Provide a dummy TRANSLATION_UNIT_DECL if the FE failed to provide one. */
5700 if (vec_safe_is_empty (all_translation_units
))
5701 build_translation_unit_decl (NULL_TREE
);
5703 /* Allocate and assign alias sets to the standard integer types
5704 while the slots are still in the way the frontends generated them. */
5705 for (i
= 0; i
< itk_none
; ++i
)
5706 if (integer_types
[i
])
5707 TYPE_ALIAS_SET (integer_types
[i
]) = get_alias_set (integer_types
[i
]);
5709 /* Traverse the IL resetting language specific information for
5710 operands, expressions, etc. */
5711 free_lang_data_in_cgraph ();
5713 /* Create gimple variants for common types. */
5714 for (unsigned i
= 0;
5715 i
< sizeof (builtin_structptr_types
) / sizeof (builtin_structptr_type
);
5717 builtin_structptr_types
[i
].node
= builtin_structptr_types
[i
].base
;
5719 /* Reset some langhooks. Do not reset types_compatible_p, it may
5720 still be used indirectly via the get_alias_set langhook. */
5721 lang_hooks
.dwarf_name
= lhd_dwarf_name
;
5722 lang_hooks
.decl_printable_name
= gimple_decl_printable_name
;
5723 lang_hooks
.gimplify_expr
= lhd_gimplify_expr
;
5725 /* We do not want the default decl_assembler_name implementation,
5726 rather if we have fixed everything we want a wrapper around it
5727 asserting that all non-local symbols already got their assembler
5728 name and only produce assembler names for local symbols. Or rather
5729 make sure we never call decl_assembler_name on local symbols and
5730 devise a separate, middle-end private scheme for it. */
5732 /* Reset diagnostic machinery. */
5733 tree_diagnostics_defaults (global_dc
);
5741 const pass_data pass_data_ipa_free_lang_data
=
5743 SIMPLE_IPA_PASS
, /* type */
5744 "*free_lang_data", /* name */
5745 OPTGROUP_NONE
, /* optinfo_flags */
5746 TV_IPA_FREE_LANG_DATA
, /* tv_id */
5747 0, /* properties_required */
5748 0, /* properties_provided */
5749 0, /* properties_destroyed */
5750 0, /* todo_flags_start */
5751 0, /* todo_flags_finish */
5754 class pass_ipa_free_lang_data
: public simple_ipa_opt_pass
5757 pass_ipa_free_lang_data (gcc::context
*ctxt
)
5758 : simple_ipa_opt_pass (pass_data_ipa_free_lang_data
, ctxt
)
5761 /* opt_pass methods: */
5762 virtual unsigned int execute (function
*) { return free_lang_data (); }
5764 }; // class pass_ipa_free_lang_data
5768 simple_ipa_opt_pass
*
5769 make_pass_ipa_free_lang_data (gcc::context
*ctxt
)
5771 return new pass_ipa_free_lang_data (ctxt
);
5774 /* Set the type qualifiers for TYPE to TYPE_QUALS, which is a bitmask
5775 of the various TYPE_QUAL values. */
5778 set_type_quals (tree type
, int type_quals
)
5780 TYPE_READONLY (type
) = (type_quals
& TYPE_QUAL_CONST
) != 0;
5781 TYPE_VOLATILE (type
) = (type_quals
& TYPE_QUAL_VOLATILE
) != 0;
5782 TYPE_RESTRICT (type
) = (type_quals
& TYPE_QUAL_RESTRICT
) != 0;
5783 TYPE_ATOMIC (type
) = (type_quals
& TYPE_QUAL_ATOMIC
) != 0;
5784 TYPE_ADDR_SPACE (type
) = DECODE_QUAL_ADDR_SPACE (type_quals
);
5787 /* Returns true iff CAND and BASE have equivalent language-specific
5791 check_lang_type (const_tree cand
, const_tree base
)
5793 if (lang_hooks
.types
.type_hash_eq
== NULL
)
5795 /* type_hash_eq currently only applies to these types. */
5796 if (TREE_CODE (cand
) != FUNCTION_TYPE
5797 && TREE_CODE (cand
) != METHOD_TYPE
)
5799 return lang_hooks
.types
.type_hash_eq (cand
, base
);
5802 /* Returns true iff unqualified CAND and BASE are equivalent. */
5805 check_base_type (const_tree cand
, const_tree base
)
5807 return (TYPE_NAME (cand
) == TYPE_NAME (base
)
5808 /* Apparently this is needed for Objective-C. */
5809 && TYPE_CONTEXT (cand
) == TYPE_CONTEXT (base
)
5810 /* Check alignment. */
5811 && TYPE_ALIGN (cand
) == TYPE_ALIGN (base
)
5812 && attribute_list_equal (TYPE_ATTRIBUTES (cand
),
5813 TYPE_ATTRIBUTES (base
)));
5816 /* Returns true iff CAND is equivalent to BASE with TYPE_QUALS. */
5819 check_qualified_type (const_tree cand
, const_tree base
, int type_quals
)
5821 return (TYPE_QUALS (cand
) == type_quals
5822 && check_base_type (cand
, base
)
5823 && check_lang_type (cand
, base
));
5826 /* Returns true iff CAND is equivalent to BASE with ALIGN. */
5829 check_aligned_type (const_tree cand
, const_tree base
, unsigned int align
)
5831 return (TYPE_QUALS (cand
) == TYPE_QUALS (base
)
5832 && TYPE_NAME (cand
) == TYPE_NAME (base
)
5833 /* Apparently this is needed for Objective-C. */
5834 && TYPE_CONTEXT (cand
) == TYPE_CONTEXT (base
)
5835 /* Check alignment. */
5836 && TYPE_ALIGN (cand
) == align
5837 && attribute_list_equal (TYPE_ATTRIBUTES (cand
),
5838 TYPE_ATTRIBUTES (base
))
5839 && check_lang_type (cand
, base
));
5842 /* This function checks to see if TYPE matches the size one of the built-in
5843 atomic types, and returns that core atomic type. */
5846 find_atomic_core_type (tree type
)
5848 tree base_atomic_type
;
5850 /* Only handle complete types. */
5851 if (!tree_fits_uhwi_p (TYPE_SIZE (type
)))
5854 switch (tree_to_uhwi (TYPE_SIZE (type
)))
5857 base_atomic_type
= atomicQI_type_node
;
5861 base_atomic_type
= atomicHI_type_node
;
5865 base_atomic_type
= atomicSI_type_node
;
5869 base_atomic_type
= atomicDI_type_node
;
5873 base_atomic_type
= atomicTI_type_node
;
5877 base_atomic_type
= NULL_TREE
;
5880 return base_atomic_type
;
5883 /* Return a version of the TYPE, qualified as indicated by the
5884 TYPE_QUALS, if one exists. If no qualified version exists yet,
5885 return NULL_TREE. */
5888 get_qualified_type (tree type
, int type_quals
)
5892 if (TYPE_QUALS (type
) == type_quals
)
5895 /* Search the chain of variants to see if there is already one there just
5896 like the one we need to have. If so, use that existing one. We must
5897 preserve the TYPE_NAME, since there is code that depends on this. */
5898 for (t
= TYPE_MAIN_VARIANT (type
); t
; t
= TYPE_NEXT_VARIANT (t
))
5899 if (check_qualified_type (t
, type
, type_quals
))
5905 /* Like get_qualified_type, but creates the type if it does not
5906 exist. This function never returns NULL_TREE. */
5909 build_qualified_type (tree type
, int type_quals MEM_STAT_DECL
)
5913 /* See if we already have the appropriate qualified variant. */
5914 t
= get_qualified_type (type
, type_quals
);
5916 /* If not, build it. */
5919 t
= build_variant_type_copy (type PASS_MEM_STAT
);
5920 set_type_quals (t
, type_quals
);
5922 if (((type_quals
& TYPE_QUAL_ATOMIC
) == TYPE_QUAL_ATOMIC
))
5924 /* See if this object can map to a basic atomic type. */
5925 tree atomic_type
= find_atomic_core_type (type
);
5928 /* Ensure the alignment of this type is compatible with
5929 the required alignment of the atomic type. */
5930 if (TYPE_ALIGN (atomic_type
) > TYPE_ALIGN (t
))
5931 SET_TYPE_ALIGN (t
, TYPE_ALIGN (atomic_type
));
5935 if (TYPE_STRUCTURAL_EQUALITY_P (type
))
5936 /* Propagate structural equality. */
5937 SET_TYPE_STRUCTURAL_EQUALITY (t
);
5938 else if (TYPE_CANONICAL (type
) != type
)
5939 /* Build the underlying canonical type, since it is different
5942 tree c
= build_qualified_type (TYPE_CANONICAL (type
), type_quals
);
5943 TYPE_CANONICAL (t
) = TYPE_CANONICAL (c
);
5946 /* T is its own canonical type. */
5947 TYPE_CANONICAL (t
) = t
;
5954 /* Create a variant of type T with alignment ALIGN. */
5957 build_aligned_type (tree type
, unsigned int align
)
5961 if (TYPE_PACKED (type
)
5962 || TYPE_ALIGN (type
) == align
)
5965 for (t
= TYPE_MAIN_VARIANT (type
); t
; t
= TYPE_NEXT_VARIANT (t
))
5966 if (check_aligned_type (t
, type
, align
))
5969 t
= build_variant_type_copy (type
);
5970 SET_TYPE_ALIGN (t
, align
);
5971 TYPE_USER_ALIGN (t
) = 1;
5976 /* Create a new distinct copy of TYPE. The new type is made its own
5977 MAIN_VARIANT. If TYPE requires structural equality checks, the
5978 resulting type requires structural equality checks; otherwise, its
5979 TYPE_CANONICAL points to itself. */
5982 build_distinct_type_copy (tree type MEM_STAT_DECL
)
5984 tree t
= copy_node (type PASS_MEM_STAT
);
5986 TYPE_POINTER_TO (t
) = 0;
5987 TYPE_REFERENCE_TO (t
) = 0;
5989 /* Set the canonical type either to a new equivalence class, or
5990 propagate the need for structural equality checks. */
5991 if (TYPE_STRUCTURAL_EQUALITY_P (type
))
5992 SET_TYPE_STRUCTURAL_EQUALITY (t
);
5994 TYPE_CANONICAL (t
) = t
;
5996 /* Make it its own variant. */
5997 TYPE_MAIN_VARIANT (t
) = t
;
5998 TYPE_NEXT_VARIANT (t
) = 0;
6000 /* Note that it is now possible for TYPE_MIN_VALUE to be a value
6001 whose TREE_TYPE is not t. This can also happen in the Ada
6002 frontend when using subtypes. */
6007 /* Create a new variant of TYPE, equivalent but distinct. This is so
6008 the caller can modify it. TYPE_CANONICAL for the return type will
6009 be equivalent to TYPE_CANONICAL of TYPE, indicating that the types
6010 are considered equal by the language itself (or that both types
6011 require structural equality checks). */
6014 build_variant_type_copy (tree type MEM_STAT_DECL
)
6016 tree t
, m
= TYPE_MAIN_VARIANT (type
);
6018 t
= build_distinct_type_copy (type PASS_MEM_STAT
);
6020 /* Since we're building a variant, assume that it is a non-semantic
6021 variant. This also propagates TYPE_STRUCTURAL_EQUALITY_P. */
6022 TYPE_CANONICAL (t
) = TYPE_CANONICAL (type
);
6023 /* Type variants have no alias set defined. */
6024 TYPE_ALIAS_SET (t
) = -1;
6026 /* Add the new type to the chain of variants of TYPE. */
6027 TYPE_NEXT_VARIANT (t
) = TYPE_NEXT_VARIANT (m
);
6028 TYPE_NEXT_VARIANT (m
) = t
;
6029 TYPE_MAIN_VARIANT (t
) = m
;
6034 /* Return true if the from tree in both tree maps are equal. */
6037 tree_map_base_eq (const void *va
, const void *vb
)
6039 const struct tree_map_base
*const a
= (const struct tree_map_base
*) va
,
6040 *const b
= (const struct tree_map_base
*) vb
;
6041 return (a
->from
== b
->from
);
6044 /* Hash a from tree in a tree_base_map. */
6047 tree_map_base_hash (const void *item
)
6049 return htab_hash_pointer (((const struct tree_map_base
*)item
)->from
);
6052 /* Return true if this tree map structure is marked for garbage collection
6053 purposes. We simply return true if the from tree is marked, so that this
6054 structure goes away when the from tree goes away. */
6057 tree_map_base_marked_p (const void *p
)
6059 return ggc_marked_p (((const struct tree_map_base
*) p
)->from
);
6062 /* Hash a from tree in a tree_map. */
6065 tree_map_hash (const void *item
)
6067 return (((const struct tree_map
*) item
)->hash
);
6070 /* Hash a from tree in a tree_decl_map. */
6073 tree_decl_map_hash (const void *item
)
6075 return DECL_UID (((const struct tree_decl_map
*) item
)->base
.from
);
6078 /* Return the initialization priority for DECL. */
6081 decl_init_priority_lookup (tree decl
)
6083 symtab_node
*snode
= symtab_node::get (decl
);
6086 return DEFAULT_INIT_PRIORITY
;
6088 snode
->get_init_priority ();
6091 /* Return the finalization priority for DECL. */
6094 decl_fini_priority_lookup (tree decl
)
6096 cgraph_node
*node
= cgraph_node::get (decl
);
6099 return DEFAULT_INIT_PRIORITY
;
6101 node
->get_fini_priority ();
6104 /* Set the initialization priority for DECL to PRIORITY. */
6107 decl_init_priority_insert (tree decl
, priority_type priority
)
6109 struct symtab_node
*snode
;
6111 if (priority
== DEFAULT_INIT_PRIORITY
)
6113 snode
= symtab_node::get (decl
);
6117 else if (VAR_P (decl
))
6118 snode
= varpool_node::get_create (decl
);
6120 snode
= cgraph_node::get_create (decl
);
6121 snode
->set_init_priority (priority
);
6124 /* Set the finalization priority for DECL to PRIORITY. */
6127 decl_fini_priority_insert (tree decl
, priority_type priority
)
6129 struct cgraph_node
*node
;
6131 if (priority
== DEFAULT_INIT_PRIORITY
)
6133 node
= cgraph_node::get (decl
);
6138 node
= cgraph_node::get_create (decl
);
6139 node
->set_fini_priority (priority
);
6142 /* Print out the statistics for the DECL_DEBUG_EXPR hash table. */
6145 print_debug_expr_statistics (void)
6147 fprintf (stderr
, "DECL_DEBUG_EXPR hash: size %ld, %ld elements, %f collisions\n",
6148 (long) debug_expr_for_decl
->size (),
6149 (long) debug_expr_for_decl
->elements (),
6150 debug_expr_for_decl
->collisions ());
6153 /* Print out the statistics for the DECL_VALUE_EXPR hash table. */
6156 print_value_expr_statistics (void)
6158 fprintf (stderr
, "DECL_VALUE_EXPR hash: size %ld, %ld elements, %f collisions\n",
6159 (long) value_expr_for_decl
->size (),
6160 (long) value_expr_for_decl
->elements (),
6161 value_expr_for_decl
->collisions ());
6164 /* Lookup a debug expression for FROM, and return it if we find one. */
6167 decl_debug_expr_lookup (tree from
)
6169 struct tree_decl_map
*h
, in
;
6170 in
.base
.from
= from
;
6172 h
= debug_expr_for_decl
->find_with_hash (&in
, DECL_UID (from
));
6178 /* Insert a mapping FROM->TO in the debug expression hashtable. */
6181 decl_debug_expr_insert (tree from
, tree to
)
6183 struct tree_decl_map
*h
;
6185 h
= ggc_alloc
<tree_decl_map
> ();
6186 h
->base
.from
= from
;
6188 *debug_expr_for_decl
->find_slot_with_hash (h
, DECL_UID (from
), INSERT
) = h
;
6191 /* Lookup a value expression for FROM, and return it if we find one. */
6194 decl_value_expr_lookup (tree from
)
6196 struct tree_decl_map
*h
, in
;
6197 in
.base
.from
= from
;
6199 h
= value_expr_for_decl
->find_with_hash (&in
, DECL_UID (from
));
6205 /* Insert a mapping FROM->TO in the value expression hashtable. */
6208 decl_value_expr_insert (tree from
, tree to
)
6210 struct tree_decl_map
*h
;
6212 h
= ggc_alloc
<tree_decl_map
> ();
6213 h
->base
.from
= from
;
6215 *value_expr_for_decl
->find_slot_with_hash (h
, DECL_UID (from
), INSERT
) = h
;
6218 /* Lookup a vector of debug arguments for FROM, and return it if we
6222 decl_debug_args_lookup (tree from
)
6224 struct tree_vec_map
*h
, in
;
6226 if (!DECL_HAS_DEBUG_ARGS_P (from
))
6228 gcc_checking_assert (debug_args_for_decl
!= NULL
);
6229 in
.base
.from
= from
;
6230 h
= debug_args_for_decl
->find_with_hash (&in
, DECL_UID (from
));
6236 /* Insert a mapping FROM->empty vector of debug arguments in the value
6237 expression hashtable. */
6240 decl_debug_args_insert (tree from
)
6242 struct tree_vec_map
*h
;
6245 if (DECL_HAS_DEBUG_ARGS_P (from
))
6246 return decl_debug_args_lookup (from
);
6247 if (debug_args_for_decl
== NULL
)
6248 debug_args_for_decl
= hash_table
<tree_vec_map_cache_hasher
>::create_ggc (64);
6249 h
= ggc_alloc
<tree_vec_map
> ();
6250 h
->base
.from
= from
;
6252 loc
= debug_args_for_decl
->find_slot_with_hash (h
, DECL_UID (from
), INSERT
);
6254 DECL_HAS_DEBUG_ARGS_P (from
) = 1;
6258 /* Hashing of types so that we don't make duplicates.
6259 The entry point is `type_hash_canon'. */
6261 /* Generate the default hash code for TYPE. This is designed for
6262 speed, rather than maximum entropy. */
6265 type_hash_canon_hash (tree type
)
6267 inchash::hash hstate
;
6269 hstate
.add_int (TREE_CODE (type
));
6271 if (TREE_TYPE (type
))
6272 hstate
.add_object (TYPE_HASH (TREE_TYPE (type
)));
6274 for (tree t
= TYPE_ATTRIBUTES (type
); t
; t
= TREE_CHAIN (t
))
6275 /* Just the identifier is adequate to distinguish. */
6276 hstate
.add_object (IDENTIFIER_HASH_VALUE (get_attribute_name (t
)));
6278 switch (TREE_CODE (type
))
6281 hstate
.add_object (TYPE_HASH (TYPE_METHOD_BASETYPE (type
)));
6284 for (tree t
= TYPE_ARG_TYPES (type
); t
; t
= TREE_CHAIN (t
))
6285 if (TREE_VALUE (t
) != error_mark_node
)
6286 hstate
.add_object (TYPE_HASH (TREE_VALUE (t
)));
6290 hstate
.add_object (TYPE_HASH (TYPE_OFFSET_BASETYPE (type
)));
6295 if (TYPE_DOMAIN (type
))
6296 hstate
.add_object (TYPE_HASH (TYPE_DOMAIN (type
)));
6297 if (!AGGREGATE_TYPE_P (TREE_TYPE (type
)))
6299 unsigned typeless
= TYPE_TYPELESS_STORAGE (type
);
6300 hstate
.add_object (typeless
);
6307 tree t
= TYPE_MAX_VALUE (type
);
6309 t
= TYPE_MIN_VALUE (type
);
6310 for (int i
= 0; i
< TREE_INT_CST_NUNITS (t
); i
++)
6311 hstate
.add_object (TREE_INT_CST_ELT (t
, i
));
6316 case FIXED_POINT_TYPE
:
6318 unsigned prec
= TYPE_PRECISION (type
);
6319 hstate
.add_object (prec
);
6325 unsigned nunits
= TYPE_VECTOR_SUBPARTS (type
);
6326 hstate
.add_object (nunits
);
6334 return hstate
.end ();
6337 /* These are the Hashtable callback functions. */
6339 /* Returns true iff the types are equivalent. */
6342 type_cache_hasher::equal (type_hash
*a
, type_hash
*b
)
6344 /* First test the things that are the same for all types. */
6345 if (a
->hash
!= b
->hash
6346 || TREE_CODE (a
->type
) != TREE_CODE (b
->type
)
6347 || TREE_TYPE (a
->type
) != TREE_TYPE (b
->type
)
6348 || !attribute_list_equal (TYPE_ATTRIBUTES (a
->type
),
6349 TYPE_ATTRIBUTES (b
->type
))
6350 || (TREE_CODE (a
->type
) != COMPLEX_TYPE
6351 && TYPE_NAME (a
->type
) != TYPE_NAME (b
->type
)))
6354 /* Be careful about comparing arrays before and after the element type
6355 has been completed; don't compare TYPE_ALIGN unless both types are
6357 if (COMPLETE_TYPE_P (a
->type
) && COMPLETE_TYPE_P (b
->type
)
6358 && (TYPE_ALIGN (a
->type
) != TYPE_ALIGN (b
->type
)
6359 || TYPE_MODE (a
->type
) != TYPE_MODE (b
->type
)))
6362 switch (TREE_CODE (a
->type
))
6367 case REFERENCE_TYPE
:
6372 return TYPE_VECTOR_SUBPARTS (a
->type
) == TYPE_VECTOR_SUBPARTS (b
->type
);
6375 if (TYPE_VALUES (a
->type
) != TYPE_VALUES (b
->type
)
6376 && !(TYPE_VALUES (a
->type
)
6377 && TREE_CODE (TYPE_VALUES (a
->type
)) == TREE_LIST
6378 && TYPE_VALUES (b
->type
)
6379 && TREE_CODE (TYPE_VALUES (b
->type
)) == TREE_LIST
6380 && type_list_equal (TYPE_VALUES (a
->type
),
6381 TYPE_VALUES (b
->type
))))
6389 if (TYPE_PRECISION (a
->type
) != TYPE_PRECISION (b
->type
))
6391 return ((TYPE_MAX_VALUE (a
->type
) == TYPE_MAX_VALUE (b
->type
)
6392 || tree_int_cst_equal (TYPE_MAX_VALUE (a
->type
),
6393 TYPE_MAX_VALUE (b
->type
)))
6394 && (TYPE_MIN_VALUE (a
->type
) == TYPE_MIN_VALUE (b
->type
)
6395 || tree_int_cst_equal (TYPE_MIN_VALUE (a
->type
),
6396 TYPE_MIN_VALUE (b
->type
))));
6398 case FIXED_POINT_TYPE
:
6399 return TYPE_SATURATING (a
->type
) == TYPE_SATURATING (b
->type
);
6402 return TYPE_OFFSET_BASETYPE (a
->type
) == TYPE_OFFSET_BASETYPE (b
->type
);
6405 if (TYPE_METHOD_BASETYPE (a
->type
) == TYPE_METHOD_BASETYPE (b
->type
)
6406 && (TYPE_ARG_TYPES (a
->type
) == TYPE_ARG_TYPES (b
->type
)
6407 || (TYPE_ARG_TYPES (a
->type
)
6408 && TREE_CODE (TYPE_ARG_TYPES (a
->type
)) == TREE_LIST
6409 && TYPE_ARG_TYPES (b
->type
)
6410 && TREE_CODE (TYPE_ARG_TYPES (b
->type
)) == TREE_LIST
6411 && type_list_equal (TYPE_ARG_TYPES (a
->type
),
6412 TYPE_ARG_TYPES (b
->type
)))))
6416 /* Don't compare TYPE_TYPELESS_STORAGE flag on aggregates,
6417 where the flag should be inherited from the element type
6418 and can change after ARRAY_TYPEs are created; on non-aggregates
6419 compare it and hash it, scalars will never have that flag set
6420 and we need to differentiate between arrays created by different
6421 front-ends or middle-end created arrays. */
6422 return (TYPE_DOMAIN (a
->type
) == TYPE_DOMAIN (b
->type
)
6423 && (AGGREGATE_TYPE_P (TREE_TYPE (a
->type
))
6424 || (TYPE_TYPELESS_STORAGE (a
->type
)
6425 == TYPE_TYPELESS_STORAGE (b
->type
))));
6429 case QUAL_UNION_TYPE
:
6430 return (TYPE_FIELDS (a
->type
) == TYPE_FIELDS (b
->type
)
6431 || (TYPE_FIELDS (a
->type
)
6432 && TREE_CODE (TYPE_FIELDS (a
->type
)) == TREE_LIST
6433 && TYPE_FIELDS (b
->type
)
6434 && TREE_CODE (TYPE_FIELDS (b
->type
)) == TREE_LIST
6435 && type_list_equal (TYPE_FIELDS (a
->type
),
6436 TYPE_FIELDS (b
->type
))));
6439 if (TYPE_ARG_TYPES (a
->type
) == TYPE_ARG_TYPES (b
->type
)
6440 || (TYPE_ARG_TYPES (a
->type
)
6441 && TREE_CODE (TYPE_ARG_TYPES (a
->type
)) == TREE_LIST
6442 && TYPE_ARG_TYPES (b
->type
)
6443 && TREE_CODE (TYPE_ARG_TYPES (b
->type
)) == TREE_LIST
6444 && type_list_equal (TYPE_ARG_TYPES (a
->type
),
6445 TYPE_ARG_TYPES (b
->type
))))
6453 if (lang_hooks
.types
.type_hash_eq
!= NULL
)
6454 return lang_hooks
.types
.type_hash_eq (a
->type
, b
->type
);
6459 /* Given TYPE, and HASHCODE its hash code, return the canonical
6460 object for an identical type if one already exists.
6461 Otherwise, return TYPE, and record it as the canonical object.
6463 To use this function, first create a type of the sort you want.
6464 Then compute its hash code from the fields of the type that
6465 make it different from other similar types.
6466 Then call this function and use the value. */
6469 type_hash_canon (unsigned int hashcode
, tree type
)
6474 /* The hash table only contains main variants, so ensure that's what we're
6476 gcc_assert (TYPE_MAIN_VARIANT (type
) == type
);
6478 /* The TYPE_ALIGN field of a type is set by layout_type(), so we
6479 must call that routine before comparing TYPE_ALIGNs. */
6485 loc
= type_hash_table
->find_slot_with_hash (&in
, hashcode
, INSERT
);
6488 tree t1
= ((type_hash
*) *loc
)->type
;
6489 gcc_assert (TYPE_MAIN_VARIANT (t1
) == t1
);
6490 if (TYPE_UID (type
) + 1 == next_type_uid
)
6492 /* Free also min/max values and the cache for integer
6493 types. This can't be done in free_node, as LTO frees
6494 those on its own. */
6495 if (TREE_CODE (type
) == INTEGER_TYPE
)
6497 if (TYPE_MIN_VALUE (type
)
6498 && TREE_TYPE (TYPE_MIN_VALUE (type
)) == type
)
6500 /* Zero is always in TYPE_CACHED_VALUES. */
6501 if (! TYPE_UNSIGNED (type
))
6502 int_cst_hash_table
->remove_elt (TYPE_MIN_VALUE (type
));
6503 ggc_free (TYPE_MIN_VALUE (type
));
6505 if (TYPE_MAX_VALUE (type
)
6506 && TREE_TYPE (TYPE_MAX_VALUE (type
)) == type
)
6508 int_cst_hash_table
->remove_elt (TYPE_MAX_VALUE (type
));
6509 ggc_free (TYPE_MAX_VALUE (type
));
6511 if (TYPE_CACHED_VALUES_P (type
))
6512 ggc_free (TYPE_CACHED_VALUES (type
));
6519 struct type_hash
*h
;
6521 h
= ggc_alloc
<type_hash
> ();
6531 print_type_hash_statistics (void)
6533 fprintf (stderr
, "Type hash: size %ld, %ld elements, %f collisions\n",
6534 (long) type_hash_table
->size (),
6535 (long) type_hash_table
->elements (),
6536 type_hash_table
->collisions ());
6539 /* Given two lists of types
6540 (chains of TREE_LIST nodes with types in the TREE_VALUE slots)
6541 return 1 if the lists contain the same types in the same order.
6542 Also, the TREE_PURPOSEs must match. */
6545 type_list_equal (const_tree l1
, const_tree l2
)
6549 for (t1
= l1
, t2
= l2
; t1
&& t2
; t1
= TREE_CHAIN (t1
), t2
= TREE_CHAIN (t2
))
6550 if (TREE_VALUE (t1
) != TREE_VALUE (t2
)
6551 || (TREE_PURPOSE (t1
) != TREE_PURPOSE (t2
)
6552 && ! (1 == simple_cst_equal (TREE_PURPOSE (t1
), TREE_PURPOSE (t2
))
6553 && (TREE_TYPE (TREE_PURPOSE (t1
))
6554 == TREE_TYPE (TREE_PURPOSE (t2
))))))
6560 /* Returns the number of arguments to the FUNCTION_TYPE or METHOD_TYPE
6561 given by TYPE. If the argument list accepts variable arguments,
6562 then this function counts only the ordinary arguments. */
6565 type_num_arguments (const_tree type
)
6570 for (t
= TYPE_ARG_TYPES (type
); t
; t
= TREE_CHAIN (t
))
6571 /* If the function does not take a variable number of arguments,
6572 the last element in the list will have type `void'. */
6573 if (VOID_TYPE_P (TREE_VALUE (t
)))
6581 /* Nonzero if integer constants T1 and T2
6582 represent the same constant value. */
6585 tree_int_cst_equal (const_tree t1
, const_tree t2
)
6590 if (t1
== 0 || t2
== 0)
6593 if (TREE_CODE (t1
) == INTEGER_CST
6594 && TREE_CODE (t2
) == INTEGER_CST
6595 && wi::to_widest (t1
) == wi::to_widest (t2
))
6601 /* Return true if T is an INTEGER_CST whose numerical value (extended
6602 according to TYPE_UNSIGNED) fits in a signed HOST_WIDE_INT. */
6605 tree_fits_shwi_p (const_tree t
)
6607 return (t
!= NULL_TREE
6608 && TREE_CODE (t
) == INTEGER_CST
6609 && wi::fits_shwi_p (wi::to_widest (t
)));
6612 /* Return true if T is an INTEGER_CST whose numerical value (extended
6613 according to TYPE_UNSIGNED) fits in an unsigned HOST_WIDE_INT. */
6616 tree_fits_uhwi_p (const_tree t
)
6618 return (t
!= NULL_TREE
6619 && TREE_CODE (t
) == INTEGER_CST
6620 && wi::fits_uhwi_p (wi::to_widest (t
)));
6623 /* T is an INTEGER_CST whose numerical value (extended according to
6624 TYPE_UNSIGNED) fits in a signed HOST_WIDE_INT. Return that
6628 tree_to_shwi (const_tree t
)
6630 gcc_assert (tree_fits_shwi_p (t
));
6631 return TREE_INT_CST_LOW (t
);
6634 /* T is an INTEGER_CST whose numerical value (extended according to
6635 TYPE_UNSIGNED) fits in an unsigned HOST_WIDE_INT. Return that
6638 unsigned HOST_WIDE_INT
6639 tree_to_uhwi (const_tree t
)
6641 gcc_assert (tree_fits_uhwi_p (t
));
6642 return TREE_INT_CST_LOW (t
);
6645 /* Return the most significant (sign) bit of T. */
6648 tree_int_cst_sign_bit (const_tree t
)
6650 unsigned bitno
= TYPE_PRECISION (TREE_TYPE (t
)) - 1;
6652 return wi::extract_uhwi (wi::to_wide (t
), bitno
, 1);
6655 /* Return an indication of the sign of the integer constant T.
6656 The return value is -1 if T < 0, 0 if T == 0, and 1 if T > 0.
6657 Note that -1 will never be returned if T's type is unsigned. */
6660 tree_int_cst_sgn (const_tree t
)
6662 if (wi::to_wide (t
) == 0)
6664 else if (TYPE_UNSIGNED (TREE_TYPE (t
)))
6666 else if (wi::neg_p (wi::to_wide (t
)))
6672 /* Return the minimum number of bits needed to represent VALUE in a
6673 signed or unsigned type, UNSIGNEDP says which. */
6676 tree_int_cst_min_precision (tree value
, signop sgn
)
6678 /* If the value is negative, compute its negative minus 1. The latter
6679 adjustment is because the absolute value of the largest negative value
6680 is one larger than the largest positive value. This is equivalent to
6681 a bit-wise negation, so use that operation instead. */
6683 if (tree_int_cst_sgn (value
) < 0)
6684 value
= fold_build1 (BIT_NOT_EXPR
, TREE_TYPE (value
), value
);
6686 /* Return the number of bits needed, taking into account the fact
6687 that we need one more bit for a signed than unsigned type.
6688 If value is 0 or -1, the minimum precision is 1 no matter
6689 whether unsignedp is true or false. */
6691 if (integer_zerop (value
))
6694 return tree_floor_log2 (value
) + 1 + (sgn
== SIGNED
? 1 : 0) ;
6697 /* Return truthvalue of whether T1 is the same tree structure as T2.
6698 Return 1 if they are the same.
6699 Return 0 if they are understandably different.
6700 Return -1 if either contains tree structure not understood by
6704 simple_cst_equal (const_tree t1
, const_tree t2
)
6706 enum tree_code code1
, code2
;
6712 if (t1
== 0 || t2
== 0)
6715 code1
= TREE_CODE (t1
);
6716 code2
= TREE_CODE (t2
);
6718 if (CONVERT_EXPR_CODE_P (code1
) || code1
== NON_LVALUE_EXPR
)
6720 if (CONVERT_EXPR_CODE_P (code2
)
6721 || code2
== NON_LVALUE_EXPR
)
6722 return simple_cst_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
6724 return simple_cst_equal (TREE_OPERAND (t1
, 0), t2
);
6727 else if (CONVERT_EXPR_CODE_P (code2
)
6728 || code2
== NON_LVALUE_EXPR
)
6729 return simple_cst_equal (t1
, TREE_OPERAND (t2
, 0));
6737 return wi::to_widest (t1
) == wi::to_widest (t2
);
6740 return real_identical (&TREE_REAL_CST (t1
), &TREE_REAL_CST (t2
));
6743 return FIXED_VALUES_IDENTICAL (TREE_FIXED_CST (t1
), TREE_FIXED_CST (t2
));
6746 return (TREE_STRING_LENGTH (t1
) == TREE_STRING_LENGTH (t2
)
6747 && ! memcmp (TREE_STRING_POINTER (t1
), TREE_STRING_POINTER (t2
),
6748 TREE_STRING_LENGTH (t1
)));
6752 unsigned HOST_WIDE_INT idx
;
6753 vec
<constructor_elt
, va_gc
> *v1
= CONSTRUCTOR_ELTS (t1
);
6754 vec
<constructor_elt
, va_gc
> *v2
= CONSTRUCTOR_ELTS (t2
);
6756 if (vec_safe_length (v1
) != vec_safe_length (v2
))
6759 for (idx
= 0; idx
< vec_safe_length (v1
); ++idx
)
6760 /* ??? Should we handle also fields here? */
6761 if (!simple_cst_equal ((*v1
)[idx
].value
, (*v2
)[idx
].value
))
6767 return simple_cst_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
6770 cmp
= simple_cst_equal (CALL_EXPR_FN (t1
), CALL_EXPR_FN (t2
));
6773 if (call_expr_nargs (t1
) != call_expr_nargs (t2
))
6776 const_tree arg1
, arg2
;
6777 const_call_expr_arg_iterator iter1
, iter2
;
6778 for (arg1
= first_const_call_expr_arg (t1
, &iter1
),
6779 arg2
= first_const_call_expr_arg (t2
, &iter2
);
6781 arg1
= next_const_call_expr_arg (&iter1
),
6782 arg2
= next_const_call_expr_arg (&iter2
))
6784 cmp
= simple_cst_equal (arg1
, arg2
);
6788 return arg1
== arg2
;
6792 /* Special case: if either target is an unallocated VAR_DECL,
6793 it means that it's going to be unified with whatever the
6794 TARGET_EXPR is really supposed to initialize, so treat it
6795 as being equivalent to anything. */
6796 if ((TREE_CODE (TREE_OPERAND (t1
, 0)) == VAR_DECL
6797 && DECL_NAME (TREE_OPERAND (t1
, 0)) == NULL_TREE
6798 && !DECL_RTL_SET_P (TREE_OPERAND (t1
, 0)))
6799 || (TREE_CODE (TREE_OPERAND (t2
, 0)) == VAR_DECL
6800 && DECL_NAME (TREE_OPERAND (t2
, 0)) == NULL_TREE
6801 && !DECL_RTL_SET_P (TREE_OPERAND (t2
, 0))))
6804 cmp
= simple_cst_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
6809 return simple_cst_equal (TREE_OPERAND (t1
, 1), TREE_OPERAND (t2
, 1));
6811 case WITH_CLEANUP_EXPR
:
6812 cmp
= simple_cst_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
6816 return simple_cst_equal (TREE_OPERAND (t1
, 1), TREE_OPERAND (t1
, 1));
6819 if (TREE_OPERAND (t1
, 1) == TREE_OPERAND (t2
, 1))
6820 return simple_cst_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
6834 /* This general rule works for most tree codes. All exceptions should be
6835 handled above. If this is a language-specific tree code, we can't
6836 trust what might be in the operand, so say we don't know
6838 if ((int) code1
>= (int) LAST_AND_UNUSED_TREE_CODE
)
6841 switch (TREE_CODE_CLASS (code1
))
6845 case tcc_comparison
:
6846 case tcc_expression
:
6850 for (i
= 0; i
< TREE_CODE_LENGTH (code1
); i
++)
6852 cmp
= simple_cst_equal (TREE_OPERAND (t1
, i
), TREE_OPERAND (t2
, i
));
6864 /* Compare the value of T, an INTEGER_CST, with U, an unsigned integer value.
6865 Return -1, 0, or 1 if the value of T is less than, equal to, or greater
6866 than U, respectively. */
6869 compare_tree_int (const_tree t
, unsigned HOST_WIDE_INT u
)
6871 if (tree_int_cst_sgn (t
) < 0)
6873 else if (!tree_fits_uhwi_p (t
))
6875 else if (TREE_INT_CST_LOW (t
) == u
)
6877 else if (TREE_INT_CST_LOW (t
) < u
)
6883 /* Return true if SIZE represents a constant size that is in bounds of
6884 what the middle-end and the backend accepts (covering not more than
6885 half of the address-space). */
6888 valid_constant_size_p (const_tree size
)
6890 if (! tree_fits_uhwi_p (size
)
6891 || TREE_OVERFLOW (size
)
6892 || tree_int_cst_sign_bit (size
) != 0)
6897 /* Return the precision of the type, or for a complex or vector type the
6898 precision of the type of its elements. */
6901 element_precision (const_tree type
)
6904 type
= TREE_TYPE (type
);
6905 enum tree_code code
= TREE_CODE (type
);
6906 if (code
== COMPLEX_TYPE
|| code
== VECTOR_TYPE
)
6907 type
= TREE_TYPE (type
);
6909 return TYPE_PRECISION (type
);
6912 /* Return true if CODE represents an associative tree code. Otherwise
6915 associative_tree_code (enum tree_code code
)
6934 /* Return true if CODE represents a commutative tree code. Otherwise
6937 commutative_tree_code (enum tree_code code
)
6943 case MULT_HIGHPART_EXPR
:
6951 case UNORDERED_EXPR
:
6955 case TRUTH_AND_EXPR
:
6956 case TRUTH_XOR_EXPR
:
6958 case WIDEN_MULT_EXPR
:
6959 case VEC_WIDEN_MULT_HI_EXPR
:
6960 case VEC_WIDEN_MULT_LO_EXPR
:
6961 case VEC_WIDEN_MULT_EVEN_EXPR
:
6962 case VEC_WIDEN_MULT_ODD_EXPR
:
6971 /* Return true if CODE represents a ternary tree code for which the
6972 first two operands are commutative. Otherwise return false. */
6974 commutative_ternary_tree_code (enum tree_code code
)
6978 case WIDEN_MULT_PLUS_EXPR
:
6979 case WIDEN_MULT_MINUS_EXPR
:
6990 /* Returns true if CODE can overflow. */
6993 operation_can_overflow (enum tree_code code
)
7001 /* Can overflow in various ways. */
7003 case TRUNC_DIV_EXPR
:
7004 case EXACT_DIV_EXPR
:
7005 case FLOOR_DIV_EXPR
:
7007 /* For INT_MIN / -1. */
7014 /* These operators cannot overflow. */
7019 /* Returns true if CODE operating on operands of type TYPE doesn't overflow, or
7020 ftrapv doesn't generate trapping insns for CODE. */
7023 operation_no_trapping_overflow (tree type
, enum tree_code code
)
7025 gcc_checking_assert (ANY_INTEGRAL_TYPE_P (type
));
7027 /* We don't generate instructions that trap on overflow for complex or vector
7029 if (!INTEGRAL_TYPE_P (type
))
7032 if (!TYPE_OVERFLOW_TRAPS (type
))
7042 /* These operators can overflow, and -ftrapv generates trapping code for
7045 case TRUNC_DIV_EXPR
:
7046 case EXACT_DIV_EXPR
:
7047 case FLOOR_DIV_EXPR
:
7050 /* These operators can overflow, but -ftrapv does not generate trapping
7054 /* These operators cannot overflow. */
7062 /* Generate a hash value for an expression. This can be used iteratively
7063 by passing a previous result as the HSTATE argument.
7065 This function is intended to produce the same hash for expressions which
7066 would compare equal using operand_equal_p. */
7068 add_expr (const_tree t
, inchash::hash
&hstate
, unsigned int flags
)
7071 enum tree_code code
;
7072 enum tree_code_class tclass
;
7074 if (t
== NULL_TREE
|| t
== error_mark_node
)
7076 hstate
.merge_hash (0);
7080 if (!(flags
& OEP_ADDRESS_OF
))
7083 code
= TREE_CODE (t
);
7087 /* Alas, constants aren't shared, so we can't rely on pointer
7090 hstate
.merge_hash (0);
7093 gcc_checking_assert (!(flags
& OEP_ADDRESS_OF
));
7094 for (i
= 0; i
< TREE_INT_CST_EXT_NUNITS (t
); i
++)
7095 hstate
.add_hwi (TREE_INT_CST_ELT (t
, i
));
7100 if (!HONOR_SIGNED_ZEROS (t
) && real_zerop (t
))
7103 val2
= real_hash (TREE_REAL_CST_PTR (t
));
7104 hstate
.merge_hash (val2
);
7109 unsigned int val2
= fixed_hash (TREE_FIXED_CST_PTR (t
));
7110 hstate
.merge_hash (val2
);
7114 hstate
.add ((const void *) TREE_STRING_POINTER (t
),
7115 TREE_STRING_LENGTH (t
));
7118 inchash::add_expr (TREE_REALPART (t
), hstate
, flags
);
7119 inchash::add_expr (TREE_IMAGPART (t
), hstate
, flags
);
7124 for (i
= 0; i
< VECTOR_CST_NELTS (t
); ++i
)
7125 inchash::add_expr (VECTOR_CST_ELT (t
, i
), hstate
, flags
);
7129 /* We can just compare by pointer. */
7130 hstate
.add_hwi (SSA_NAME_VERSION (t
));
7132 case PLACEHOLDER_EXPR
:
7133 /* The node itself doesn't matter. */
7140 /* A list of expressions, for a CALL_EXPR or as the elements of a
7142 for (; t
; t
= TREE_CHAIN (t
))
7143 inchash::add_expr (TREE_VALUE (t
), hstate
, flags
);
7147 unsigned HOST_WIDE_INT idx
;
7149 flags
&= ~OEP_ADDRESS_OF
;
7150 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t
), idx
, field
, value
)
7152 inchash::add_expr (field
, hstate
, flags
);
7153 inchash::add_expr (value
, hstate
, flags
);
7157 case STATEMENT_LIST
:
7159 tree_stmt_iterator i
;
7160 for (i
= tsi_start (CONST_CAST_TREE (t
));
7161 !tsi_end_p (i
); tsi_next (&i
))
7162 inchash::add_expr (tsi_stmt (i
), hstate
, flags
);
7166 for (i
= 0; i
< TREE_VEC_LENGTH (t
); ++i
)
7167 inchash::add_expr (TREE_VEC_ELT (t
, i
), hstate
, flags
);
7170 /* When referring to a built-in FUNCTION_DECL, use the __builtin__ form.
7171 Otherwise nodes that compare equal according to operand_equal_p might
7172 get different hash codes. However, don't do this for machine specific
7173 or front end builtins, since the function code is overloaded in those
7175 if (DECL_BUILT_IN_CLASS (t
) == BUILT_IN_NORMAL
7176 && builtin_decl_explicit_p (DECL_FUNCTION_CODE (t
)))
7178 t
= builtin_decl_explicit (DECL_FUNCTION_CODE (t
));
7179 code
= TREE_CODE (t
);
7183 tclass
= TREE_CODE_CLASS (code
);
7185 if (tclass
== tcc_declaration
)
7187 /* DECL's have a unique ID */
7188 hstate
.add_hwi (DECL_UID (t
));
7190 else if (tclass
== tcc_comparison
&& !commutative_tree_code (code
))
7192 /* For comparisons that can be swapped, use the lower
7194 enum tree_code ccode
= swap_tree_comparison (code
);
7197 hstate
.add_object (ccode
);
7198 inchash::add_expr (TREE_OPERAND (t
, ccode
!= code
), hstate
, flags
);
7199 inchash::add_expr (TREE_OPERAND (t
, ccode
== code
), hstate
, flags
);
7201 else if (CONVERT_EXPR_CODE_P (code
))
7203 /* NOP_EXPR and CONVERT_EXPR are considered equal by
7205 enum tree_code ccode
= NOP_EXPR
;
7206 hstate
.add_object (ccode
);
7208 /* Don't hash the type, that can lead to having nodes which
7209 compare equal according to operand_equal_p, but which
7210 have different hash codes. Make sure to include signedness
7211 in the hash computation. */
7212 hstate
.add_int (TYPE_UNSIGNED (TREE_TYPE (t
)));
7213 inchash::add_expr (TREE_OPERAND (t
, 0), hstate
, flags
);
7215 /* For OEP_ADDRESS_OF, hash MEM_EXPR[&decl, 0] the same as decl. */
7216 else if (code
== MEM_REF
7217 && (flags
& OEP_ADDRESS_OF
) != 0
7218 && TREE_CODE (TREE_OPERAND (t
, 0)) == ADDR_EXPR
7219 && DECL_P (TREE_OPERAND (TREE_OPERAND (t
, 0), 0))
7220 && integer_zerop (TREE_OPERAND (t
, 1)))
7221 inchash::add_expr (TREE_OPERAND (TREE_OPERAND (t
, 0), 0),
7223 /* Don't ICE on FE specific trees, or their arguments etc.
7224 during operand_equal_p hash verification. */
7225 else if (!IS_EXPR_CODE_CLASS (tclass
))
7226 gcc_assert (flags
& OEP_HASH_CHECK
);
7229 unsigned int sflags
= flags
;
7231 hstate
.add_object (code
);
7236 gcc_checking_assert (!(flags
& OEP_ADDRESS_OF
));
7237 flags
|= OEP_ADDRESS_OF
;
7243 case TARGET_MEM_REF
:
7244 flags
&= ~OEP_ADDRESS_OF
;
7249 case ARRAY_RANGE_REF
:
7252 sflags
&= ~OEP_ADDRESS_OF
;
7256 flags
&= ~OEP_ADDRESS_OF
;
7260 case WIDEN_MULT_PLUS_EXPR
:
7261 case WIDEN_MULT_MINUS_EXPR
:
7263 /* The multiplication operands are commutative. */
7264 inchash::hash one
, two
;
7265 inchash::add_expr (TREE_OPERAND (t
, 0), one
, flags
);
7266 inchash::add_expr (TREE_OPERAND (t
, 1), two
, flags
);
7267 hstate
.add_commutative (one
, two
);
7268 inchash::add_expr (TREE_OPERAND (t
, 2), two
, flags
);
7273 if (CALL_EXPR_FN (t
) == NULL_TREE
)
7274 hstate
.add_int (CALL_EXPR_IFN (t
));
7278 /* For TARGET_EXPR, just hash on the TARGET_EXPR_SLOT.
7279 Usually different TARGET_EXPRs just should use
7280 different temporaries in their slots. */
7281 inchash::add_expr (TARGET_EXPR_SLOT (t
), hstate
, flags
);
7288 /* Don't hash the type, that can lead to having nodes which
7289 compare equal according to operand_equal_p, but which
7290 have different hash codes. */
7291 if (code
== NON_LVALUE_EXPR
)
7293 /* Make sure to include signness in the hash computation. */
7294 hstate
.add_int (TYPE_UNSIGNED (TREE_TYPE (t
)));
7295 inchash::add_expr (TREE_OPERAND (t
, 0), hstate
, flags
);
7298 else if (commutative_tree_code (code
))
7300 /* It's a commutative expression. We want to hash it the same
7301 however it appears. We do this by first hashing both operands
7302 and then rehashing based on the order of their independent
7304 inchash::hash one
, two
;
7305 inchash::add_expr (TREE_OPERAND (t
, 0), one
, flags
);
7306 inchash::add_expr (TREE_OPERAND (t
, 1), two
, flags
);
7307 hstate
.add_commutative (one
, two
);
7310 for (i
= TREE_OPERAND_LENGTH (t
) - 1; i
>= 0; --i
)
7311 inchash::add_expr (TREE_OPERAND (t
, i
), hstate
,
7312 i
== 0 ? flags
: sflags
);
7320 /* Constructors for pointer, array and function types.
7321 (RECORD_TYPE, UNION_TYPE and ENUMERAL_TYPE nodes are
7322 constructed by language-dependent code, not here.) */
7324 /* Construct, lay out and return the type of pointers to TO_TYPE with
7325 mode MODE. If CAN_ALIAS_ALL is TRUE, indicate this type can
7326 reference all of memory. If such a type has already been
7327 constructed, reuse it. */
7330 build_pointer_type_for_mode (tree to_type
, machine_mode mode
,
7334 bool could_alias
= can_alias_all
;
7336 if (to_type
== error_mark_node
)
7337 return error_mark_node
;
7339 /* If the pointed-to type has the may_alias attribute set, force
7340 a TYPE_REF_CAN_ALIAS_ALL pointer to be generated. */
7341 if (lookup_attribute ("may_alias", TYPE_ATTRIBUTES (to_type
)))
7342 can_alias_all
= true;
7344 /* In some cases, languages will have things that aren't a POINTER_TYPE
7345 (such as a RECORD_TYPE for fat pointers in Ada) as TYPE_POINTER_TO.
7346 In that case, return that type without regard to the rest of our
7349 ??? This is a kludge, but consistent with the way this function has
7350 always operated and there doesn't seem to be a good way to avoid this
7352 if (TYPE_POINTER_TO (to_type
) != 0
7353 && TREE_CODE (TYPE_POINTER_TO (to_type
)) != POINTER_TYPE
)
7354 return TYPE_POINTER_TO (to_type
);
7356 /* First, if we already have a type for pointers to TO_TYPE and it's
7357 the proper mode, use it. */
7358 for (t
= TYPE_POINTER_TO (to_type
); t
; t
= TYPE_NEXT_PTR_TO (t
))
7359 if (TYPE_MODE (t
) == mode
&& TYPE_REF_CAN_ALIAS_ALL (t
) == can_alias_all
)
7362 t
= make_node (POINTER_TYPE
);
7364 TREE_TYPE (t
) = to_type
;
7365 SET_TYPE_MODE (t
, mode
);
7366 TYPE_REF_CAN_ALIAS_ALL (t
) = can_alias_all
;
7367 TYPE_NEXT_PTR_TO (t
) = TYPE_POINTER_TO (to_type
);
7368 TYPE_POINTER_TO (to_type
) = t
;
7370 /* During LTO we do not set TYPE_CANONICAL of pointers and references. */
7371 if (TYPE_STRUCTURAL_EQUALITY_P (to_type
) || in_lto_p
)
7372 SET_TYPE_STRUCTURAL_EQUALITY (t
);
7373 else if (TYPE_CANONICAL (to_type
) != to_type
|| could_alias
)
7375 = build_pointer_type_for_mode (TYPE_CANONICAL (to_type
),
7378 /* Lay out the type. This function has many callers that are concerned
7379 with expression-construction, and this simplifies them all. */
7385 /* By default build pointers in ptr_mode. */
7388 build_pointer_type (tree to_type
)
7390 addr_space_t as
= to_type
== error_mark_node
? ADDR_SPACE_GENERIC
7391 : TYPE_ADDR_SPACE (to_type
);
7392 machine_mode pointer_mode
= targetm
.addr_space
.pointer_mode (as
);
7393 return build_pointer_type_for_mode (to_type
, pointer_mode
, false);
7396 /* Same as build_pointer_type_for_mode, but for REFERENCE_TYPE. */
7399 build_reference_type_for_mode (tree to_type
, machine_mode mode
,
7403 bool could_alias
= can_alias_all
;
7405 if (to_type
== error_mark_node
)
7406 return error_mark_node
;
7408 /* If the pointed-to type has the may_alias attribute set, force
7409 a TYPE_REF_CAN_ALIAS_ALL pointer to be generated. */
7410 if (lookup_attribute ("may_alias", TYPE_ATTRIBUTES (to_type
)))
7411 can_alias_all
= true;
7413 /* In some cases, languages will have things that aren't a REFERENCE_TYPE
7414 (such as a RECORD_TYPE for fat pointers in Ada) as TYPE_REFERENCE_TO.
7415 In that case, return that type without regard to the rest of our
7418 ??? This is a kludge, but consistent with the way this function has
7419 always operated and there doesn't seem to be a good way to avoid this
7421 if (TYPE_REFERENCE_TO (to_type
) != 0
7422 && TREE_CODE (TYPE_REFERENCE_TO (to_type
)) != REFERENCE_TYPE
)
7423 return TYPE_REFERENCE_TO (to_type
);
7425 /* First, if we already have a type for pointers to TO_TYPE and it's
7426 the proper mode, use it. */
7427 for (t
= TYPE_REFERENCE_TO (to_type
); t
; t
= TYPE_NEXT_REF_TO (t
))
7428 if (TYPE_MODE (t
) == mode
&& TYPE_REF_CAN_ALIAS_ALL (t
) == can_alias_all
)
7431 t
= make_node (REFERENCE_TYPE
);
7433 TREE_TYPE (t
) = to_type
;
7434 SET_TYPE_MODE (t
, mode
);
7435 TYPE_REF_CAN_ALIAS_ALL (t
) = can_alias_all
;
7436 TYPE_NEXT_REF_TO (t
) = TYPE_REFERENCE_TO (to_type
);
7437 TYPE_REFERENCE_TO (to_type
) = t
;
7439 /* During LTO we do not set TYPE_CANONICAL of pointers and references. */
7440 if (TYPE_STRUCTURAL_EQUALITY_P (to_type
) || in_lto_p
)
7441 SET_TYPE_STRUCTURAL_EQUALITY (t
);
7442 else if (TYPE_CANONICAL (to_type
) != to_type
|| could_alias
)
7444 = build_reference_type_for_mode (TYPE_CANONICAL (to_type
),
7453 /* Build the node for the type of references-to-TO_TYPE by default
7457 build_reference_type (tree to_type
)
7459 addr_space_t as
= to_type
== error_mark_node
? ADDR_SPACE_GENERIC
7460 : TYPE_ADDR_SPACE (to_type
);
7461 machine_mode pointer_mode
= targetm
.addr_space
.pointer_mode (as
);
7462 return build_reference_type_for_mode (to_type
, pointer_mode
, false);
7465 #define MAX_INT_CACHED_PREC \
7466 (HOST_BITS_PER_WIDE_INT > 64 ? HOST_BITS_PER_WIDE_INT : 64)
7467 static GTY(()) tree nonstandard_integer_type_cache
[2 * MAX_INT_CACHED_PREC
+ 2];
7469 /* Builds a signed or unsigned integer type of precision PRECISION.
7470 Used for C bitfields whose precision does not match that of
7471 built-in target types. */
7473 build_nonstandard_integer_type (unsigned HOST_WIDE_INT precision
,
7479 unsignedp
= MAX_INT_CACHED_PREC
+ 1;
7481 if (precision
<= MAX_INT_CACHED_PREC
)
7483 itype
= nonstandard_integer_type_cache
[precision
+ unsignedp
];
7488 itype
= make_node (INTEGER_TYPE
);
7489 TYPE_PRECISION (itype
) = precision
;
7492 fixup_unsigned_type (itype
);
7494 fixup_signed_type (itype
);
7498 inchash::hash hstate
;
7499 inchash::add_expr (TYPE_MAX_VALUE (itype
), hstate
);
7500 ret
= type_hash_canon (hstate
.end (), itype
);
7501 if (precision
<= MAX_INT_CACHED_PREC
)
7502 nonstandard_integer_type_cache
[precision
+ unsignedp
] = ret
;
7507 #define MAX_BOOL_CACHED_PREC \
7508 (HOST_BITS_PER_WIDE_INT > 64 ? HOST_BITS_PER_WIDE_INT : 64)
7509 static GTY(()) tree nonstandard_boolean_type_cache
[MAX_BOOL_CACHED_PREC
+ 1];
7511 /* Builds a boolean type of precision PRECISION.
7512 Used for boolean vectors to choose proper vector element size. */
7514 build_nonstandard_boolean_type (unsigned HOST_WIDE_INT precision
)
7518 if (precision
<= MAX_BOOL_CACHED_PREC
)
7520 type
= nonstandard_boolean_type_cache
[precision
];
7525 type
= make_node (BOOLEAN_TYPE
);
7526 TYPE_PRECISION (type
) = precision
;
7527 fixup_signed_type (type
);
7529 if (precision
<= MAX_INT_CACHED_PREC
)
7530 nonstandard_boolean_type_cache
[precision
] = type
;
7535 /* Create a range of some discrete type TYPE (an INTEGER_TYPE, ENUMERAL_TYPE
7536 or BOOLEAN_TYPE) with low bound LOWVAL and high bound HIGHVAL. If SHARED
7537 is true, reuse such a type that has already been constructed. */
7540 build_range_type_1 (tree type
, tree lowval
, tree highval
, bool shared
)
7542 tree itype
= make_node (INTEGER_TYPE
);
7544 TREE_TYPE (itype
) = type
;
7546 TYPE_MIN_VALUE (itype
) = fold_convert (type
, lowval
);
7547 TYPE_MAX_VALUE (itype
) = highval
? fold_convert (type
, highval
) : NULL
;
7549 TYPE_PRECISION (itype
) = TYPE_PRECISION (type
);
7550 SET_TYPE_MODE (itype
, TYPE_MODE (type
));
7551 TYPE_SIZE (itype
) = TYPE_SIZE (type
);
7552 TYPE_SIZE_UNIT (itype
) = TYPE_SIZE_UNIT (type
);
7553 SET_TYPE_ALIGN (itype
, TYPE_ALIGN (type
));
7554 TYPE_USER_ALIGN (itype
) = TYPE_USER_ALIGN (type
);
7555 SET_TYPE_WARN_IF_NOT_ALIGN (itype
, TYPE_WARN_IF_NOT_ALIGN (type
));
7560 if ((TYPE_MIN_VALUE (itype
)
7561 && TREE_CODE (TYPE_MIN_VALUE (itype
)) != INTEGER_CST
)
7562 || (TYPE_MAX_VALUE (itype
)
7563 && TREE_CODE (TYPE_MAX_VALUE (itype
)) != INTEGER_CST
))
7565 /* Since we cannot reliably merge this type, we need to compare it using
7566 structural equality checks. */
7567 SET_TYPE_STRUCTURAL_EQUALITY (itype
);
7571 hashval_t hash
= type_hash_canon_hash (itype
);
7572 itype
= type_hash_canon (hash
, itype
);
7577 /* Wrapper around build_range_type_1 with SHARED set to true. */
7580 build_range_type (tree type
, tree lowval
, tree highval
)
7582 return build_range_type_1 (type
, lowval
, highval
, true);
7585 /* Wrapper around build_range_type_1 with SHARED set to false. */
7588 build_nonshared_range_type (tree type
, tree lowval
, tree highval
)
7590 return build_range_type_1 (type
, lowval
, highval
, false);
7593 /* Create a type of integers to be the TYPE_DOMAIN of an ARRAY_TYPE.
7594 MAXVAL should be the maximum value in the domain
7595 (one less than the length of the array).
7597 The maximum value that MAXVAL can have is INT_MAX for a HOST_WIDE_INT.
7598 We don't enforce this limit, that is up to caller (e.g. language front end).
7599 The limit exists because the result is a signed type and we don't handle
7600 sizes that use more than one HOST_WIDE_INT. */
7603 build_index_type (tree maxval
)
7605 return build_range_type (sizetype
, size_zero_node
, maxval
);
7608 /* Return true if the debug information for TYPE, a subtype, should be emitted
7609 as a subrange type. If so, set LOWVAL to the low bound and HIGHVAL to the
7610 high bound, respectively. Sometimes doing so unnecessarily obfuscates the
7611 debug info and doesn't reflect the source code. */
7614 subrange_type_for_debug_p (const_tree type
, tree
*lowval
, tree
*highval
)
7616 tree base_type
= TREE_TYPE (type
), low
, high
;
7618 /* Subrange types have a base type which is an integral type. */
7619 if (!INTEGRAL_TYPE_P (base_type
))
7622 /* Get the real bounds of the subtype. */
7623 if (lang_hooks
.types
.get_subrange_bounds
)
7624 lang_hooks
.types
.get_subrange_bounds (type
, &low
, &high
);
7627 low
= TYPE_MIN_VALUE (type
);
7628 high
= TYPE_MAX_VALUE (type
);
7631 /* If the type and its base type have the same representation and the same
7632 name, then the type is not a subrange but a copy of the base type. */
7633 if ((TREE_CODE (base_type
) == INTEGER_TYPE
7634 || TREE_CODE (base_type
) == BOOLEAN_TYPE
)
7635 && int_size_in_bytes (type
) == int_size_in_bytes (base_type
)
7636 && tree_int_cst_equal (low
, TYPE_MIN_VALUE (base_type
))
7637 && tree_int_cst_equal (high
, TYPE_MAX_VALUE (base_type
))
7638 && TYPE_IDENTIFIER (type
) == TYPE_IDENTIFIER (base_type
))
7648 /* Construct, lay out and return the type of arrays of elements with ELT_TYPE
7649 and number of elements specified by the range of values of INDEX_TYPE.
7650 If TYPELESS_STORAGE is true, TYPE_TYPELESS_STORAGE flag is set on the type.
7651 If SHARED is true, reuse such a type that has already been constructed. */
7654 build_array_type_1 (tree elt_type
, tree index_type
, bool typeless_storage
,
7659 if (TREE_CODE (elt_type
) == FUNCTION_TYPE
)
7661 error ("arrays of functions are not meaningful");
7662 elt_type
= integer_type_node
;
7665 t
= make_node (ARRAY_TYPE
);
7666 TREE_TYPE (t
) = elt_type
;
7667 TYPE_DOMAIN (t
) = index_type
;
7668 TYPE_ADDR_SPACE (t
) = TYPE_ADDR_SPACE (elt_type
);
7669 TYPE_TYPELESS_STORAGE (t
) = typeless_storage
;
7672 /* If the element type is incomplete at this point we get marked for
7673 structural equality. Do not record these types in the canonical
7675 if (TYPE_STRUCTURAL_EQUALITY_P (t
))
7680 hashval_t hash
= type_hash_canon_hash (t
);
7681 t
= type_hash_canon (hash
, t
);
7684 if (TYPE_CANONICAL (t
) == t
)
7686 if (TYPE_STRUCTURAL_EQUALITY_P (elt_type
)
7687 || (index_type
&& TYPE_STRUCTURAL_EQUALITY_P (index_type
))
7689 SET_TYPE_STRUCTURAL_EQUALITY (t
);
7690 else if (TYPE_CANONICAL (elt_type
) != elt_type
7691 || (index_type
&& TYPE_CANONICAL (index_type
) != index_type
))
7693 = build_array_type_1 (TYPE_CANONICAL (elt_type
),
7695 ? TYPE_CANONICAL (index_type
) : NULL_TREE
,
7696 typeless_storage
, shared
);
7702 /* Wrapper around build_array_type_1 with SHARED set to true. */
7705 build_array_type (tree elt_type
, tree index_type
, bool typeless_storage
)
7707 return build_array_type_1 (elt_type
, index_type
, typeless_storage
, true);
7710 /* Wrapper around build_array_type_1 with SHARED set to false. */
7713 build_nonshared_array_type (tree elt_type
, tree index_type
)
7715 return build_array_type_1 (elt_type
, index_type
, false, false);
7718 /* Return a representation of ELT_TYPE[NELTS], using indices of type
7722 build_array_type_nelts (tree elt_type
, unsigned HOST_WIDE_INT nelts
)
7724 return build_array_type (elt_type
, build_index_type (size_int (nelts
- 1)));
7727 /* Recursively examines the array elements of TYPE, until a non-array
7728 element type is found. */
7731 strip_array_types (tree type
)
7733 while (TREE_CODE (type
) == ARRAY_TYPE
)
7734 type
= TREE_TYPE (type
);
7739 /* Computes the canonical argument types from the argument type list
7742 Upon return, *ANY_STRUCTURAL_P will be true iff either it was true
7743 on entry to this function, or if any of the ARGTYPES are
7746 Upon return, *ANY_NONCANONICAL_P will be true iff either it was
7747 true on entry to this function, or if any of the ARGTYPES are
7750 Returns a canonical argument list, which may be ARGTYPES when the
7751 canonical argument list is unneeded (i.e., *ANY_STRUCTURAL_P is
7752 true) or would not differ from ARGTYPES. */
7755 maybe_canonicalize_argtypes (tree argtypes
,
7756 bool *any_structural_p
,
7757 bool *any_noncanonical_p
)
7760 bool any_noncanonical_argtypes_p
= false;
7762 for (arg
= argtypes
; arg
&& !(*any_structural_p
); arg
= TREE_CHAIN (arg
))
7764 if (!TREE_VALUE (arg
) || TREE_VALUE (arg
) == error_mark_node
)
7765 /* Fail gracefully by stating that the type is structural. */
7766 *any_structural_p
= true;
7767 else if (TYPE_STRUCTURAL_EQUALITY_P (TREE_VALUE (arg
)))
7768 *any_structural_p
= true;
7769 else if (TYPE_CANONICAL (TREE_VALUE (arg
)) != TREE_VALUE (arg
)
7770 || TREE_PURPOSE (arg
))
7771 /* If the argument has a default argument, we consider it
7772 non-canonical even though the type itself is canonical.
7773 That way, different variants of function and method types
7774 with default arguments will all point to the variant with
7775 no defaults as their canonical type. */
7776 any_noncanonical_argtypes_p
= true;
7779 if (*any_structural_p
)
7782 if (any_noncanonical_argtypes_p
)
7784 /* Build the canonical list of argument types. */
7785 tree canon_argtypes
= NULL_TREE
;
7786 bool is_void
= false;
7788 for (arg
= argtypes
; arg
; arg
= TREE_CHAIN (arg
))
7790 if (arg
== void_list_node
)
7793 canon_argtypes
= tree_cons (NULL_TREE
,
7794 TYPE_CANONICAL (TREE_VALUE (arg
)),
7798 canon_argtypes
= nreverse (canon_argtypes
);
7800 canon_argtypes
= chainon (canon_argtypes
, void_list_node
);
7802 /* There is a non-canonical type. */
7803 *any_noncanonical_p
= true;
7804 return canon_argtypes
;
7807 /* The canonical argument types are the same as ARGTYPES. */
7811 /* Construct, lay out and return
7812 the type of functions returning type VALUE_TYPE
7813 given arguments of types ARG_TYPES.
7814 ARG_TYPES is a chain of TREE_LIST nodes whose TREE_VALUEs
7815 are data type nodes for the arguments of the function.
7816 If such a type has already been constructed, reuse it. */
7819 build_function_type (tree value_type
, tree arg_types
)
7822 inchash::hash hstate
;
7823 bool any_structural_p
, any_noncanonical_p
;
7824 tree canon_argtypes
;
7826 if (TREE_CODE (value_type
) == FUNCTION_TYPE
)
7828 error ("function return type cannot be function");
7829 value_type
= integer_type_node
;
7832 /* Make a node of the sort we want. */
7833 t
= make_node (FUNCTION_TYPE
);
7834 TREE_TYPE (t
) = value_type
;
7835 TYPE_ARG_TYPES (t
) = arg_types
;
7837 /* If we already have such a type, use the old one. */
7838 hashval_t hash
= type_hash_canon_hash (t
);
7839 t
= type_hash_canon (hash
, t
);
7841 /* Set up the canonical type. */
7842 any_structural_p
= TYPE_STRUCTURAL_EQUALITY_P (value_type
);
7843 any_noncanonical_p
= TYPE_CANONICAL (value_type
) != value_type
;
7844 canon_argtypes
= maybe_canonicalize_argtypes (arg_types
,
7846 &any_noncanonical_p
);
7847 if (any_structural_p
)
7848 SET_TYPE_STRUCTURAL_EQUALITY (t
);
7849 else if (any_noncanonical_p
)
7850 TYPE_CANONICAL (t
) = build_function_type (TYPE_CANONICAL (value_type
),
7853 if (!COMPLETE_TYPE_P (t
))
7858 /* Build a function type. The RETURN_TYPE is the type returned by the
7859 function. If VAARGS is set, no void_type_node is appended to the
7860 list. ARGP must be always be terminated be a NULL_TREE. */
7863 build_function_type_list_1 (bool vaargs
, tree return_type
, va_list argp
)
7867 t
= va_arg (argp
, tree
);
7868 for (args
= NULL_TREE
; t
!= NULL_TREE
; t
= va_arg (argp
, tree
))
7869 args
= tree_cons (NULL_TREE
, t
, args
);
7874 if (args
!= NULL_TREE
)
7875 args
= nreverse (args
);
7876 gcc_assert (last
!= void_list_node
);
7878 else if (args
== NULL_TREE
)
7879 args
= void_list_node
;
7883 args
= nreverse (args
);
7884 TREE_CHAIN (last
) = void_list_node
;
7886 args
= build_function_type (return_type
, args
);
7891 /* Build a function type. The RETURN_TYPE is the type returned by the
7892 function. If additional arguments are provided, they are
7893 additional argument types. The list of argument types must always
7894 be terminated by NULL_TREE. */
7897 build_function_type_list (tree return_type
, ...)
7902 va_start (p
, return_type
);
7903 args
= build_function_type_list_1 (false, return_type
, p
);
7908 /* Build a variable argument function type. The RETURN_TYPE is the
7909 type returned by the function. If additional arguments are provided,
7910 they are additional argument types. The list of argument types must
7911 always be terminated by NULL_TREE. */
7914 build_varargs_function_type_list (tree return_type
, ...)
7919 va_start (p
, return_type
);
7920 args
= build_function_type_list_1 (true, return_type
, p
);
7926 /* Build a function type. RETURN_TYPE is the type returned by the
7927 function; VAARGS indicates whether the function takes varargs. The
7928 function takes N named arguments, the types of which are provided in
7932 build_function_type_array_1 (bool vaargs
, tree return_type
, int n
,
7936 tree t
= vaargs
? NULL_TREE
: void_list_node
;
7938 for (i
= n
- 1; i
>= 0; i
--)
7939 t
= tree_cons (NULL_TREE
, arg_types
[i
], t
);
7941 return build_function_type (return_type
, t
);
7944 /* Build a function type. RETURN_TYPE is the type returned by the
7945 function. The function takes N named arguments, the types of which
7946 are provided in ARG_TYPES. */
7949 build_function_type_array (tree return_type
, int n
, tree
*arg_types
)
7951 return build_function_type_array_1 (false, return_type
, n
, arg_types
);
7954 /* Build a variable argument function type. RETURN_TYPE is the type
7955 returned by the function. The function takes N named arguments, the
7956 types of which are provided in ARG_TYPES. */
7959 build_varargs_function_type_array (tree return_type
, int n
, tree
*arg_types
)
7961 return build_function_type_array_1 (true, return_type
, n
, arg_types
);
7964 /* Build a METHOD_TYPE for a member of BASETYPE. The RETTYPE (a TYPE)
7965 and ARGTYPES (a TREE_LIST) are the return type and arguments types
7966 for the method. An implicit additional parameter (of type
7967 pointer-to-BASETYPE) is added to the ARGTYPES. */
7970 build_method_type_directly (tree basetype
,
7976 bool any_structural_p
, any_noncanonical_p
;
7977 tree canon_argtypes
;
7979 /* Make a node of the sort we want. */
7980 t
= make_node (METHOD_TYPE
);
7982 TYPE_METHOD_BASETYPE (t
) = TYPE_MAIN_VARIANT (basetype
);
7983 TREE_TYPE (t
) = rettype
;
7984 ptype
= build_pointer_type (basetype
);
7986 /* The actual arglist for this function includes a "hidden" argument
7987 which is "this". Put it into the list of argument types. */
7988 argtypes
= tree_cons (NULL_TREE
, ptype
, argtypes
);
7989 TYPE_ARG_TYPES (t
) = argtypes
;
7991 /* If we already have such a type, use the old one. */
7992 hashval_t hash
= type_hash_canon_hash (t
);
7993 t
= type_hash_canon (hash
, t
);
7995 /* Set up the canonical type. */
7997 = (TYPE_STRUCTURAL_EQUALITY_P (basetype
)
7998 || TYPE_STRUCTURAL_EQUALITY_P (rettype
));
8000 = (TYPE_CANONICAL (basetype
) != basetype
8001 || TYPE_CANONICAL (rettype
) != rettype
);
8002 canon_argtypes
= maybe_canonicalize_argtypes (TREE_CHAIN (argtypes
),
8004 &any_noncanonical_p
);
8005 if (any_structural_p
)
8006 SET_TYPE_STRUCTURAL_EQUALITY (t
);
8007 else if (any_noncanonical_p
)
8009 = build_method_type_directly (TYPE_CANONICAL (basetype
),
8010 TYPE_CANONICAL (rettype
),
8012 if (!COMPLETE_TYPE_P (t
))
8018 /* Construct, lay out and return the type of methods belonging to class
8019 BASETYPE and whose arguments and values are described by TYPE.
8020 If that type exists already, reuse it.
8021 TYPE must be a FUNCTION_TYPE node. */
8024 build_method_type (tree basetype
, tree type
)
8026 gcc_assert (TREE_CODE (type
) == FUNCTION_TYPE
);
8028 return build_method_type_directly (basetype
,
8030 TYPE_ARG_TYPES (type
));
8033 /* Construct, lay out and return the type of offsets to a value
8034 of type TYPE, within an object of type BASETYPE.
8035 If a suitable offset type exists already, reuse it. */
8038 build_offset_type (tree basetype
, tree type
)
8042 /* Make a node of the sort we want. */
8043 t
= make_node (OFFSET_TYPE
);
8045 TYPE_OFFSET_BASETYPE (t
) = TYPE_MAIN_VARIANT (basetype
);
8046 TREE_TYPE (t
) = type
;
8048 /* If we already have such a type, use the old one. */
8049 hashval_t hash
= type_hash_canon_hash (t
);
8050 t
= type_hash_canon (hash
, t
);
8052 if (!COMPLETE_TYPE_P (t
))
8055 if (TYPE_CANONICAL (t
) == t
)
8057 if (TYPE_STRUCTURAL_EQUALITY_P (basetype
)
8058 || TYPE_STRUCTURAL_EQUALITY_P (type
))
8059 SET_TYPE_STRUCTURAL_EQUALITY (t
);
8060 else if (TYPE_CANONICAL (TYPE_MAIN_VARIANT (basetype
)) != basetype
8061 || TYPE_CANONICAL (type
) != type
)
8063 = build_offset_type (TYPE_CANONICAL (TYPE_MAIN_VARIANT (basetype
)),
8064 TYPE_CANONICAL (type
));
8070 /* Create a complex type whose components are COMPONENT_TYPE.
8072 If NAMED is true, the type is given a TYPE_NAME. We do not always
8073 do so because this creates a DECL node and thus make the DECL_UIDs
8074 dependent on the type canonicalization hashtable, which is GC-ed,
8075 so the DECL_UIDs would not be stable wrt garbage collection. */
8078 build_complex_type (tree component_type
, bool named
)
8082 gcc_assert (INTEGRAL_TYPE_P (component_type
)
8083 || SCALAR_FLOAT_TYPE_P (component_type
)
8084 || FIXED_POINT_TYPE_P (component_type
));
8086 /* Make a node of the sort we want. */
8087 t
= make_node (COMPLEX_TYPE
);
8089 TREE_TYPE (t
) = TYPE_MAIN_VARIANT (component_type
);
8091 /* If we already have such a type, use the old one. */
8092 hashval_t hash
= type_hash_canon_hash (t
);
8093 t
= type_hash_canon (hash
, t
);
8095 if (!COMPLETE_TYPE_P (t
))
8098 if (TYPE_CANONICAL (t
) == t
)
8100 if (TYPE_STRUCTURAL_EQUALITY_P (component_type
))
8101 SET_TYPE_STRUCTURAL_EQUALITY (t
);
8102 else if (TYPE_CANONICAL (component_type
) != component_type
)
8104 = build_complex_type (TYPE_CANONICAL (component_type
), named
);
8107 /* We need to create a name, since complex is a fundamental type. */
8108 if (!TYPE_NAME (t
) && named
)
8111 if (component_type
== char_type_node
)
8112 name
= "complex char";
8113 else if (component_type
== signed_char_type_node
)
8114 name
= "complex signed char";
8115 else if (component_type
== unsigned_char_type_node
)
8116 name
= "complex unsigned char";
8117 else if (component_type
== short_integer_type_node
)
8118 name
= "complex short int";
8119 else if (component_type
== short_unsigned_type_node
)
8120 name
= "complex short unsigned int";
8121 else if (component_type
== integer_type_node
)
8122 name
= "complex int";
8123 else if (component_type
== unsigned_type_node
)
8124 name
= "complex unsigned int";
8125 else if (component_type
== long_integer_type_node
)
8126 name
= "complex long int";
8127 else if (component_type
== long_unsigned_type_node
)
8128 name
= "complex long unsigned int";
8129 else if (component_type
== long_long_integer_type_node
)
8130 name
= "complex long long int";
8131 else if (component_type
== long_long_unsigned_type_node
)
8132 name
= "complex long long unsigned int";
8137 TYPE_NAME (t
) = build_decl (UNKNOWN_LOCATION
, TYPE_DECL
,
8138 get_identifier (name
), t
);
8141 return build_qualified_type (t
, TYPE_QUALS (component_type
));
8144 /* If TYPE is a real or complex floating-point type and the target
8145 does not directly support arithmetic on TYPE then return the wider
8146 type to be used for arithmetic on TYPE. Otherwise, return
8150 excess_precision_type (tree type
)
8152 /* The target can give two different responses to the question of
8153 which excess precision mode it would like depending on whether we
8154 are in -fexcess-precision=standard or -fexcess-precision=fast. */
8156 enum excess_precision_type requested_type
8157 = (flag_excess_precision
== EXCESS_PRECISION_FAST
8158 ? EXCESS_PRECISION_TYPE_FAST
8159 : EXCESS_PRECISION_TYPE_STANDARD
);
8161 enum flt_eval_method target_flt_eval_method
8162 = targetm
.c
.excess_precision (requested_type
);
8164 /* The target should not ask for unpredictable float evaluation (though
8165 it might advertise that implicitly the evaluation is unpredictable,
8166 but we don't care about that here, it will have been reported
8167 elsewhere). If it does ask for unpredictable evaluation, we have
8168 nothing to do here. */
8169 gcc_assert (target_flt_eval_method
!= FLT_EVAL_METHOD_UNPREDICTABLE
);
8171 /* Nothing to do. The target has asked for all types we know about
8172 to be computed with their native precision and range. */
8173 if (target_flt_eval_method
== FLT_EVAL_METHOD_PROMOTE_TO_FLOAT16
)
8176 /* The target will promote this type in a target-dependent way, so excess
8177 precision ought to leave it alone. */
8178 if (targetm
.promoted_type (type
) != NULL_TREE
)
8181 machine_mode float16_type_mode
= (float16_type_node
8182 ? TYPE_MODE (float16_type_node
)
8184 machine_mode float_type_mode
= TYPE_MODE (float_type_node
);
8185 machine_mode double_type_mode
= TYPE_MODE (double_type_node
);
8187 switch (TREE_CODE (type
))
8191 machine_mode type_mode
= TYPE_MODE (type
);
8192 switch (target_flt_eval_method
)
8194 case FLT_EVAL_METHOD_PROMOTE_TO_FLOAT
:
8195 if (type_mode
== float16_type_mode
)
8196 return float_type_node
;
8198 case FLT_EVAL_METHOD_PROMOTE_TO_DOUBLE
:
8199 if (type_mode
== float16_type_mode
8200 || type_mode
== float_type_mode
)
8201 return double_type_node
;
8203 case FLT_EVAL_METHOD_PROMOTE_TO_LONG_DOUBLE
:
8204 if (type_mode
== float16_type_mode
8205 || type_mode
== float_type_mode
8206 || type_mode
== double_type_mode
)
8207 return long_double_type_node
;
8216 if (TREE_CODE (TREE_TYPE (type
)) != REAL_TYPE
)
8218 machine_mode type_mode
= TYPE_MODE (TREE_TYPE (type
));
8219 switch (target_flt_eval_method
)
8221 case FLT_EVAL_METHOD_PROMOTE_TO_FLOAT
:
8222 if (type_mode
== float16_type_mode
)
8223 return complex_float_type_node
;
8225 case FLT_EVAL_METHOD_PROMOTE_TO_DOUBLE
:
8226 if (type_mode
== float16_type_mode
8227 || type_mode
== float_type_mode
)
8228 return complex_double_type_node
;
8230 case FLT_EVAL_METHOD_PROMOTE_TO_LONG_DOUBLE
:
8231 if (type_mode
== float16_type_mode
8232 || type_mode
== float_type_mode
8233 || type_mode
== double_type_mode
)
8234 return complex_long_double_type_node
;
8248 /* Return OP, stripped of any conversions to wider types as much as is safe.
8249 Converting the value back to OP's type makes a value equivalent to OP.
8251 If FOR_TYPE is nonzero, we return a value which, if converted to
8252 type FOR_TYPE, would be equivalent to converting OP to type FOR_TYPE.
8254 OP must have integer, real or enumeral type. Pointers are not allowed!
8256 There are some cases where the obvious value we could return
8257 would regenerate to OP if converted to OP's type,
8258 but would not extend like OP to wider types.
8259 If FOR_TYPE indicates such extension is contemplated, we eschew such values.
8260 For example, if OP is (unsigned short)(signed char)-1,
8261 we avoid returning (signed char)-1 if FOR_TYPE is int,
8262 even though extending that to an unsigned short would regenerate OP,
8263 since the result of extending (signed char)-1 to (int)
8264 is different from (int) OP. */
8267 get_unwidened (tree op
, tree for_type
)
8269 /* Set UNS initially if converting OP to FOR_TYPE is a zero-extension. */
8270 tree type
= TREE_TYPE (op
);
8272 = TYPE_PRECISION (for_type
!= 0 ? for_type
: type
);
8274 = (for_type
!= 0 && for_type
!= type
8275 && final_prec
> TYPE_PRECISION (type
)
8276 && TYPE_UNSIGNED (type
));
8279 while (CONVERT_EXPR_P (op
))
8283 /* TYPE_PRECISION on vector types has different meaning
8284 (TYPE_VECTOR_SUBPARTS) and casts from vectors are view conversions,
8285 so avoid them here. */
8286 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (op
, 0))) == VECTOR_TYPE
)
8289 bitschange
= TYPE_PRECISION (TREE_TYPE (op
))
8290 - TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op
, 0)));
8292 /* Truncations are many-one so cannot be removed.
8293 Unless we are later going to truncate down even farther. */
8295 && final_prec
> TYPE_PRECISION (TREE_TYPE (op
)))
8298 /* See what's inside this conversion. If we decide to strip it,
8300 op
= TREE_OPERAND (op
, 0);
8302 /* If we have not stripped any zero-extensions (uns is 0),
8303 we can strip any kind of extension.
8304 If we have previously stripped a zero-extension,
8305 only zero-extensions can safely be stripped.
8306 Any extension can be stripped if the bits it would produce
8307 are all going to be discarded later by truncating to FOR_TYPE. */
8311 if (! uns
|| final_prec
<= TYPE_PRECISION (TREE_TYPE (op
)))
8313 /* TYPE_UNSIGNED says whether this is a zero-extension.
8314 Let's avoid computing it if it does not affect WIN
8315 and if UNS will not be needed again. */
8317 || CONVERT_EXPR_P (op
))
8318 && TYPE_UNSIGNED (TREE_TYPE (op
)))
8326 /* If we finally reach a constant see if it fits in sth smaller and
8327 in that case convert it. */
8328 if (TREE_CODE (win
) == INTEGER_CST
)
8330 tree wtype
= TREE_TYPE (win
);
8331 unsigned prec
= wi::min_precision (wi::to_wide (win
), TYPE_SIGN (wtype
));
8333 prec
= MAX (prec
, final_prec
);
8334 if (prec
< TYPE_PRECISION (wtype
))
8336 tree t
= lang_hooks
.types
.type_for_size (prec
, TYPE_UNSIGNED (wtype
));
8337 if (t
&& TYPE_PRECISION (t
) < TYPE_PRECISION (wtype
))
8338 win
= fold_convert (t
, win
);
8345 /* Return OP or a simpler expression for a narrower value
8346 which can be sign-extended or zero-extended to give back OP.
8347 Store in *UNSIGNEDP_PTR either 1 if the value should be zero-extended
8348 or 0 if the value should be sign-extended. */
8351 get_narrower (tree op
, int *unsignedp_ptr
)
8356 bool integral_p
= INTEGRAL_TYPE_P (TREE_TYPE (op
));
8358 while (TREE_CODE (op
) == NOP_EXPR
)
8361 = (TYPE_PRECISION (TREE_TYPE (op
))
8362 - TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op
, 0))));
8364 /* Truncations are many-one so cannot be removed. */
8368 /* See what's inside this conversion. If we decide to strip it,
8373 op
= TREE_OPERAND (op
, 0);
8374 /* An extension: the outermost one can be stripped,
8375 but remember whether it is zero or sign extension. */
8377 uns
= TYPE_UNSIGNED (TREE_TYPE (op
));
8378 /* Otherwise, if a sign extension has been stripped,
8379 only sign extensions can now be stripped;
8380 if a zero extension has been stripped, only zero-extensions. */
8381 else if (uns
!= TYPE_UNSIGNED (TREE_TYPE (op
)))
8385 else /* bitschange == 0 */
8387 /* A change in nominal type can always be stripped, but we must
8388 preserve the unsignedness. */
8390 uns
= TYPE_UNSIGNED (TREE_TYPE (op
));
8392 op
= TREE_OPERAND (op
, 0);
8393 /* Keep trying to narrow, but don't assign op to win if it
8394 would turn an integral type into something else. */
8395 if (INTEGRAL_TYPE_P (TREE_TYPE (op
)) != integral_p
)
8402 if (TREE_CODE (op
) == COMPONENT_REF
8403 /* Since type_for_size always gives an integer type. */
8404 && TREE_CODE (TREE_TYPE (op
)) != REAL_TYPE
8405 && TREE_CODE (TREE_TYPE (op
)) != FIXED_POINT_TYPE
8406 /* Ensure field is laid out already. */
8407 && DECL_SIZE (TREE_OPERAND (op
, 1)) != 0
8408 && tree_fits_uhwi_p (DECL_SIZE (TREE_OPERAND (op
, 1))))
8410 unsigned HOST_WIDE_INT innerprec
8411 = tree_to_uhwi (DECL_SIZE (TREE_OPERAND (op
, 1)));
8412 int unsignedp
= (DECL_UNSIGNED (TREE_OPERAND (op
, 1))
8413 || TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op
, 1))));
8414 tree type
= lang_hooks
.types
.type_for_size (innerprec
, unsignedp
);
8416 /* We can get this structure field in a narrower type that fits it,
8417 but the resulting extension to its nominal type (a fullword type)
8418 must satisfy the same conditions as for other extensions.
8420 Do this only for fields that are aligned (not bit-fields),
8421 because when bit-field insns will be used there is no
8422 advantage in doing this. */
8424 if (innerprec
< TYPE_PRECISION (TREE_TYPE (op
))
8425 && ! DECL_BIT_FIELD (TREE_OPERAND (op
, 1))
8426 && (first
|| uns
== DECL_UNSIGNED (TREE_OPERAND (op
, 1)))
8430 uns
= DECL_UNSIGNED (TREE_OPERAND (op
, 1));
8431 win
= fold_convert (type
, op
);
8435 *unsignedp_ptr
= uns
;
8439 /* Return true if integer constant C has a value that is permissible
8440 for TYPE, an integral type. */
8443 int_fits_type_p (const_tree c
, const_tree type
)
8445 tree type_low_bound
, type_high_bound
;
8446 bool ok_for_low_bound
, ok_for_high_bound
;
8447 signop sgn_c
= TYPE_SIGN (TREE_TYPE (c
));
8449 /* Non-standard boolean types can have arbitrary precision but various
8450 transformations assume that they can only take values 0 and +/-1. */
8451 if (TREE_CODE (type
) == BOOLEAN_TYPE
)
8452 return wi::fits_to_boolean_p (wi::to_wide (c
), type
);
8455 type_low_bound
= TYPE_MIN_VALUE (type
);
8456 type_high_bound
= TYPE_MAX_VALUE (type
);
8458 /* If at least one bound of the type is a constant integer, we can check
8459 ourselves and maybe make a decision. If no such decision is possible, but
8460 this type is a subtype, try checking against that. Otherwise, use
8461 fits_to_tree_p, which checks against the precision.
8463 Compute the status for each possibly constant bound, and return if we see
8464 one does not match. Use ok_for_xxx_bound for this purpose, assigning -1
8465 for "unknown if constant fits", 0 for "constant known *not* to fit" and 1
8466 for "constant known to fit". */
8468 /* Check if c >= type_low_bound. */
8469 if (type_low_bound
&& TREE_CODE (type_low_bound
) == INTEGER_CST
)
8471 if (tree_int_cst_lt (c
, type_low_bound
))
8473 ok_for_low_bound
= true;
8476 ok_for_low_bound
= false;
8478 /* Check if c <= type_high_bound. */
8479 if (type_high_bound
&& TREE_CODE (type_high_bound
) == INTEGER_CST
)
8481 if (tree_int_cst_lt (type_high_bound
, c
))
8483 ok_for_high_bound
= true;
8486 ok_for_high_bound
= false;
8488 /* If the constant fits both bounds, the result is known. */
8489 if (ok_for_low_bound
&& ok_for_high_bound
)
8492 /* Perform some generic filtering which may allow making a decision
8493 even if the bounds are not constant. First, negative integers
8494 never fit in unsigned types, */
8495 if (TYPE_UNSIGNED (type
) && sgn_c
== SIGNED
&& wi::neg_p (wi::to_wide (c
)))
8498 /* Second, narrower types always fit in wider ones. */
8499 if (TYPE_PRECISION (type
) > TYPE_PRECISION (TREE_TYPE (c
)))
8502 /* Third, unsigned integers with top bit set never fit signed types. */
8503 if (!TYPE_UNSIGNED (type
) && sgn_c
== UNSIGNED
)
8505 int prec
= GET_MODE_PRECISION (SCALAR_INT_TYPE_MODE (TREE_TYPE (c
))) - 1;
8506 if (prec
< TYPE_PRECISION (TREE_TYPE (c
)))
8508 /* When a tree_cst is converted to a wide-int, the precision
8509 is taken from the type. However, if the precision of the
8510 mode underneath the type is smaller than that, it is
8511 possible that the value will not fit. The test below
8512 fails if any bit is set between the sign bit of the
8513 underlying mode and the top bit of the type. */
8514 if (wi::zext (wi::to_wide (c
), prec
- 1) != wi::to_wide (c
))
8517 else if (wi::neg_p (wi::to_wide (c
)))
8521 /* If we haven't been able to decide at this point, there nothing more we
8522 can check ourselves here. Look at the base type if we have one and it
8523 has the same precision. */
8524 if (TREE_CODE (type
) == INTEGER_TYPE
8525 && TREE_TYPE (type
) != 0
8526 && TYPE_PRECISION (type
) == TYPE_PRECISION (TREE_TYPE (type
)))
8528 type
= TREE_TYPE (type
);
8532 /* Or to fits_to_tree_p, if nothing else. */
8533 return wi::fits_to_tree_p (wi::to_wide (c
), type
);
8536 /* Stores bounds of an integer TYPE in MIN and MAX. If TYPE has non-constant
8537 bounds or is a POINTER_TYPE, the maximum and/or minimum values that can be
8538 represented (assuming two's-complement arithmetic) within the bit
8539 precision of the type are returned instead. */
8542 get_type_static_bounds (const_tree type
, mpz_t min
, mpz_t max
)
8544 if (!POINTER_TYPE_P (type
) && TYPE_MIN_VALUE (type
)
8545 && TREE_CODE (TYPE_MIN_VALUE (type
)) == INTEGER_CST
)
8546 wi::to_mpz (wi::to_wide (TYPE_MIN_VALUE (type
)), min
, TYPE_SIGN (type
));
8549 if (TYPE_UNSIGNED (type
))
8550 mpz_set_ui (min
, 0);
8553 wide_int mn
= wi::min_value (TYPE_PRECISION (type
), SIGNED
);
8554 wi::to_mpz (mn
, min
, SIGNED
);
8558 if (!POINTER_TYPE_P (type
) && TYPE_MAX_VALUE (type
)
8559 && TREE_CODE (TYPE_MAX_VALUE (type
)) == INTEGER_CST
)
8560 wi::to_mpz (wi::to_wide (TYPE_MAX_VALUE (type
)), max
, TYPE_SIGN (type
));
8563 wide_int mn
= wi::max_value (TYPE_PRECISION (type
), TYPE_SIGN (type
));
8564 wi::to_mpz (mn
, max
, TYPE_SIGN (type
));
8568 /* Return true if VAR is an automatic variable defined in function FN. */
8571 auto_var_in_fn_p (const_tree var
, const_tree fn
)
8573 return (DECL_P (var
) && DECL_CONTEXT (var
) == fn
8574 && ((((VAR_P (var
) && ! DECL_EXTERNAL (var
))
8575 || TREE_CODE (var
) == PARM_DECL
)
8576 && ! TREE_STATIC (var
))
8577 || TREE_CODE (var
) == LABEL_DECL
8578 || TREE_CODE (var
) == RESULT_DECL
));
8581 /* Subprogram of following function. Called by walk_tree.
8583 Return *TP if it is an automatic variable or parameter of the
8584 function passed in as DATA. */
8587 find_var_from_fn (tree
*tp
, int *walk_subtrees
, void *data
)
8589 tree fn
= (tree
) data
;
8594 else if (DECL_P (*tp
)
8595 && auto_var_in_fn_p (*tp
, fn
))
8601 /* Returns true if T is, contains, or refers to a type with variable
8602 size. For METHOD_TYPEs and FUNCTION_TYPEs we exclude the
8603 arguments, but not the return type. If FN is nonzero, only return
8604 true if a modifier of the type or position of FN is a variable or
8605 parameter inside FN.
8607 This concept is more general than that of C99 'variably modified types':
8608 in C99, a struct type is never variably modified because a VLA may not
8609 appear as a structure member. However, in GNU C code like:
8611 struct S { int i[f()]; };
8613 is valid, and other languages may define similar constructs. */
8616 variably_modified_type_p (tree type
, tree fn
)
8620 /* Test if T is either variable (if FN is zero) or an expression containing
8621 a variable in FN. If TYPE isn't gimplified, return true also if
8622 gimplify_one_sizepos would gimplify the expression into a local
8624 #define RETURN_TRUE_IF_VAR(T) \
8625 do { tree _t = (T); \
8626 if (_t != NULL_TREE \
8627 && _t != error_mark_node \
8628 && TREE_CODE (_t) != INTEGER_CST \
8629 && TREE_CODE (_t) != PLACEHOLDER_EXPR \
8631 || (!TYPE_SIZES_GIMPLIFIED (type) \
8632 && !is_gimple_sizepos (_t)) \
8633 || walk_tree (&_t, find_var_from_fn, fn, NULL))) \
8634 return true; } while (0)
8636 if (type
== error_mark_node
)
8639 /* If TYPE itself has variable size, it is variably modified. */
8640 RETURN_TRUE_IF_VAR (TYPE_SIZE (type
));
8641 RETURN_TRUE_IF_VAR (TYPE_SIZE_UNIT (type
));
8643 switch (TREE_CODE (type
))
8646 case REFERENCE_TYPE
:
8648 /* Ada can have pointer types refering to themselves indirectly. */
8649 if (TREE_VISITED (type
))
8651 TREE_VISITED (type
) = true;
8652 if (variably_modified_type_p (TREE_TYPE (type
), fn
))
8654 TREE_VISITED (type
) = false;
8657 TREE_VISITED (type
) = false;
8662 /* If TYPE is a function type, it is variably modified if the
8663 return type is variably modified. */
8664 if (variably_modified_type_p (TREE_TYPE (type
), fn
))
8670 case FIXED_POINT_TYPE
:
8673 /* Scalar types are variably modified if their end points
8675 RETURN_TRUE_IF_VAR (TYPE_MIN_VALUE (type
));
8676 RETURN_TRUE_IF_VAR (TYPE_MAX_VALUE (type
));
8681 case QUAL_UNION_TYPE
:
8682 /* We can't see if any of the fields are variably-modified by the
8683 definition we normally use, since that would produce infinite
8684 recursion via pointers. */
8685 /* This is variably modified if some field's type is. */
8686 for (t
= TYPE_FIELDS (type
); t
; t
= DECL_CHAIN (t
))
8687 if (TREE_CODE (t
) == FIELD_DECL
)
8689 RETURN_TRUE_IF_VAR (DECL_FIELD_OFFSET (t
));
8690 RETURN_TRUE_IF_VAR (DECL_SIZE (t
));
8691 RETURN_TRUE_IF_VAR (DECL_SIZE_UNIT (t
));
8693 if (TREE_CODE (type
) == QUAL_UNION_TYPE
)
8694 RETURN_TRUE_IF_VAR (DECL_QUALIFIER (t
));
8699 /* Do not call ourselves to avoid infinite recursion. This is
8700 variably modified if the element type is. */
8701 RETURN_TRUE_IF_VAR (TYPE_SIZE (TREE_TYPE (type
)));
8702 RETURN_TRUE_IF_VAR (TYPE_SIZE_UNIT (TREE_TYPE (type
)));
8709 /* The current language may have other cases to check, but in general,
8710 all other types are not variably modified. */
8711 return lang_hooks
.tree_inlining
.var_mod_type_p (type
, fn
);
8713 #undef RETURN_TRUE_IF_VAR
8716 /* Given a DECL or TYPE, return the scope in which it was declared, or
8717 NULL_TREE if there is no containing scope. */
8720 get_containing_scope (const_tree t
)
8722 return (TYPE_P (t
) ? TYPE_CONTEXT (t
) : DECL_CONTEXT (t
));
8725 /* Returns the ultimate TRANSLATION_UNIT_DECL context of DECL or NULL. */
8728 get_ultimate_context (const_tree decl
)
8730 while (decl
&& TREE_CODE (decl
) != TRANSLATION_UNIT_DECL
)
8732 if (TREE_CODE (decl
) == BLOCK
)
8733 decl
= BLOCK_SUPERCONTEXT (decl
);
8735 decl
= get_containing_scope (decl
);
8740 /* Return the innermost context enclosing DECL that is
8741 a FUNCTION_DECL, or zero if none. */
8744 decl_function_context (const_tree decl
)
8748 if (TREE_CODE (decl
) == ERROR_MARK
)
8751 /* C++ virtual functions use DECL_CONTEXT for the class of the vtable
8752 where we look up the function at runtime. Such functions always take
8753 a first argument of type 'pointer to real context'.
8755 C++ should really be fixed to use DECL_CONTEXT for the real context,
8756 and use something else for the "virtual context". */
8757 else if (TREE_CODE (decl
) == FUNCTION_DECL
&& DECL_VINDEX (decl
))
8760 (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl
)))));
8762 context
= DECL_CONTEXT (decl
);
8764 while (context
&& TREE_CODE (context
) != FUNCTION_DECL
)
8766 if (TREE_CODE (context
) == BLOCK
)
8767 context
= BLOCK_SUPERCONTEXT (context
);
8769 context
= get_containing_scope (context
);
8775 /* Return the innermost context enclosing DECL that is
8776 a RECORD_TYPE, UNION_TYPE or QUAL_UNION_TYPE, or zero if none.
8777 TYPE_DECLs and FUNCTION_DECLs are transparent to this function. */
8780 decl_type_context (const_tree decl
)
8782 tree context
= DECL_CONTEXT (decl
);
8785 switch (TREE_CODE (context
))
8787 case NAMESPACE_DECL
:
8788 case TRANSLATION_UNIT_DECL
:
8793 case QUAL_UNION_TYPE
:
8798 context
= DECL_CONTEXT (context
);
8802 context
= BLOCK_SUPERCONTEXT (context
);
8812 /* CALL is a CALL_EXPR. Return the declaration for the function
8813 called, or NULL_TREE if the called function cannot be
8817 get_callee_fndecl (const_tree call
)
8821 if (call
== error_mark_node
)
8822 return error_mark_node
;
8824 /* It's invalid to call this function with anything but a
8826 gcc_assert (TREE_CODE (call
) == CALL_EXPR
);
8828 /* The first operand to the CALL is the address of the function
8830 addr
= CALL_EXPR_FN (call
);
8832 /* If there is no function, return early. */
8833 if (addr
== NULL_TREE
)
8838 /* If this is a readonly function pointer, extract its initial value. */
8839 if (DECL_P (addr
) && TREE_CODE (addr
) != FUNCTION_DECL
8840 && TREE_READONLY (addr
) && ! TREE_THIS_VOLATILE (addr
)
8841 && DECL_INITIAL (addr
))
8842 addr
= DECL_INITIAL (addr
);
8844 /* If the address is just `&f' for some function `f', then we know
8845 that `f' is being called. */
8846 if (TREE_CODE (addr
) == ADDR_EXPR
8847 && TREE_CODE (TREE_OPERAND (addr
, 0)) == FUNCTION_DECL
)
8848 return TREE_OPERAND (addr
, 0);
8850 /* We couldn't figure out what was being called. */
8854 /* If CALL_EXPR CALL calls a normal built-in function or an internal function,
8855 return the associated function code, otherwise return CFN_LAST. */
8858 get_call_combined_fn (const_tree call
)
8860 /* It's invalid to call this function with anything but a CALL_EXPR. */
8861 gcc_assert (TREE_CODE (call
) == CALL_EXPR
);
8863 if (!CALL_EXPR_FN (call
))
8864 return as_combined_fn (CALL_EXPR_IFN (call
));
8866 tree fndecl
= get_callee_fndecl (call
);
8867 if (fndecl
&& DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_NORMAL
)
8868 return as_combined_fn (DECL_FUNCTION_CODE (fndecl
));
8873 #define TREE_MEM_USAGE_SPACES 40
8875 /* Print debugging information about tree nodes generated during the compile,
8876 and any language-specific information. */
8879 dump_tree_statistics (void)
8881 if (GATHER_STATISTICS
)
8884 int total_nodes
, total_bytes
;
8885 fprintf (stderr
, "\nKind Nodes Bytes\n");
8886 mem_usage::print_dash_line (TREE_MEM_USAGE_SPACES
);
8887 total_nodes
= total_bytes
= 0;
8888 for (i
= 0; i
< (int) all_kinds
; i
++)
8890 fprintf (stderr
, "%-20s %7d %10d\n", tree_node_kind_names
[i
],
8891 tree_node_counts
[i
], tree_node_sizes
[i
]);
8892 total_nodes
+= tree_node_counts
[i
];
8893 total_bytes
+= tree_node_sizes
[i
];
8895 mem_usage::print_dash_line (TREE_MEM_USAGE_SPACES
);
8896 fprintf (stderr
, "%-20s %7d %10d\n", "Total", total_nodes
, total_bytes
);
8897 mem_usage::print_dash_line (TREE_MEM_USAGE_SPACES
);
8898 fprintf (stderr
, "Code Nodes\n");
8899 mem_usage::print_dash_line (TREE_MEM_USAGE_SPACES
);
8900 for (i
= 0; i
< (int) MAX_TREE_CODES
; i
++)
8901 fprintf (stderr
, "%-32s %7d\n", get_tree_code_name ((enum tree_code
) i
),
8902 tree_code_counts
[i
]);
8903 mem_usage::print_dash_line (TREE_MEM_USAGE_SPACES
);
8904 fprintf (stderr
, "\n");
8905 ssanames_print_statistics ();
8906 fprintf (stderr
, "\n");
8907 phinodes_print_statistics ();
8908 fprintf (stderr
, "\n");
8911 fprintf (stderr
, "(No per-node statistics)\n");
8913 print_type_hash_statistics ();
8914 print_debug_expr_statistics ();
8915 print_value_expr_statistics ();
8916 lang_hooks
.print_statistics ();
8919 #define FILE_FUNCTION_FORMAT "_GLOBAL__%s_%s"
8921 /* Generate a crc32 of the low BYTES bytes of VALUE. */
8924 crc32_unsigned_n (unsigned chksum
, unsigned value
, unsigned bytes
)
8926 /* This relies on the raw feedback's top 4 bits being zero. */
8927 #define FEEDBACK(X) ((X) * 0x04c11db7)
8928 #define SYNDROME(X) (FEEDBACK ((X) & 1) ^ FEEDBACK ((X) & 2) \
8929 ^ FEEDBACK ((X) & 4) ^ FEEDBACK ((X) & 8))
8930 static const unsigned syndromes
[16] =
8932 SYNDROME(0x0), SYNDROME(0x1), SYNDROME(0x2), SYNDROME(0x3),
8933 SYNDROME(0x4), SYNDROME(0x5), SYNDROME(0x6), SYNDROME(0x7),
8934 SYNDROME(0x8), SYNDROME(0x9), SYNDROME(0xa), SYNDROME(0xb),
8935 SYNDROME(0xc), SYNDROME(0xd), SYNDROME(0xe), SYNDROME(0xf),
8940 value
<<= (32 - bytes
* 8);
8941 for (unsigned ix
= bytes
* 2; ix
--; value
<<= 4)
8943 unsigned feedback
= syndromes
[((value
^ chksum
) >> 28) & 0xf];
8945 chksum
= (chksum
<< 4) ^ feedback
;
8951 /* Generate a crc32 of a string. */
8954 crc32_string (unsigned chksum
, const char *string
)
8957 chksum
= crc32_byte (chksum
, *string
);
8962 /* P is a string that will be used in a symbol. Mask out any characters
8963 that are not valid in that context. */
8966 clean_symbol_name (char *p
)
8970 #ifndef NO_DOLLAR_IN_LABEL /* this for `$'; unlikely, but... -- kr */
8973 #ifndef NO_DOT_IN_LABEL /* this for `.'; unlikely, but... */
8980 /* For anonymous aggregate types, we need some sort of name to
8981 hold on to. In practice, this should not appear, but it should
8982 not be harmful if it does. */
8984 anon_aggrname_p(const_tree id_node
)
8986 #ifndef NO_DOT_IN_LABEL
8987 return (IDENTIFIER_POINTER (id_node
)[0] == '.'
8988 && IDENTIFIER_POINTER (id_node
)[1] == '_');
8989 #else /* NO_DOT_IN_LABEL */
8990 #ifndef NO_DOLLAR_IN_LABEL
8991 return (IDENTIFIER_POINTER (id_node
)[0] == '$' \
8992 && IDENTIFIER_POINTER (id_node
)[1] == '_');
8993 #else /* NO_DOLLAR_IN_LABEL */
8994 #define ANON_AGGRNAME_PREFIX "__anon_"
8995 return (!strncmp (IDENTIFIER_POINTER (id_node
), ANON_AGGRNAME_PREFIX
,
8996 sizeof (ANON_AGGRNAME_PREFIX
) - 1));
8997 #endif /* NO_DOLLAR_IN_LABEL */
8998 #endif /* NO_DOT_IN_LABEL */
9001 /* Return a format for an anonymous aggregate name. */
9003 anon_aggrname_format()
9005 #ifndef NO_DOT_IN_LABEL
9007 #else /* NO_DOT_IN_LABEL */
9008 #ifndef NO_DOLLAR_IN_LABEL
9010 #else /* NO_DOLLAR_IN_LABEL */
9012 #endif /* NO_DOLLAR_IN_LABEL */
9013 #endif /* NO_DOT_IN_LABEL */
9016 /* Generate a name for a special-purpose function.
9017 The generated name may need to be unique across the whole link.
9018 Changes to this function may also require corresponding changes to
9019 xstrdup_mask_random.
9020 TYPE is some string to identify the purpose of this function to the
9021 linker or collect2; it must start with an uppercase letter,
9023 I - for constructors
9025 N - for C++ anonymous namespaces
9026 F - for DWARF unwind frame information. */
9029 get_file_function_name (const char *type
)
9035 /* If we already have a name we know to be unique, just use that. */
9036 if (first_global_object_name
)
9037 p
= q
= ASTRDUP (first_global_object_name
);
9038 /* If the target is handling the constructors/destructors, they
9039 will be local to this file and the name is only necessary for
9041 We also assign sub_I and sub_D sufixes to constructors called from
9042 the global static constructors. These are always local. */
9043 else if (((type
[0] == 'I' || type
[0] == 'D') && targetm
.have_ctors_dtors
)
9044 || (strncmp (type
, "sub_", 4) == 0
9045 && (type
[4] == 'I' || type
[4] == 'D')))
9047 const char *file
= main_input_filename
;
9049 file
= LOCATION_FILE (input_location
);
9050 /* Just use the file's basename, because the full pathname
9051 might be quite long. */
9052 p
= q
= ASTRDUP (lbasename (file
));
9056 /* Otherwise, the name must be unique across the entire link.
9057 We don't have anything that we know to be unique to this translation
9058 unit, so use what we do have and throw in some randomness. */
9060 const char *name
= weak_global_object_name
;
9061 const char *file
= main_input_filename
;
9066 file
= LOCATION_FILE (input_location
);
9068 len
= strlen (file
);
9069 q
= (char *) alloca (9 + 19 + len
+ 1);
9070 memcpy (q
, file
, len
+ 1);
9072 snprintf (q
+ len
, 9 + 19 + 1, "_%08X_" HOST_WIDE_INT_PRINT_HEX
,
9073 crc32_string (0, name
), get_random_seed (false));
9078 clean_symbol_name (q
);
9079 buf
= (char *) alloca (sizeof (FILE_FUNCTION_FORMAT
) + strlen (p
)
9082 /* Set up the name of the file-level functions we may need.
9083 Use a global object (which is already required to be unique over
9084 the program) rather than the file name (which imposes extra
9086 sprintf (buf
, FILE_FUNCTION_FORMAT
, type
, p
);
9088 return get_identifier (buf
);
9091 #if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
9093 /* Complain that the tree code of NODE does not match the expected 0
9094 terminated list of trailing codes. The trailing code list can be
9095 empty, for a more vague error message. FILE, LINE, and FUNCTION
9096 are of the caller. */
9099 tree_check_failed (const_tree node
, const char *file
,
9100 int line
, const char *function
, ...)
9104 unsigned length
= 0;
9105 enum tree_code code
;
9107 va_start (args
, function
);
9108 while ((code
= (enum tree_code
) va_arg (args
, int)))
9109 length
+= 4 + strlen (get_tree_code_name (code
));
9114 va_start (args
, function
);
9115 length
+= strlen ("expected ");
9116 buffer
= tmp
= (char *) alloca (length
);
9118 while ((code
= (enum tree_code
) va_arg (args
, int)))
9120 const char *prefix
= length
? " or " : "expected ";
9122 strcpy (tmp
+ length
, prefix
);
9123 length
+= strlen (prefix
);
9124 strcpy (tmp
+ length
, get_tree_code_name (code
));
9125 length
+= strlen (get_tree_code_name (code
));
9130 buffer
= "unexpected node";
9132 internal_error ("tree check: %s, have %s in %s, at %s:%d",
9133 buffer
, get_tree_code_name (TREE_CODE (node
)),
9134 function
, trim_filename (file
), line
);
9137 /* Complain that the tree code of NODE does match the expected 0
9138 terminated list of trailing codes. FILE, LINE, and FUNCTION are of
9142 tree_not_check_failed (const_tree node
, const char *file
,
9143 int line
, const char *function
, ...)
9147 unsigned length
= 0;
9148 enum tree_code code
;
9150 va_start (args
, function
);
9151 while ((code
= (enum tree_code
) va_arg (args
, int)))
9152 length
+= 4 + strlen (get_tree_code_name (code
));
9154 va_start (args
, function
);
9155 buffer
= (char *) alloca (length
);
9157 while ((code
= (enum tree_code
) va_arg (args
, int)))
9161 strcpy (buffer
+ length
, " or ");
9164 strcpy (buffer
+ length
, get_tree_code_name (code
));
9165 length
+= strlen (get_tree_code_name (code
));
9169 internal_error ("tree check: expected none of %s, have %s in %s, at %s:%d",
9170 buffer
, get_tree_code_name (TREE_CODE (node
)),
9171 function
, trim_filename (file
), line
);
9174 /* Similar to tree_check_failed, except that we check for a class of tree
9175 code, given in CL. */
9178 tree_class_check_failed (const_tree node
, const enum tree_code_class cl
,
9179 const char *file
, int line
, const char *function
)
9182 ("tree check: expected class %qs, have %qs (%s) in %s, at %s:%d",
9183 TREE_CODE_CLASS_STRING (cl
),
9184 TREE_CODE_CLASS_STRING (TREE_CODE_CLASS (TREE_CODE (node
))),
9185 get_tree_code_name (TREE_CODE (node
)), function
, trim_filename (file
), line
);
9188 /* Similar to tree_check_failed, except that instead of specifying a
9189 dozen codes, use the knowledge that they're all sequential. */
9192 tree_range_check_failed (const_tree node
, const char *file
, int line
,
9193 const char *function
, enum tree_code c1
,
9197 unsigned length
= 0;
9200 for (c
= c1
; c
<= c2
; ++c
)
9201 length
+= 4 + strlen (get_tree_code_name ((enum tree_code
) c
));
9203 length
+= strlen ("expected ");
9204 buffer
= (char *) alloca (length
);
9207 for (c
= c1
; c
<= c2
; ++c
)
9209 const char *prefix
= length
? " or " : "expected ";
9211 strcpy (buffer
+ length
, prefix
);
9212 length
+= strlen (prefix
);
9213 strcpy (buffer
+ length
, get_tree_code_name ((enum tree_code
) c
));
9214 length
+= strlen (get_tree_code_name ((enum tree_code
) c
));
9217 internal_error ("tree check: %s, have %s in %s, at %s:%d",
9218 buffer
, get_tree_code_name (TREE_CODE (node
)),
9219 function
, trim_filename (file
), line
);
9223 /* Similar to tree_check_failed, except that we check that a tree does
9224 not have the specified code, given in CL. */
9227 tree_not_class_check_failed (const_tree node
, const enum tree_code_class cl
,
9228 const char *file
, int line
, const char *function
)
9231 ("tree check: did not expect class %qs, have %qs (%s) in %s, at %s:%d",
9232 TREE_CODE_CLASS_STRING (cl
),
9233 TREE_CODE_CLASS_STRING (TREE_CODE_CLASS (TREE_CODE (node
))),
9234 get_tree_code_name (TREE_CODE (node
)), function
, trim_filename (file
), line
);
9238 /* Similar to tree_check_failed but applied to OMP_CLAUSE codes. */
9241 omp_clause_check_failed (const_tree node
, const char *file
, int line
,
9242 const char *function
, enum omp_clause_code code
)
9244 internal_error ("tree check: expected omp_clause %s, have %s in %s, at %s:%d",
9245 omp_clause_code_name
[code
], get_tree_code_name (TREE_CODE (node
)),
9246 function
, trim_filename (file
), line
);
9250 /* Similar to tree_range_check_failed but applied to OMP_CLAUSE codes. */
9253 omp_clause_range_check_failed (const_tree node
, const char *file
, int line
,
9254 const char *function
, enum omp_clause_code c1
,
9255 enum omp_clause_code c2
)
9258 unsigned length
= 0;
9261 for (c
= c1
; c
<= c2
; ++c
)
9262 length
+= 4 + strlen (omp_clause_code_name
[c
]);
9264 length
+= strlen ("expected ");
9265 buffer
= (char *) alloca (length
);
9268 for (c
= c1
; c
<= c2
; ++c
)
9270 const char *prefix
= length
? " or " : "expected ";
9272 strcpy (buffer
+ length
, prefix
);
9273 length
+= strlen (prefix
);
9274 strcpy (buffer
+ length
, omp_clause_code_name
[c
]);
9275 length
+= strlen (omp_clause_code_name
[c
]);
9278 internal_error ("tree check: %s, have %s in %s, at %s:%d",
9279 buffer
, omp_clause_code_name
[TREE_CODE (node
)],
9280 function
, trim_filename (file
), line
);
9284 #undef DEFTREESTRUCT
9285 #define DEFTREESTRUCT(VAL, NAME) NAME,
9287 static const char *ts_enum_names
[] = {
9288 #include "treestruct.def"
9290 #undef DEFTREESTRUCT
9292 #define TS_ENUM_NAME(EN) (ts_enum_names[(EN)])
9294 /* Similar to tree_class_check_failed, except that we check for
9295 whether CODE contains the tree structure identified by EN. */
9298 tree_contains_struct_check_failed (const_tree node
,
9299 const enum tree_node_structure_enum en
,
9300 const char *file
, int line
,
9301 const char *function
)
9304 ("tree check: expected tree that contains %qs structure, have %qs in %s, at %s:%d",
9306 get_tree_code_name (TREE_CODE (node
)), function
, trim_filename (file
), line
);
9310 /* Similar to above, except that the check is for the bounds of a TREE_VEC's
9311 (dynamically sized) vector. */
9314 tree_int_cst_elt_check_failed (int idx
, int len
, const char *file
, int line
,
9315 const char *function
)
9318 ("tree check: accessed elt %d of tree_int_cst with %d elts in %s, at %s:%d",
9319 idx
+ 1, len
, function
, trim_filename (file
), line
);
9322 /* Similar to above, except that the check is for the bounds of a TREE_VEC's
9323 (dynamically sized) vector. */
9326 tree_vec_elt_check_failed (int idx
, int len
, const char *file
, int line
,
9327 const char *function
)
9330 ("tree check: accessed elt %d of tree_vec with %d elts in %s, at %s:%d",
9331 idx
+ 1, len
, function
, trim_filename (file
), line
);
9334 /* Similar to above, except that the check is for the bounds of the operand
9335 vector of an expression node EXP. */
9338 tree_operand_check_failed (int idx
, const_tree exp
, const char *file
,
9339 int line
, const char *function
)
9341 enum tree_code code
= TREE_CODE (exp
);
9343 ("tree check: accessed operand %d of %s with %d operands in %s, at %s:%d",
9344 idx
+ 1, get_tree_code_name (code
), TREE_OPERAND_LENGTH (exp
),
9345 function
, trim_filename (file
), line
);
9348 /* Similar to above, except that the check is for the number of
9349 operands of an OMP_CLAUSE node. */
9352 omp_clause_operand_check_failed (int idx
, const_tree t
, const char *file
,
9353 int line
, const char *function
)
9356 ("tree check: accessed operand %d of omp_clause %s with %d operands "
9357 "in %s, at %s:%d", idx
+ 1, omp_clause_code_name
[OMP_CLAUSE_CODE (t
)],
9358 omp_clause_num_ops
[OMP_CLAUSE_CODE (t
)], function
,
9359 trim_filename (file
), line
);
9361 #endif /* ENABLE_TREE_CHECKING */
9363 /* Create a new vector type node holding SUBPARTS units of type INNERTYPE,
9364 and mapped to the machine mode MODE. Initialize its fields and build
9365 the information necessary for debugging output. */
9368 make_vector_type (tree innertype
, int nunits
, machine_mode mode
)
9371 tree mv_innertype
= TYPE_MAIN_VARIANT (innertype
);
9373 t
= make_node (VECTOR_TYPE
);
9374 TREE_TYPE (t
) = mv_innertype
;
9375 SET_TYPE_VECTOR_SUBPARTS (t
, nunits
);
9376 SET_TYPE_MODE (t
, mode
);
9378 if (TYPE_STRUCTURAL_EQUALITY_P (mv_innertype
) || in_lto_p
)
9379 SET_TYPE_STRUCTURAL_EQUALITY (t
);
9380 else if ((TYPE_CANONICAL (mv_innertype
) != innertype
9381 || mode
!= VOIDmode
)
9382 && !VECTOR_BOOLEAN_TYPE_P (t
))
9384 = make_vector_type (TYPE_CANONICAL (mv_innertype
), nunits
, VOIDmode
);
9388 hashval_t hash
= type_hash_canon_hash (t
);
9389 t
= type_hash_canon (hash
, t
);
9391 /* We have built a main variant, based on the main variant of the
9392 inner type. Use it to build the variant we return. */
9393 if ((TYPE_ATTRIBUTES (innertype
) || TYPE_QUALS (innertype
))
9394 && TREE_TYPE (t
) != innertype
)
9395 return build_type_attribute_qual_variant (t
,
9396 TYPE_ATTRIBUTES (innertype
),
9397 TYPE_QUALS (innertype
));
9403 make_or_reuse_type (unsigned size
, int unsignedp
)
9407 if (size
== INT_TYPE_SIZE
)
9408 return unsignedp
? unsigned_type_node
: integer_type_node
;
9409 if (size
== CHAR_TYPE_SIZE
)
9410 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
9411 if (size
== SHORT_TYPE_SIZE
)
9412 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
9413 if (size
== LONG_TYPE_SIZE
)
9414 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
9415 if (size
== LONG_LONG_TYPE_SIZE
)
9416 return (unsignedp
? long_long_unsigned_type_node
9417 : long_long_integer_type_node
);
9419 for (i
= 0; i
< NUM_INT_N_ENTS
; i
++)
9420 if (size
== int_n_data
[i
].bitsize
9421 && int_n_enabled_p
[i
])
9422 return (unsignedp
? int_n_trees
[i
].unsigned_type
9423 : int_n_trees
[i
].signed_type
);
9426 return make_unsigned_type (size
);
9428 return make_signed_type (size
);
9431 /* Create or reuse a fract type by SIZE, UNSIGNEDP, and SATP. */
9434 make_or_reuse_fract_type (unsigned size
, int unsignedp
, int satp
)
9438 if (size
== SHORT_FRACT_TYPE_SIZE
)
9439 return unsignedp
? sat_unsigned_short_fract_type_node
9440 : sat_short_fract_type_node
;
9441 if (size
== FRACT_TYPE_SIZE
)
9442 return unsignedp
? sat_unsigned_fract_type_node
: sat_fract_type_node
;
9443 if (size
== LONG_FRACT_TYPE_SIZE
)
9444 return unsignedp
? sat_unsigned_long_fract_type_node
9445 : sat_long_fract_type_node
;
9446 if (size
== LONG_LONG_FRACT_TYPE_SIZE
)
9447 return unsignedp
? sat_unsigned_long_long_fract_type_node
9448 : sat_long_long_fract_type_node
;
9452 if (size
== SHORT_FRACT_TYPE_SIZE
)
9453 return unsignedp
? unsigned_short_fract_type_node
9454 : short_fract_type_node
;
9455 if (size
== FRACT_TYPE_SIZE
)
9456 return unsignedp
? unsigned_fract_type_node
: fract_type_node
;
9457 if (size
== LONG_FRACT_TYPE_SIZE
)
9458 return unsignedp
? unsigned_long_fract_type_node
9459 : long_fract_type_node
;
9460 if (size
== LONG_LONG_FRACT_TYPE_SIZE
)
9461 return unsignedp
? unsigned_long_long_fract_type_node
9462 : long_long_fract_type_node
;
9465 return make_fract_type (size
, unsignedp
, satp
);
9468 /* Create or reuse an accum type by SIZE, UNSIGNEDP, and SATP. */
9471 make_or_reuse_accum_type (unsigned size
, int unsignedp
, int satp
)
9475 if (size
== SHORT_ACCUM_TYPE_SIZE
)
9476 return unsignedp
? sat_unsigned_short_accum_type_node
9477 : sat_short_accum_type_node
;
9478 if (size
== ACCUM_TYPE_SIZE
)
9479 return unsignedp
? sat_unsigned_accum_type_node
: sat_accum_type_node
;
9480 if (size
== LONG_ACCUM_TYPE_SIZE
)
9481 return unsignedp
? sat_unsigned_long_accum_type_node
9482 : sat_long_accum_type_node
;
9483 if (size
== LONG_LONG_ACCUM_TYPE_SIZE
)
9484 return unsignedp
? sat_unsigned_long_long_accum_type_node
9485 : sat_long_long_accum_type_node
;
9489 if (size
== SHORT_ACCUM_TYPE_SIZE
)
9490 return unsignedp
? unsigned_short_accum_type_node
9491 : short_accum_type_node
;
9492 if (size
== ACCUM_TYPE_SIZE
)
9493 return unsignedp
? unsigned_accum_type_node
: accum_type_node
;
9494 if (size
== LONG_ACCUM_TYPE_SIZE
)
9495 return unsignedp
? unsigned_long_accum_type_node
9496 : long_accum_type_node
;
9497 if (size
== LONG_LONG_ACCUM_TYPE_SIZE
)
9498 return unsignedp
? unsigned_long_long_accum_type_node
9499 : long_long_accum_type_node
;
9502 return make_accum_type (size
, unsignedp
, satp
);
9506 /* Create an atomic variant node for TYPE. This routine is called
9507 during initialization of data types to create the 5 basic atomic
9508 types. The generic build_variant_type function requires these to
9509 already be set up in order to function properly, so cannot be
9510 called from there. If ALIGN is non-zero, then ensure alignment is
9511 overridden to this value. */
9514 build_atomic_base (tree type
, unsigned int align
)
9518 /* Make sure its not already registered. */
9519 if ((t
= get_qualified_type (type
, TYPE_QUAL_ATOMIC
)))
9522 t
= build_variant_type_copy (type
);
9523 set_type_quals (t
, TYPE_QUAL_ATOMIC
);
9526 SET_TYPE_ALIGN (t
, align
);
9531 /* Information about the _FloatN and _FloatNx types. This must be in
9532 the same order as the corresponding TI_* enum values. */
9533 const floatn_type_info floatn_nx_types
[NUM_FLOATN_NX_TYPES
] =
9545 /* Create nodes for all integer types (and error_mark_node) using the sizes
9546 of C datatypes. SIGNED_CHAR specifies whether char is signed. */
9549 build_common_tree_nodes (bool signed_char
)
9553 error_mark_node
= make_node (ERROR_MARK
);
9554 TREE_TYPE (error_mark_node
) = error_mark_node
;
9556 initialize_sizetypes ();
9558 /* Define both `signed char' and `unsigned char'. */
9559 signed_char_type_node
= make_signed_type (CHAR_TYPE_SIZE
);
9560 TYPE_STRING_FLAG (signed_char_type_node
) = 1;
9561 unsigned_char_type_node
= make_unsigned_type (CHAR_TYPE_SIZE
);
9562 TYPE_STRING_FLAG (unsigned_char_type_node
) = 1;
9564 /* Define `char', which is like either `signed char' or `unsigned char'
9565 but not the same as either. */
9568 ? make_signed_type (CHAR_TYPE_SIZE
)
9569 : make_unsigned_type (CHAR_TYPE_SIZE
));
9570 TYPE_STRING_FLAG (char_type_node
) = 1;
9572 short_integer_type_node
= make_signed_type (SHORT_TYPE_SIZE
);
9573 short_unsigned_type_node
= make_unsigned_type (SHORT_TYPE_SIZE
);
9574 integer_type_node
= make_signed_type (INT_TYPE_SIZE
);
9575 unsigned_type_node
= make_unsigned_type (INT_TYPE_SIZE
);
9576 long_integer_type_node
= make_signed_type (LONG_TYPE_SIZE
);
9577 long_unsigned_type_node
= make_unsigned_type (LONG_TYPE_SIZE
);
9578 long_long_integer_type_node
= make_signed_type (LONG_LONG_TYPE_SIZE
);
9579 long_long_unsigned_type_node
= make_unsigned_type (LONG_LONG_TYPE_SIZE
);
9581 for (i
= 0; i
< NUM_INT_N_ENTS
; i
++)
9583 int_n_trees
[i
].signed_type
= make_signed_type (int_n_data
[i
].bitsize
);
9584 int_n_trees
[i
].unsigned_type
= make_unsigned_type (int_n_data
[i
].bitsize
);
9585 TYPE_SIZE (int_n_trees
[i
].signed_type
) = bitsize_int (int_n_data
[i
].bitsize
);
9586 TYPE_SIZE (int_n_trees
[i
].unsigned_type
) = bitsize_int (int_n_data
[i
].bitsize
);
9588 if (int_n_data
[i
].bitsize
> LONG_LONG_TYPE_SIZE
9589 && int_n_enabled_p
[i
])
9591 integer_types
[itk_intN_0
+ i
* 2] = int_n_trees
[i
].signed_type
;
9592 integer_types
[itk_unsigned_intN_0
+ i
* 2] = int_n_trees
[i
].unsigned_type
;
9596 /* Define a boolean type. This type only represents boolean values but
9597 may be larger than char depending on the value of BOOL_TYPE_SIZE. */
9598 boolean_type_node
= make_unsigned_type (BOOL_TYPE_SIZE
);
9599 TREE_SET_CODE (boolean_type_node
, BOOLEAN_TYPE
);
9600 TYPE_PRECISION (boolean_type_node
) = 1;
9601 TYPE_MAX_VALUE (boolean_type_node
) = build_int_cst (boolean_type_node
, 1);
9603 /* Define what type to use for size_t. */
9604 if (strcmp (SIZE_TYPE
, "unsigned int") == 0)
9605 size_type_node
= unsigned_type_node
;
9606 else if (strcmp (SIZE_TYPE
, "long unsigned int") == 0)
9607 size_type_node
= long_unsigned_type_node
;
9608 else if (strcmp (SIZE_TYPE
, "long long unsigned int") == 0)
9609 size_type_node
= long_long_unsigned_type_node
;
9610 else if (strcmp (SIZE_TYPE
, "short unsigned int") == 0)
9611 size_type_node
= short_unsigned_type_node
;
9616 size_type_node
= NULL_TREE
;
9617 for (i
= 0; i
< NUM_INT_N_ENTS
; i
++)
9618 if (int_n_enabled_p
[i
])
9621 sprintf (name
, "__int%d unsigned", int_n_data
[i
].bitsize
);
9623 if (strcmp (name
, SIZE_TYPE
) == 0)
9625 size_type_node
= int_n_trees
[i
].unsigned_type
;
9628 if (size_type_node
== NULL_TREE
)
9632 /* Define what type to use for ptrdiff_t. */
9633 if (strcmp (PTRDIFF_TYPE
, "int") == 0)
9634 ptrdiff_type_node
= integer_type_node
;
9635 else if (strcmp (PTRDIFF_TYPE
, "long int") == 0)
9636 ptrdiff_type_node
= long_integer_type_node
;
9637 else if (strcmp (PTRDIFF_TYPE
, "long long int") == 0)
9638 ptrdiff_type_node
= long_long_integer_type_node
;
9639 else if (strcmp (PTRDIFF_TYPE
, "short int") == 0)
9640 ptrdiff_type_node
= short_integer_type_node
;
9643 ptrdiff_type_node
= NULL_TREE
;
9644 for (int i
= 0; i
< NUM_INT_N_ENTS
; i
++)
9645 if (int_n_enabled_p
[i
])
9648 sprintf (name
, "__int%d", int_n_data
[i
].bitsize
);
9649 if (strcmp (name
, PTRDIFF_TYPE
) == 0)
9650 ptrdiff_type_node
= int_n_trees
[i
].signed_type
;
9652 if (ptrdiff_type_node
== NULL_TREE
)
9656 /* Fill in the rest of the sized types. Reuse existing type nodes
9658 intQI_type_node
= make_or_reuse_type (GET_MODE_BITSIZE (QImode
), 0);
9659 intHI_type_node
= make_or_reuse_type (GET_MODE_BITSIZE (HImode
), 0);
9660 intSI_type_node
= make_or_reuse_type (GET_MODE_BITSIZE (SImode
), 0);
9661 intDI_type_node
= make_or_reuse_type (GET_MODE_BITSIZE (DImode
), 0);
9662 intTI_type_node
= make_or_reuse_type (GET_MODE_BITSIZE (TImode
), 0);
9664 unsigned_intQI_type_node
= make_or_reuse_type (GET_MODE_BITSIZE (QImode
), 1);
9665 unsigned_intHI_type_node
= make_or_reuse_type (GET_MODE_BITSIZE (HImode
), 1);
9666 unsigned_intSI_type_node
= make_or_reuse_type (GET_MODE_BITSIZE (SImode
), 1);
9667 unsigned_intDI_type_node
= make_or_reuse_type (GET_MODE_BITSIZE (DImode
), 1);
9668 unsigned_intTI_type_node
= make_or_reuse_type (GET_MODE_BITSIZE (TImode
), 1);
9670 /* Don't call build_qualified type for atomics. That routine does
9671 special processing for atomics, and until they are initialized
9672 it's better not to make that call.
9674 Check to see if there is a target override for atomic types. */
9676 atomicQI_type_node
= build_atomic_base (unsigned_intQI_type_node
,
9677 targetm
.atomic_align_for_mode (QImode
));
9678 atomicHI_type_node
= build_atomic_base (unsigned_intHI_type_node
,
9679 targetm
.atomic_align_for_mode (HImode
));
9680 atomicSI_type_node
= build_atomic_base (unsigned_intSI_type_node
,
9681 targetm
.atomic_align_for_mode (SImode
));
9682 atomicDI_type_node
= build_atomic_base (unsigned_intDI_type_node
,
9683 targetm
.atomic_align_for_mode (DImode
));
9684 atomicTI_type_node
= build_atomic_base (unsigned_intTI_type_node
,
9685 targetm
.atomic_align_for_mode (TImode
));
9687 access_public_node
= get_identifier ("public");
9688 access_protected_node
= get_identifier ("protected");
9689 access_private_node
= get_identifier ("private");
9691 /* Define these next since types below may used them. */
9692 integer_zero_node
= build_int_cst (integer_type_node
, 0);
9693 integer_one_node
= build_int_cst (integer_type_node
, 1);
9694 integer_three_node
= build_int_cst (integer_type_node
, 3);
9695 integer_minus_one_node
= build_int_cst (integer_type_node
, -1);
9697 size_zero_node
= size_int (0);
9698 size_one_node
= size_int (1);
9699 bitsize_zero_node
= bitsize_int (0);
9700 bitsize_one_node
= bitsize_int (1);
9701 bitsize_unit_node
= bitsize_int (BITS_PER_UNIT
);
9703 boolean_false_node
= TYPE_MIN_VALUE (boolean_type_node
);
9704 boolean_true_node
= TYPE_MAX_VALUE (boolean_type_node
);
9706 void_type_node
= make_node (VOID_TYPE
);
9707 layout_type (void_type_node
);
9709 pointer_bounds_type_node
= targetm
.chkp_bound_type ();
9711 /* We are not going to have real types in C with less than byte alignment,
9712 so we might as well not have any types that claim to have it. */
9713 SET_TYPE_ALIGN (void_type_node
, BITS_PER_UNIT
);
9714 TYPE_USER_ALIGN (void_type_node
) = 0;
9716 void_node
= make_node (VOID_CST
);
9717 TREE_TYPE (void_node
) = void_type_node
;
9719 null_pointer_node
= build_int_cst (build_pointer_type (void_type_node
), 0);
9720 layout_type (TREE_TYPE (null_pointer_node
));
9722 ptr_type_node
= build_pointer_type (void_type_node
);
9724 = build_pointer_type (build_type_variant (void_type_node
, 1, 0));
9725 for (unsigned i
= 0;
9726 i
< sizeof (builtin_structptr_types
) / sizeof (builtin_structptr_type
);
9728 builtin_structptr_types
[i
].node
= builtin_structptr_types
[i
].base
;
9730 pointer_sized_int_node
= build_nonstandard_integer_type (POINTER_SIZE
, 1);
9732 float_type_node
= make_node (REAL_TYPE
);
9733 TYPE_PRECISION (float_type_node
) = FLOAT_TYPE_SIZE
;
9734 layout_type (float_type_node
);
9736 double_type_node
= make_node (REAL_TYPE
);
9737 TYPE_PRECISION (double_type_node
) = DOUBLE_TYPE_SIZE
;
9738 layout_type (double_type_node
);
9740 long_double_type_node
= make_node (REAL_TYPE
);
9741 TYPE_PRECISION (long_double_type_node
) = LONG_DOUBLE_TYPE_SIZE
;
9742 layout_type (long_double_type_node
);
9744 for (i
= 0; i
< NUM_FLOATN_NX_TYPES
; i
++)
9746 int n
= floatn_nx_types
[i
].n
;
9747 bool extended
= floatn_nx_types
[i
].extended
;
9748 scalar_float_mode mode
;
9749 if (!targetm
.floatn_mode (n
, extended
).exists (&mode
))
9751 int precision
= GET_MODE_PRECISION (mode
);
9752 /* Work around the rs6000 KFmode having precision 113 not
9754 const struct real_format
*fmt
= REAL_MODE_FORMAT (mode
);
9755 gcc_assert (fmt
->b
== 2 && fmt
->emin
+ fmt
->emax
== 3);
9756 int min_precision
= fmt
->p
+ ceil_log2 (fmt
->emax
- fmt
->emin
);
9758 gcc_assert (min_precision
== n
);
9759 if (precision
< min_precision
)
9760 precision
= min_precision
;
9761 FLOATN_NX_TYPE_NODE (i
) = make_node (REAL_TYPE
);
9762 TYPE_PRECISION (FLOATN_NX_TYPE_NODE (i
)) = precision
;
9763 layout_type (FLOATN_NX_TYPE_NODE (i
));
9764 SET_TYPE_MODE (FLOATN_NX_TYPE_NODE (i
), mode
);
9767 float_ptr_type_node
= build_pointer_type (float_type_node
);
9768 double_ptr_type_node
= build_pointer_type (double_type_node
);
9769 long_double_ptr_type_node
= build_pointer_type (long_double_type_node
);
9770 integer_ptr_type_node
= build_pointer_type (integer_type_node
);
9772 /* Fixed size integer types. */
9773 uint16_type_node
= make_or_reuse_type (16, 1);
9774 uint32_type_node
= make_or_reuse_type (32, 1);
9775 uint64_type_node
= make_or_reuse_type (64, 1);
9777 /* Decimal float types. */
9778 dfloat32_type_node
= make_node (REAL_TYPE
);
9779 TYPE_PRECISION (dfloat32_type_node
) = DECIMAL32_TYPE_SIZE
;
9780 SET_TYPE_MODE (dfloat32_type_node
, SDmode
);
9781 layout_type (dfloat32_type_node
);
9782 dfloat32_ptr_type_node
= build_pointer_type (dfloat32_type_node
);
9784 dfloat64_type_node
= make_node (REAL_TYPE
);
9785 TYPE_PRECISION (dfloat64_type_node
) = DECIMAL64_TYPE_SIZE
;
9786 SET_TYPE_MODE (dfloat64_type_node
, DDmode
);
9787 layout_type (dfloat64_type_node
);
9788 dfloat64_ptr_type_node
= build_pointer_type (dfloat64_type_node
);
9790 dfloat128_type_node
= make_node (REAL_TYPE
);
9791 TYPE_PRECISION (dfloat128_type_node
) = DECIMAL128_TYPE_SIZE
;
9792 SET_TYPE_MODE (dfloat128_type_node
, TDmode
);
9793 layout_type (dfloat128_type_node
);
9794 dfloat128_ptr_type_node
= build_pointer_type (dfloat128_type_node
);
9796 complex_integer_type_node
= build_complex_type (integer_type_node
, true);
9797 complex_float_type_node
= build_complex_type (float_type_node
, true);
9798 complex_double_type_node
= build_complex_type (double_type_node
, true);
9799 complex_long_double_type_node
= build_complex_type (long_double_type_node
,
9802 for (i
= 0; i
< NUM_FLOATN_NX_TYPES
; i
++)
9804 if (FLOATN_NX_TYPE_NODE (i
) != NULL_TREE
)
9805 COMPLEX_FLOATN_NX_TYPE_NODE (i
)
9806 = build_complex_type (FLOATN_NX_TYPE_NODE (i
));
9809 /* Make fixed-point nodes based on sat/non-sat and signed/unsigned. */
9810 #define MAKE_FIXED_TYPE_NODE(KIND,SIZE) \
9811 sat_ ## KIND ## _type_node = \
9812 make_sat_signed_ ## KIND ## _type (SIZE); \
9813 sat_unsigned_ ## KIND ## _type_node = \
9814 make_sat_unsigned_ ## KIND ## _type (SIZE); \
9815 KIND ## _type_node = make_signed_ ## KIND ## _type (SIZE); \
9816 unsigned_ ## KIND ## _type_node = \
9817 make_unsigned_ ## KIND ## _type (SIZE);
9819 #define MAKE_FIXED_TYPE_NODE_WIDTH(KIND,WIDTH,SIZE) \
9820 sat_ ## WIDTH ## KIND ## _type_node = \
9821 make_sat_signed_ ## KIND ## _type (SIZE); \
9822 sat_unsigned_ ## WIDTH ## KIND ## _type_node = \
9823 make_sat_unsigned_ ## KIND ## _type (SIZE); \
9824 WIDTH ## KIND ## _type_node = make_signed_ ## KIND ## _type (SIZE); \
9825 unsigned_ ## WIDTH ## KIND ## _type_node = \
9826 make_unsigned_ ## KIND ## _type (SIZE);
9828 /* Make fixed-point type nodes based on four different widths. */
9829 #define MAKE_FIXED_TYPE_NODE_FAMILY(N1,N2) \
9830 MAKE_FIXED_TYPE_NODE_WIDTH (N1, short_, SHORT_ ## N2 ## _TYPE_SIZE) \
9831 MAKE_FIXED_TYPE_NODE (N1, N2 ## _TYPE_SIZE) \
9832 MAKE_FIXED_TYPE_NODE_WIDTH (N1, long_, LONG_ ## N2 ## _TYPE_SIZE) \
9833 MAKE_FIXED_TYPE_NODE_WIDTH (N1, long_long_, LONG_LONG_ ## N2 ## _TYPE_SIZE)
9835 /* Make fixed-point mode nodes based on sat/non-sat and signed/unsigned. */
9836 #define MAKE_FIXED_MODE_NODE(KIND,NAME,MODE) \
9837 NAME ## _type_node = \
9838 make_or_reuse_signed_ ## KIND ## _type (GET_MODE_BITSIZE (MODE ## mode)); \
9839 u ## NAME ## _type_node = \
9840 make_or_reuse_unsigned_ ## KIND ## _type \
9841 (GET_MODE_BITSIZE (U ## MODE ## mode)); \
9842 sat_ ## NAME ## _type_node = \
9843 make_or_reuse_sat_signed_ ## KIND ## _type \
9844 (GET_MODE_BITSIZE (MODE ## mode)); \
9845 sat_u ## NAME ## _type_node = \
9846 make_or_reuse_sat_unsigned_ ## KIND ## _type \
9847 (GET_MODE_BITSIZE (U ## MODE ## mode));
9849 /* Fixed-point type and mode nodes. */
9850 MAKE_FIXED_TYPE_NODE_FAMILY (fract
, FRACT
)
9851 MAKE_FIXED_TYPE_NODE_FAMILY (accum
, ACCUM
)
9852 MAKE_FIXED_MODE_NODE (fract
, qq
, QQ
)
9853 MAKE_FIXED_MODE_NODE (fract
, hq
, HQ
)
9854 MAKE_FIXED_MODE_NODE (fract
, sq
, SQ
)
9855 MAKE_FIXED_MODE_NODE (fract
, dq
, DQ
)
9856 MAKE_FIXED_MODE_NODE (fract
, tq
, TQ
)
9857 MAKE_FIXED_MODE_NODE (accum
, ha
, HA
)
9858 MAKE_FIXED_MODE_NODE (accum
, sa
, SA
)
9859 MAKE_FIXED_MODE_NODE (accum
, da
, DA
)
9860 MAKE_FIXED_MODE_NODE (accum
, ta
, TA
)
9863 tree t
= targetm
.build_builtin_va_list ();
9865 /* Many back-ends define record types without setting TYPE_NAME.
9866 If we copied the record type here, we'd keep the original
9867 record type without a name. This breaks name mangling. So,
9868 don't copy record types and let c_common_nodes_and_builtins()
9869 declare the type to be __builtin_va_list. */
9870 if (TREE_CODE (t
) != RECORD_TYPE
)
9871 t
= build_variant_type_copy (t
);
9873 va_list_type_node
= t
;
9877 /* Modify DECL for given flags.
9878 TM_PURE attribute is set only on types, so the function will modify
9879 DECL's type when ECF_TM_PURE is used. */
9882 set_call_expr_flags (tree decl
, int flags
)
9884 if (flags
& ECF_NOTHROW
)
9885 TREE_NOTHROW (decl
) = 1;
9886 if (flags
& ECF_CONST
)
9887 TREE_READONLY (decl
) = 1;
9888 if (flags
& ECF_PURE
)
9889 DECL_PURE_P (decl
) = 1;
9890 if (flags
& ECF_LOOPING_CONST_OR_PURE
)
9891 DECL_LOOPING_CONST_OR_PURE_P (decl
) = 1;
9892 if (flags
& ECF_NOVOPS
)
9893 DECL_IS_NOVOPS (decl
) = 1;
9894 if (flags
& ECF_NORETURN
)
9895 TREE_THIS_VOLATILE (decl
) = 1;
9896 if (flags
& ECF_MALLOC
)
9897 DECL_IS_MALLOC (decl
) = 1;
9898 if (flags
& ECF_RETURNS_TWICE
)
9899 DECL_IS_RETURNS_TWICE (decl
) = 1;
9900 if (flags
& ECF_LEAF
)
9901 DECL_ATTRIBUTES (decl
) = tree_cons (get_identifier ("leaf"),
9902 NULL
, DECL_ATTRIBUTES (decl
));
9903 if (flags
& ECF_COLD
)
9904 DECL_ATTRIBUTES (decl
) = tree_cons (get_identifier ("cold"),
9905 NULL
, DECL_ATTRIBUTES (decl
));
9906 if (flags
& ECF_RET1
)
9907 DECL_ATTRIBUTES (decl
)
9908 = tree_cons (get_identifier ("fn spec"),
9909 build_tree_list (NULL_TREE
, build_string (1, "1")),
9910 DECL_ATTRIBUTES (decl
));
9911 if ((flags
& ECF_TM_PURE
) && flag_tm
)
9912 apply_tm_attr (decl
, get_identifier ("transaction_pure"));
9913 /* Looping const or pure is implied by noreturn.
9914 There is currently no way to declare looping const or looping pure alone. */
9915 gcc_assert (!(flags
& ECF_LOOPING_CONST_OR_PURE
)
9916 || ((flags
& ECF_NORETURN
) && (flags
& (ECF_CONST
| ECF_PURE
))));
9920 /* A subroutine of build_common_builtin_nodes. Define a builtin function. */
9923 local_define_builtin (const char *name
, tree type
, enum built_in_function code
,
9924 const char *library_name
, int ecf_flags
)
9928 decl
= add_builtin_function (name
, type
, code
, BUILT_IN_NORMAL
,
9929 library_name
, NULL_TREE
);
9930 set_call_expr_flags (decl
, ecf_flags
);
9932 set_builtin_decl (code
, decl
, true);
9935 /* Call this function after instantiating all builtins that the language
9936 front end cares about. This will build the rest of the builtins
9937 and internal functions that are relied upon by the tree optimizers and
9941 build_common_builtin_nodes (void)
9946 if (!builtin_decl_explicit_p (BUILT_IN_UNREACHABLE
)
9947 || !builtin_decl_explicit_p (BUILT_IN_ABORT
))
9949 ftype
= build_function_type (void_type_node
, void_list_node
);
9950 if (!builtin_decl_explicit_p (BUILT_IN_UNREACHABLE
))
9951 local_define_builtin ("__builtin_unreachable", ftype
,
9952 BUILT_IN_UNREACHABLE
,
9953 "__builtin_unreachable",
9954 ECF_NOTHROW
| ECF_LEAF
| ECF_NORETURN
9955 | ECF_CONST
| ECF_COLD
);
9956 if (!builtin_decl_explicit_p (BUILT_IN_ABORT
))
9957 local_define_builtin ("__builtin_abort", ftype
, BUILT_IN_ABORT
,
9959 ECF_LEAF
| ECF_NORETURN
| ECF_CONST
| ECF_COLD
);
9962 if (!builtin_decl_explicit_p (BUILT_IN_MEMCPY
)
9963 || !builtin_decl_explicit_p (BUILT_IN_MEMMOVE
))
9965 ftype
= build_function_type_list (ptr_type_node
,
9966 ptr_type_node
, const_ptr_type_node
,
9967 size_type_node
, NULL_TREE
);
9969 if (!builtin_decl_explicit_p (BUILT_IN_MEMCPY
))
9970 local_define_builtin ("__builtin_memcpy", ftype
, BUILT_IN_MEMCPY
,
9971 "memcpy", ECF_NOTHROW
| ECF_LEAF
| ECF_RET1
);
9972 if (!builtin_decl_explicit_p (BUILT_IN_MEMMOVE
))
9973 local_define_builtin ("__builtin_memmove", ftype
, BUILT_IN_MEMMOVE
,
9974 "memmove", ECF_NOTHROW
| ECF_LEAF
| ECF_RET1
);
9977 if (!builtin_decl_explicit_p (BUILT_IN_MEMCMP
))
9979 ftype
= build_function_type_list (integer_type_node
, const_ptr_type_node
,
9980 const_ptr_type_node
, size_type_node
,
9982 local_define_builtin ("__builtin_memcmp", ftype
, BUILT_IN_MEMCMP
,
9983 "memcmp", ECF_PURE
| ECF_NOTHROW
| ECF_LEAF
);
9986 if (!builtin_decl_explicit_p (BUILT_IN_MEMSET
))
9988 ftype
= build_function_type_list (ptr_type_node
,
9989 ptr_type_node
, integer_type_node
,
9990 size_type_node
, NULL_TREE
);
9991 local_define_builtin ("__builtin_memset", ftype
, BUILT_IN_MEMSET
,
9992 "memset", ECF_NOTHROW
| ECF_LEAF
| ECF_RET1
);
9995 /* If we're checking the stack, `alloca' can throw. */
9996 const int alloca_flags
9997 = ECF_MALLOC
| ECF_LEAF
| (flag_stack_check
? 0 : ECF_NOTHROW
);
9999 if (!builtin_decl_explicit_p (BUILT_IN_ALLOCA
))
10001 ftype
= build_function_type_list (ptr_type_node
,
10002 size_type_node
, NULL_TREE
);
10003 local_define_builtin ("__builtin_alloca", ftype
, BUILT_IN_ALLOCA
,
10004 "alloca", alloca_flags
);
10007 ftype
= build_function_type_list (ptr_type_node
, size_type_node
,
10008 size_type_node
, NULL_TREE
);
10009 local_define_builtin ("__builtin_alloca_with_align", ftype
,
10010 BUILT_IN_ALLOCA_WITH_ALIGN
,
10011 "__builtin_alloca_with_align",
10014 ftype
= build_function_type_list (ptr_type_node
, size_type_node
,
10015 size_type_node
, size_type_node
, NULL_TREE
);
10016 local_define_builtin ("__builtin_alloca_with_align_and_max", ftype
,
10017 BUILT_IN_ALLOCA_WITH_ALIGN_AND_MAX
,
10018 "__builtin_alloca_with_align_and_max",
10021 ftype
= build_function_type_list (void_type_node
,
10022 ptr_type_node
, ptr_type_node
,
10023 ptr_type_node
, NULL_TREE
);
10024 local_define_builtin ("__builtin_init_trampoline", ftype
,
10025 BUILT_IN_INIT_TRAMPOLINE
,
10026 "__builtin_init_trampoline", ECF_NOTHROW
| ECF_LEAF
);
10027 local_define_builtin ("__builtin_init_heap_trampoline", ftype
,
10028 BUILT_IN_INIT_HEAP_TRAMPOLINE
,
10029 "__builtin_init_heap_trampoline",
10030 ECF_NOTHROW
| ECF_LEAF
);
10031 local_define_builtin ("__builtin_init_descriptor", ftype
,
10032 BUILT_IN_INIT_DESCRIPTOR
,
10033 "__builtin_init_descriptor", ECF_NOTHROW
| ECF_LEAF
);
10035 ftype
= build_function_type_list (ptr_type_node
, ptr_type_node
, NULL_TREE
);
10036 local_define_builtin ("__builtin_adjust_trampoline", ftype
,
10037 BUILT_IN_ADJUST_TRAMPOLINE
,
10038 "__builtin_adjust_trampoline",
10039 ECF_CONST
| ECF_NOTHROW
);
10040 local_define_builtin ("__builtin_adjust_descriptor", ftype
,
10041 BUILT_IN_ADJUST_DESCRIPTOR
,
10042 "__builtin_adjust_descriptor",
10043 ECF_CONST
| ECF_NOTHROW
);
10045 ftype
= build_function_type_list (void_type_node
,
10046 ptr_type_node
, ptr_type_node
, NULL_TREE
);
10047 local_define_builtin ("__builtin_nonlocal_goto", ftype
,
10048 BUILT_IN_NONLOCAL_GOTO
,
10049 "__builtin_nonlocal_goto",
10050 ECF_NORETURN
| ECF_NOTHROW
);
10052 ftype
= build_function_type_list (void_type_node
,
10053 ptr_type_node
, ptr_type_node
, NULL_TREE
);
10054 local_define_builtin ("__builtin_setjmp_setup", ftype
,
10055 BUILT_IN_SETJMP_SETUP
,
10056 "__builtin_setjmp_setup", ECF_NOTHROW
);
10058 ftype
= build_function_type_list (void_type_node
, ptr_type_node
, NULL_TREE
);
10059 local_define_builtin ("__builtin_setjmp_receiver", ftype
,
10060 BUILT_IN_SETJMP_RECEIVER
,
10061 "__builtin_setjmp_receiver", ECF_NOTHROW
| ECF_LEAF
);
10063 ftype
= build_function_type_list (ptr_type_node
, NULL_TREE
);
10064 local_define_builtin ("__builtin_stack_save", ftype
, BUILT_IN_STACK_SAVE
,
10065 "__builtin_stack_save", ECF_NOTHROW
| ECF_LEAF
);
10067 ftype
= build_function_type_list (void_type_node
, ptr_type_node
, NULL_TREE
);
10068 local_define_builtin ("__builtin_stack_restore", ftype
,
10069 BUILT_IN_STACK_RESTORE
,
10070 "__builtin_stack_restore", ECF_NOTHROW
| ECF_LEAF
);
10072 ftype
= build_function_type_list (integer_type_node
, const_ptr_type_node
,
10073 const_ptr_type_node
, size_type_node
,
10075 local_define_builtin ("__builtin_memcmp_eq", ftype
, BUILT_IN_MEMCMP_EQ
,
10076 "__builtin_memcmp_eq",
10077 ECF_PURE
| ECF_NOTHROW
| ECF_LEAF
);
10079 /* If there's a possibility that we might use the ARM EABI, build the
10080 alternate __cxa_end_cleanup node used to resume from C++. */
10081 if (targetm
.arm_eabi_unwinder
)
10083 ftype
= build_function_type_list (void_type_node
, NULL_TREE
);
10084 local_define_builtin ("__builtin_cxa_end_cleanup", ftype
,
10085 BUILT_IN_CXA_END_CLEANUP
,
10086 "__cxa_end_cleanup", ECF_NORETURN
| ECF_LEAF
);
10089 ftype
= build_function_type_list (void_type_node
, ptr_type_node
, NULL_TREE
);
10090 local_define_builtin ("__builtin_unwind_resume", ftype
,
10091 BUILT_IN_UNWIND_RESUME
,
10092 ((targetm_common
.except_unwind_info (&global_options
)
10094 ? "_Unwind_SjLj_Resume" : "_Unwind_Resume"),
10097 if (builtin_decl_explicit (BUILT_IN_RETURN_ADDRESS
) == NULL_TREE
)
10099 ftype
= build_function_type_list (ptr_type_node
, integer_type_node
,
10101 local_define_builtin ("__builtin_return_address", ftype
,
10102 BUILT_IN_RETURN_ADDRESS
,
10103 "__builtin_return_address",
10107 if (!builtin_decl_explicit_p (BUILT_IN_PROFILE_FUNC_ENTER
)
10108 || !builtin_decl_explicit_p (BUILT_IN_PROFILE_FUNC_EXIT
))
10110 ftype
= build_function_type_list (void_type_node
, ptr_type_node
,
10111 ptr_type_node
, NULL_TREE
);
10112 if (!builtin_decl_explicit_p (BUILT_IN_PROFILE_FUNC_ENTER
))
10113 local_define_builtin ("__cyg_profile_func_enter", ftype
,
10114 BUILT_IN_PROFILE_FUNC_ENTER
,
10115 "__cyg_profile_func_enter", 0);
10116 if (!builtin_decl_explicit_p (BUILT_IN_PROFILE_FUNC_EXIT
))
10117 local_define_builtin ("__cyg_profile_func_exit", ftype
,
10118 BUILT_IN_PROFILE_FUNC_EXIT
,
10119 "__cyg_profile_func_exit", 0);
10122 /* The exception object and filter values from the runtime. The argument
10123 must be zero before exception lowering, i.e. from the front end. After
10124 exception lowering, it will be the region number for the exception
10125 landing pad. These functions are PURE instead of CONST to prevent
10126 them from being hoisted past the exception edge that will initialize
10127 its value in the landing pad. */
10128 ftype
= build_function_type_list (ptr_type_node
,
10129 integer_type_node
, NULL_TREE
);
10130 ecf_flags
= ECF_PURE
| ECF_NOTHROW
| ECF_LEAF
;
10131 /* Only use TM_PURE if we have TM language support. */
10132 if (builtin_decl_explicit_p (BUILT_IN_TM_LOAD_1
))
10133 ecf_flags
|= ECF_TM_PURE
;
10134 local_define_builtin ("__builtin_eh_pointer", ftype
, BUILT_IN_EH_POINTER
,
10135 "__builtin_eh_pointer", ecf_flags
);
10137 tmp
= lang_hooks
.types
.type_for_mode (targetm
.eh_return_filter_mode (), 0);
10138 ftype
= build_function_type_list (tmp
, integer_type_node
, NULL_TREE
);
10139 local_define_builtin ("__builtin_eh_filter", ftype
, BUILT_IN_EH_FILTER
,
10140 "__builtin_eh_filter", ECF_PURE
| ECF_NOTHROW
| ECF_LEAF
);
10142 ftype
= build_function_type_list (void_type_node
,
10143 integer_type_node
, integer_type_node
,
10145 local_define_builtin ("__builtin_eh_copy_values", ftype
,
10146 BUILT_IN_EH_COPY_VALUES
,
10147 "__builtin_eh_copy_values", ECF_NOTHROW
);
10149 /* Complex multiplication and division. These are handled as builtins
10150 rather than optabs because emit_library_call_value doesn't support
10151 complex. Further, we can do slightly better with folding these
10152 beasties if the real and complex parts of the arguments are separate. */
10156 for (mode
= MIN_MODE_COMPLEX_FLOAT
; mode
<= MAX_MODE_COMPLEX_FLOAT
; ++mode
)
10158 char mode_name_buf
[4], *q
;
10160 enum built_in_function mcode
, dcode
;
10161 tree type
, inner_type
;
10162 const char *prefix
= "__";
10164 if (targetm
.libfunc_gnu_prefix
)
10167 type
= lang_hooks
.types
.type_for_mode ((machine_mode
) mode
, 0);
10170 inner_type
= TREE_TYPE (type
);
10172 ftype
= build_function_type_list (type
, inner_type
, inner_type
,
10173 inner_type
, inner_type
, NULL_TREE
);
10175 mcode
= ((enum built_in_function
)
10176 (BUILT_IN_COMPLEX_MUL_MIN
+ mode
- MIN_MODE_COMPLEX_FLOAT
));
10177 dcode
= ((enum built_in_function
)
10178 (BUILT_IN_COMPLEX_DIV_MIN
+ mode
- MIN_MODE_COMPLEX_FLOAT
));
10180 for (p
= GET_MODE_NAME (mode
), q
= mode_name_buf
; *p
; p
++, q
++)
10184 built_in_names
[mcode
] = concat (prefix
, "mul", mode_name_buf
, "3",
10186 local_define_builtin (built_in_names
[mcode
], ftype
, mcode
,
10187 built_in_names
[mcode
],
10188 ECF_CONST
| ECF_NOTHROW
| ECF_LEAF
);
10190 built_in_names
[dcode
] = concat (prefix
, "div", mode_name_buf
, "3",
10192 local_define_builtin (built_in_names
[dcode
], ftype
, dcode
,
10193 built_in_names
[dcode
],
10194 ECF_CONST
| ECF_NOTHROW
| ECF_LEAF
);
10198 init_internal_fns ();
10201 /* HACK. GROSS. This is absolutely disgusting. I wish there was a
10204 If we requested a pointer to a vector, build up the pointers that
10205 we stripped off while looking for the inner type. Similarly for
10206 return values from functions.
10208 The argument TYPE is the top of the chain, and BOTTOM is the
10209 new type which we will point to. */
10212 reconstruct_complex_type (tree type
, tree bottom
)
10216 if (TREE_CODE (type
) == POINTER_TYPE
)
10218 inner
= reconstruct_complex_type (TREE_TYPE (type
), bottom
);
10219 outer
= build_pointer_type_for_mode (inner
, TYPE_MODE (type
),
10220 TYPE_REF_CAN_ALIAS_ALL (type
));
10222 else if (TREE_CODE (type
) == REFERENCE_TYPE
)
10224 inner
= reconstruct_complex_type (TREE_TYPE (type
), bottom
);
10225 outer
= build_reference_type_for_mode (inner
, TYPE_MODE (type
),
10226 TYPE_REF_CAN_ALIAS_ALL (type
));
10228 else if (TREE_CODE (type
) == ARRAY_TYPE
)
10230 inner
= reconstruct_complex_type (TREE_TYPE (type
), bottom
);
10231 outer
= build_array_type (inner
, TYPE_DOMAIN (type
));
10233 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
10235 inner
= reconstruct_complex_type (TREE_TYPE (type
), bottom
);
10236 outer
= build_function_type (inner
, TYPE_ARG_TYPES (type
));
10238 else if (TREE_CODE (type
) == METHOD_TYPE
)
10240 inner
= reconstruct_complex_type (TREE_TYPE (type
), bottom
);
10241 /* The build_method_type_directly() routine prepends 'this' to argument list,
10242 so we must compensate by getting rid of it. */
10244 = build_method_type_directly
10245 (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (type
))),
10247 TREE_CHAIN (TYPE_ARG_TYPES (type
)));
10249 else if (TREE_CODE (type
) == OFFSET_TYPE
)
10251 inner
= reconstruct_complex_type (TREE_TYPE (type
), bottom
);
10252 outer
= build_offset_type (TYPE_OFFSET_BASETYPE (type
), inner
);
10257 return build_type_attribute_qual_variant (outer
, TYPE_ATTRIBUTES (type
),
10258 TYPE_QUALS (type
));
10261 /* Returns a vector tree node given a mode (integer, vector, or BLKmode) and
10264 build_vector_type_for_mode (tree innertype
, machine_mode mode
)
10267 unsigned int bitsize
;
10269 switch (GET_MODE_CLASS (mode
))
10271 case MODE_VECTOR_INT
:
10272 case MODE_VECTOR_FLOAT
:
10273 case MODE_VECTOR_FRACT
:
10274 case MODE_VECTOR_UFRACT
:
10275 case MODE_VECTOR_ACCUM
:
10276 case MODE_VECTOR_UACCUM
:
10277 nunits
= GET_MODE_NUNITS (mode
);
10281 /* Check that there are no leftover bits. */
10282 bitsize
= GET_MODE_BITSIZE (as_a
<scalar_int_mode
> (mode
));
10283 gcc_assert (bitsize
% TREE_INT_CST_LOW (TYPE_SIZE (innertype
)) == 0);
10284 nunits
= bitsize
/ TREE_INT_CST_LOW (TYPE_SIZE (innertype
));
10288 gcc_unreachable ();
10291 return make_vector_type (innertype
, nunits
, mode
);
10294 /* Similarly, but takes the inner type and number of units, which must be
10298 build_vector_type (tree innertype
, int nunits
)
10300 return make_vector_type (innertype
, nunits
, VOIDmode
);
10303 /* Build truth vector with specified length and number of units. */
10306 build_truth_vector_type (unsigned nunits
, unsigned vector_size
)
10308 machine_mode mask_mode
10309 = targetm
.vectorize
.get_mask_mode (nunits
, vector_size
).else_blk ();
10311 unsigned HOST_WIDE_INT vsize
;
10312 if (mask_mode
== BLKmode
)
10313 vsize
= vector_size
* BITS_PER_UNIT
;
10315 vsize
= GET_MODE_BITSIZE (mask_mode
);
10317 unsigned HOST_WIDE_INT esize
= vsize
/ nunits
;
10318 gcc_assert (esize
* nunits
== vsize
);
10320 tree bool_type
= build_nonstandard_boolean_type (esize
);
10322 return make_vector_type (bool_type
, nunits
, mask_mode
);
10325 /* Returns a vector type corresponding to a comparison of VECTYPE. */
10328 build_same_sized_truth_vector_type (tree vectype
)
10330 if (VECTOR_BOOLEAN_TYPE_P (vectype
))
10333 unsigned HOST_WIDE_INT size
= GET_MODE_SIZE (TYPE_MODE (vectype
));
10336 size
= tree_to_uhwi (TYPE_SIZE_UNIT (vectype
));
10338 return build_truth_vector_type (TYPE_VECTOR_SUBPARTS (vectype
), size
);
10341 /* Similarly, but builds a variant type with TYPE_VECTOR_OPAQUE set. */
10344 build_opaque_vector_type (tree innertype
, int nunits
)
10346 tree t
= make_vector_type (innertype
, nunits
, VOIDmode
);
10348 /* We always build the non-opaque variant before the opaque one,
10349 so if it already exists, it is TYPE_NEXT_VARIANT of this one. */
10350 cand
= TYPE_NEXT_VARIANT (t
);
10352 && TYPE_VECTOR_OPAQUE (cand
)
10353 && check_qualified_type (cand
, t
, TYPE_QUALS (t
)))
10355 /* Othewise build a variant type and make sure to queue it after
10356 the non-opaque type. */
10357 cand
= build_distinct_type_copy (t
);
10358 TYPE_VECTOR_OPAQUE (cand
) = true;
10359 TYPE_CANONICAL (cand
) = TYPE_CANONICAL (t
);
10360 TYPE_NEXT_VARIANT (cand
) = TYPE_NEXT_VARIANT (t
);
10361 TYPE_NEXT_VARIANT (t
) = cand
;
10362 TYPE_MAIN_VARIANT (cand
) = TYPE_MAIN_VARIANT (t
);
10367 /* Given an initializer INIT, return TRUE if INIT is zero or some
10368 aggregate of zeros. Otherwise return FALSE. */
10370 initializer_zerop (const_tree init
)
10376 switch (TREE_CODE (init
))
10379 return integer_zerop (init
);
10382 /* ??? Note that this is not correct for C4X float formats. There,
10383 a bit pattern of all zeros is 1.0; 0.0 is encoded with the most
10384 negative exponent. */
10385 return real_zerop (init
)
10386 && ! REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (init
));
10389 return fixed_zerop (init
);
10392 return integer_zerop (init
)
10393 || (real_zerop (init
)
10394 && ! REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (TREE_REALPART (init
)))
10395 && ! REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (TREE_IMAGPART (init
))));
10400 for (i
= 0; i
< VECTOR_CST_NELTS (init
); ++i
)
10401 if (!initializer_zerop (VECTOR_CST_ELT (init
, i
)))
10408 unsigned HOST_WIDE_INT idx
;
10410 if (TREE_CLOBBER_P (init
))
10412 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (init
), idx
, elt
)
10413 if (!initializer_zerop (elt
))
10422 /* We need to loop through all elements to handle cases like
10423 "\0" and "\0foobar". */
10424 for (i
= 0; i
< TREE_STRING_LENGTH (init
); ++i
)
10425 if (TREE_STRING_POINTER (init
)[i
] != '\0')
10436 /* Check if vector VEC consists of all the equal elements and
10437 that the number of elements corresponds to the type of VEC.
10438 The function returns first element of the vector
10439 or NULL_TREE if the vector is not uniform. */
10441 uniform_vector_p (const_tree vec
)
10446 if (vec
== NULL_TREE
)
10449 gcc_assert (VECTOR_TYPE_P (TREE_TYPE (vec
)));
10451 if (TREE_CODE (vec
) == VECTOR_CST
)
10453 first
= VECTOR_CST_ELT (vec
, 0);
10454 for (i
= 1; i
< VECTOR_CST_NELTS (vec
); ++i
)
10455 if (!operand_equal_p (first
, VECTOR_CST_ELT (vec
, i
), 0))
10461 else if (TREE_CODE (vec
) == CONSTRUCTOR
)
10463 first
= error_mark_node
;
10465 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (vec
), i
, t
)
10472 if (!operand_equal_p (first
, t
, 0))
10475 if (i
!= TYPE_VECTOR_SUBPARTS (TREE_TYPE (vec
)))
10484 /* Build an empty statement at location LOC. */
10487 build_empty_stmt (location_t loc
)
10489 tree t
= build1 (NOP_EXPR
, void_type_node
, size_zero_node
);
10490 SET_EXPR_LOCATION (t
, loc
);
10495 /* Build an OpenMP clause with code CODE. LOC is the location of the
10499 build_omp_clause (location_t loc
, enum omp_clause_code code
)
10504 length
= omp_clause_num_ops
[code
];
10505 size
= (sizeof (struct tree_omp_clause
) + (length
- 1) * sizeof (tree
));
10507 record_node_allocation_statistics (OMP_CLAUSE
, size
);
10509 t
= (tree
) ggc_internal_alloc (size
);
10510 memset (t
, 0, size
);
10511 TREE_SET_CODE (t
, OMP_CLAUSE
);
10512 OMP_CLAUSE_SET_CODE (t
, code
);
10513 OMP_CLAUSE_LOCATION (t
) = loc
;
10518 /* Build a tcc_vl_exp object with code CODE and room for LEN operands. LEN
10519 includes the implicit operand count in TREE_OPERAND 0, and so must be >= 1.
10520 Except for the CODE and operand count field, other storage for the
10521 object is initialized to zeros. */
10524 build_vl_exp (enum tree_code code
, int len MEM_STAT_DECL
)
10527 int length
= (len
- 1) * sizeof (tree
) + sizeof (struct tree_exp
);
10529 gcc_assert (TREE_CODE_CLASS (code
) == tcc_vl_exp
);
10530 gcc_assert (len
>= 1);
10532 record_node_allocation_statistics (code
, length
);
10534 t
= ggc_alloc_cleared_tree_node_stat (length PASS_MEM_STAT
);
10536 TREE_SET_CODE (t
, code
);
10538 /* Can't use TREE_OPERAND to store the length because if checking is
10539 enabled, it will try to check the length before we store it. :-P */
10540 t
->exp
.operands
[0] = build_int_cst (sizetype
, len
);
10545 /* Helper function for build_call_* functions; build a CALL_EXPR with
10546 indicated RETURN_TYPE, FN, and NARGS, but do not initialize any of
10547 the argument slots. */
10550 build_call_1 (tree return_type
, tree fn
, int nargs
)
10554 t
= build_vl_exp (CALL_EXPR
, nargs
+ 3);
10555 TREE_TYPE (t
) = return_type
;
10556 CALL_EXPR_FN (t
) = fn
;
10557 CALL_EXPR_STATIC_CHAIN (t
) = NULL
;
10562 /* Build a CALL_EXPR of class tcc_vl_exp with the indicated RETURN_TYPE and
10563 FN and a null static chain slot. NARGS is the number of call arguments
10564 which are specified as "..." arguments. */
10567 build_call_nary (tree return_type
, tree fn
, int nargs
, ...)
10571 va_start (args
, nargs
);
10572 ret
= build_call_valist (return_type
, fn
, nargs
, args
);
10577 /* Build a CALL_EXPR of class tcc_vl_exp with the indicated RETURN_TYPE and
10578 FN and a null static chain slot. NARGS is the number of call arguments
10579 which are specified as a va_list ARGS. */
10582 build_call_valist (tree return_type
, tree fn
, int nargs
, va_list args
)
10587 t
= build_call_1 (return_type
, fn
, nargs
);
10588 for (i
= 0; i
< nargs
; i
++)
10589 CALL_EXPR_ARG (t
, i
) = va_arg (args
, tree
);
10590 process_call_operands (t
);
10594 /* Build a CALL_EXPR of class tcc_vl_exp with the indicated RETURN_TYPE and
10595 FN and a null static chain slot. NARGS is the number of call arguments
10596 which are specified as a tree array ARGS. */
10599 build_call_array_loc (location_t loc
, tree return_type
, tree fn
,
10600 int nargs
, const tree
*args
)
10605 t
= build_call_1 (return_type
, fn
, nargs
);
10606 for (i
= 0; i
< nargs
; i
++)
10607 CALL_EXPR_ARG (t
, i
) = args
[i
];
10608 process_call_operands (t
);
10609 SET_EXPR_LOCATION (t
, loc
);
10613 /* Like build_call_array, but takes a vec. */
10616 build_call_vec (tree return_type
, tree fn
, vec
<tree
, va_gc
> *args
)
10621 ret
= build_call_1 (return_type
, fn
, vec_safe_length (args
));
10622 FOR_EACH_VEC_SAFE_ELT (args
, ix
, t
)
10623 CALL_EXPR_ARG (ret
, ix
) = t
;
10624 process_call_operands (ret
);
10628 /* Conveniently construct a function call expression. FNDECL names the
10629 function to be called and N arguments are passed in the array
10633 build_call_expr_loc_array (location_t loc
, tree fndecl
, int n
, tree
*argarray
)
10635 tree fntype
= TREE_TYPE (fndecl
);
10636 tree fn
= build1 (ADDR_EXPR
, build_pointer_type (fntype
), fndecl
);
10638 return fold_build_call_array_loc (loc
, TREE_TYPE (fntype
), fn
, n
, argarray
);
10641 /* Conveniently construct a function call expression. FNDECL names the
10642 function to be called and the arguments are passed in the vector
10646 build_call_expr_loc_vec (location_t loc
, tree fndecl
, vec
<tree
, va_gc
> *vec
)
10648 return build_call_expr_loc_array (loc
, fndecl
, vec_safe_length (vec
),
10649 vec_safe_address (vec
));
10653 /* Conveniently construct a function call expression. FNDECL names the
10654 function to be called, N is the number of arguments, and the "..."
10655 parameters are the argument expressions. */
10658 build_call_expr_loc (location_t loc
, tree fndecl
, int n
, ...)
10661 tree
*argarray
= XALLOCAVEC (tree
, n
);
10665 for (i
= 0; i
< n
; i
++)
10666 argarray
[i
] = va_arg (ap
, tree
);
10668 return build_call_expr_loc_array (loc
, fndecl
, n
, argarray
);
10671 /* Like build_call_expr_loc (UNKNOWN_LOCATION, ...). Duplicated because
10672 varargs macros aren't supported by all bootstrap compilers. */
10675 build_call_expr (tree fndecl
, int n
, ...)
10678 tree
*argarray
= XALLOCAVEC (tree
, n
);
10682 for (i
= 0; i
< n
; i
++)
10683 argarray
[i
] = va_arg (ap
, tree
);
10685 return build_call_expr_loc_array (UNKNOWN_LOCATION
, fndecl
, n
, argarray
);
10688 /* Build an internal call to IFN, with arguments ARGS[0:N-1] and with return
10689 type TYPE. This is just like CALL_EXPR, except its CALL_EXPR_FN is NULL.
10690 It will get gimplified later into an ordinary internal function. */
10693 build_call_expr_internal_loc_array (location_t loc
, internal_fn ifn
,
10694 tree type
, int n
, const tree
*args
)
10696 tree t
= build_call_1 (type
, NULL_TREE
, n
);
10697 for (int i
= 0; i
< n
; ++i
)
10698 CALL_EXPR_ARG (t
, i
) = args
[i
];
10699 SET_EXPR_LOCATION (t
, loc
);
10700 CALL_EXPR_IFN (t
) = ifn
;
10704 /* Build internal call expression. This is just like CALL_EXPR, except
10705 its CALL_EXPR_FN is NULL. It will get gimplified later into ordinary
10706 internal function. */
10709 build_call_expr_internal_loc (location_t loc
, enum internal_fn ifn
,
10710 tree type
, int n
, ...)
10713 tree
*argarray
= XALLOCAVEC (tree
, n
);
10717 for (i
= 0; i
< n
; i
++)
10718 argarray
[i
] = va_arg (ap
, tree
);
10720 return build_call_expr_internal_loc_array (loc
, ifn
, type
, n
, argarray
);
10723 /* Return a function call to FN, if the target is guaranteed to support it,
10726 N is the number of arguments, passed in the "...", and TYPE is the
10727 type of the return value. */
10730 maybe_build_call_expr_loc (location_t loc
, combined_fn fn
, tree type
,
10734 tree
*argarray
= XALLOCAVEC (tree
, n
);
10738 for (i
= 0; i
< n
; i
++)
10739 argarray
[i
] = va_arg (ap
, tree
);
10741 if (internal_fn_p (fn
))
10743 internal_fn ifn
= as_internal_fn (fn
);
10744 if (direct_internal_fn_p (ifn
))
10746 tree_pair types
= direct_internal_fn_types (ifn
, type
, argarray
);
10747 if (!direct_internal_fn_supported_p (ifn
, types
,
10748 OPTIMIZE_FOR_BOTH
))
10751 return build_call_expr_internal_loc_array (loc
, ifn
, type
, n
, argarray
);
10755 tree fndecl
= builtin_decl_implicit (as_builtin_fn (fn
));
10758 return build_call_expr_loc_array (loc
, fndecl
, n
, argarray
);
10762 /* Return a function call to the appropriate builtin alloca variant.
10764 SIZE is the size to be allocated. ALIGN, if non-zero, is the requested
10765 alignment of the allocated area. MAX_SIZE, if non-negative, is an upper
10766 bound for SIZE in case it is not a fixed value. */
10769 build_alloca_call_expr (tree size
, unsigned int align
, HOST_WIDE_INT max_size
)
10773 tree t
= builtin_decl_explicit (BUILT_IN_ALLOCA_WITH_ALIGN_AND_MAX
);
10775 build_call_expr (t
, 3, size
, size_int (align
), size_int (max_size
));
10777 else if (align
> 0)
10779 tree t
= builtin_decl_explicit (BUILT_IN_ALLOCA_WITH_ALIGN
);
10780 return build_call_expr (t
, 2, size
, size_int (align
));
10784 tree t
= builtin_decl_explicit (BUILT_IN_ALLOCA
);
10785 return build_call_expr (t
, 1, size
);
10789 /* Create a new constant string literal and return a char* pointer to it.
10790 The STRING_CST value is the LEN characters at STR. */
10792 build_string_literal (int len
, const char *str
)
10794 tree t
, elem
, index
, type
;
10796 t
= build_string (len
, str
);
10797 elem
= build_type_variant (char_type_node
, 1, 0);
10798 index
= build_index_type (size_int (len
- 1));
10799 type
= build_array_type (elem
, index
);
10800 TREE_TYPE (t
) = type
;
10801 TREE_CONSTANT (t
) = 1;
10802 TREE_READONLY (t
) = 1;
10803 TREE_STATIC (t
) = 1;
10805 type
= build_pointer_type (elem
);
10806 t
= build1 (ADDR_EXPR
, type
,
10807 build4 (ARRAY_REF
, elem
,
10808 t
, integer_zero_node
, NULL_TREE
, NULL_TREE
));
10814 /* Return true if T (assumed to be a DECL) must be assigned a memory
10818 needs_to_live_in_memory (const_tree t
)
10820 return (TREE_ADDRESSABLE (t
)
10821 || is_global_var (t
)
10822 || (TREE_CODE (t
) == RESULT_DECL
10823 && !DECL_BY_REFERENCE (t
)
10824 && aggregate_value_p (t
, current_function_decl
)));
10827 /* Return value of a constant X and sign-extend it. */
10830 int_cst_value (const_tree x
)
10832 unsigned bits
= TYPE_PRECISION (TREE_TYPE (x
));
10833 unsigned HOST_WIDE_INT val
= TREE_INT_CST_LOW (x
);
10835 /* Make sure the sign-extended value will fit in a HOST_WIDE_INT. */
10836 gcc_assert (cst_and_fits_in_hwi (x
));
10838 if (bits
< HOST_BITS_PER_WIDE_INT
)
10840 bool negative
= ((val
>> (bits
- 1)) & 1) != 0;
10842 val
|= HOST_WIDE_INT_M1U
<< (bits
- 1) << 1;
10844 val
&= ~(HOST_WIDE_INT_M1U
<< (bits
- 1) << 1);
10850 /* If TYPE is an integral or pointer type, return an integer type with
10851 the same precision which is unsigned iff UNSIGNEDP is true, or itself
10852 if TYPE is already an integer type of signedness UNSIGNEDP. */
10855 signed_or_unsigned_type_for (int unsignedp
, tree type
)
10857 if (TREE_CODE (type
) == INTEGER_TYPE
&& TYPE_UNSIGNED (type
) == unsignedp
)
10860 if (TREE_CODE (type
) == VECTOR_TYPE
)
10862 tree inner
= TREE_TYPE (type
);
10863 tree inner2
= signed_or_unsigned_type_for (unsignedp
, inner
);
10866 if (inner
== inner2
)
10868 return build_vector_type (inner2
, TYPE_VECTOR_SUBPARTS (type
));
10871 if (!INTEGRAL_TYPE_P (type
)
10872 && !POINTER_TYPE_P (type
)
10873 && TREE_CODE (type
) != OFFSET_TYPE
)
10876 return build_nonstandard_integer_type (TYPE_PRECISION (type
), unsignedp
);
10879 /* If TYPE is an integral or pointer type, return an integer type with
10880 the same precision which is unsigned, or itself if TYPE is already an
10881 unsigned integer type. */
10884 unsigned_type_for (tree type
)
10886 return signed_or_unsigned_type_for (1, type
);
10889 /* If TYPE is an integral or pointer type, return an integer type with
10890 the same precision which is signed, or itself if TYPE is already a
10891 signed integer type. */
10894 signed_type_for (tree type
)
10896 return signed_or_unsigned_type_for (0, type
);
10899 /* If TYPE is a vector type, return a signed integer vector type with the
10900 same width and number of subparts. Otherwise return boolean_type_node. */
10903 truth_type_for (tree type
)
10905 if (TREE_CODE (type
) == VECTOR_TYPE
)
10907 if (VECTOR_BOOLEAN_TYPE_P (type
))
10909 return build_truth_vector_type (TYPE_VECTOR_SUBPARTS (type
),
10910 GET_MODE_SIZE (TYPE_MODE (type
)));
10913 return boolean_type_node
;
10916 /* Returns the largest value obtainable by casting something in INNER type to
10920 upper_bound_in_type (tree outer
, tree inner
)
10922 unsigned int det
= 0;
10923 unsigned oprec
= TYPE_PRECISION (outer
);
10924 unsigned iprec
= TYPE_PRECISION (inner
);
10927 /* Compute a unique number for every combination. */
10928 det
|= (oprec
> iprec
) ? 4 : 0;
10929 det
|= TYPE_UNSIGNED (outer
) ? 2 : 0;
10930 det
|= TYPE_UNSIGNED (inner
) ? 1 : 0;
10932 /* Determine the exponent to use. */
10937 /* oprec <= iprec, outer: signed, inner: don't care. */
10942 /* oprec <= iprec, outer: unsigned, inner: don't care. */
10946 /* oprec > iprec, outer: signed, inner: signed. */
10950 /* oprec > iprec, outer: signed, inner: unsigned. */
10954 /* oprec > iprec, outer: unsigned, inner: signed. */
10958 /* oprec > iprec, outer: unsigned, inner: unsigned. */
10962 gcc_unreachable ();
10965 return wide_int_to_tree (outer
,
10966 wi::mask (prec
, false, TYPE_PRECISION (outer
)));
10969 /* Returns the smallest value obtainable by casting something in INNER type to
10973 lower_bound_in_type (tree outer
, tree inner
)
10975 unsigned oprec
= TYPE_PRECISION (outer
);
10976 unsigned iprec
= TYPE_PRECISION (inner
);
10978 /* If OUTER type is unsigned, we can definitely cast 0 to OUTER type
10980 if (TYPE_UNSIGNED (outer
)
10981 /* If we are widening something of an unsigned type, OUTER type
10982 contains all values of INNER type. In particular, both INNER
10983 and OUTER types have zero in common. */
10984 || (oprec
> iprec
&& TYPE_UNSIGNED (inner
)))
10985 return build_int_cst (outer
, 0);
10988 /* If we are widening a signed type to another signed type, we
10989 want to obtain -2^^(iprec-1). If we are keeping the
10990 precision or narrowing to a signed type, we want to obtain
10992 unsigned prec
= oprec
> iprec
? iprec
: oprec
;
10993 return wide_int_to_tree (outer
,
10994 wi::mask (prec
- 1, true,
10995 TYPE_PRECISION (outer
)));
10999 /* Return nonzero if two operands that are suitable for PHI nodes are
11000 necessarily equal. Specifically, both ARG0 and ARG1 must be either
11001 SSA_NAME or invariant. Note that this is strictly an optimization.
11002 That is, callers of this function can directly call operand_equal_p
11003 and get the same result, only slower. */
11006 operand_equal_for_phi_arg_p (const_tree arg0
, const_tree arg1
)
11010 if (TREE_CODE (arg0
) == SSA_NAME
|| TREE_CODE (arg1
) == SSA_NAME
)
11012 return operand_equal_p (arg0
, arg1
, 0);
11015 /* Returns number of zeros at the end of binary representation of X. */
11018 num_ending_zeros (const_tree x
)
11020 return build_int_cst (TREE_TYPE (x
), wi::ctz (wi::to_wide (x
)));
11024 #define WALK_SUBTREE(NODE) \
11027 result = walk_tree_1 (&(NODE), func, data, pset, lh); \
11033 /* This is a subroutine of walk_tree that walks field of TYPE that are to
11034 be walked whenever a type is seen in the tree. Rest of operands and return
11035 value are as for walk_tree. */
11038 walk_type_fields (tree type
, walk_tree_fn func
, void *data
,
11039 hash_set
<tree
> *pset
, walk_tree_lh lh
)
11041 tree result
= NULL_TREE
;
11043 switch (TREE_CODE (type
))
11046 case REFERENCE_TYPE
:
11048 /* We have to worry about mutually recursive pointers. These can't
11049 be written in C. They can in Ada. It's pathological, but
11050 there's an ACATS test (c38102a) that checks it. Deal with this
11051 by checking if we're pointing to another pointer, that one
11052 points to another pointer, that one does too, and we have no htab.
11053 If so, get a hash table. We check three levels deep to avoid
11054 the cost of the hash table if we don't need one. */
11055 if (POINTER_TYPE_P (TREE_TYPE (type
))
11056 && POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (type
)))
11057 && POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (TREE_TYPE (type
))))
11060 result
= walk_tree_without_duplicates (&TREE_TYPE (type
),
11071 WALK_SUBTREE (TREE_TYPE (type
));
11075 WALK_SUBTREE (TYPE_METHOD_BASETYPE (type
));
11077 /* Fall through. */
11079 case FUNCTION_TYPE
:
11080 WALK_SUBTREE (TREE_TYPE (type
));
11084 /* We never want to walk into default arguments. */
11085 for (arg
= TYPE_ARG_TYPES (type
); arg
; arg
= TREE_CHAIN (arg
))
11086 WALK_SUBTREE (TREE_VALUE (arg
));
11091 /* Don't follow this nodes's type if a pointer for fear that
11092 we'll have infinite recursion. If we have a PSET, then we
11095 || (!POINTER_TYPE_P (TREE_TYPE (type
))
11096 && TREE_CODE (TREE_TYPE (type
)) != OFFSET_TYPE
))
11097 WALK_SUBTREE (TREE_TYPE (type
));
11098 WALK_SUBTREE (TYPE_DOMAIN (type
));
11102 WALK_SUBTREE (TREE_TYPE (type
));
11103 WALK_SUBTREE (TYPE_OFFSET_BASETYPE (type
));
11113 /* Apply FUNC to all the sub-trees of TP in a pre-order traversal. FUNC is
11114 called with the DATA and the address of each sub-tree. If FUNC returns a
11115 non-NULL value, the traversal is stopped, and the value returned by FUNC
11116 is returned. If PSET is non-NULL it is used to record the nodes visited,
11117 and to avoid visiting a node more than once. */
11120 walk_tree_1 (tree
*tp
, walk_tree_fn func
, void *data
,
11121 hash_set
<tree
> *pset
, walk_tree_lh lh
)
11123 enum tree_code code
;
11127 #define WALK_SUBTREE_TAIL(NODE) \
11131 goto tail_recurse; \
11136 /* Skip empty subtrees. */
11140 /* Don't walk the same tree twice, if the user has requested
11141 that we avoid doing so. */
11142 if (pset
&& pset
->add (*tp
))
11145 /* Call the function. */
11147 result
= (*func
) (tp
, &walk_subtrees
, data
);
11149 /* If we found something, return it. */
11153 code
= TREE_CODE (*tp
);
11155 /* Even if we didn't, FUNC may have decided that there was nothing
11156 interesting below this point in the tree. */
11157 if (!walk_subtrees
)
11159 /* But we still need to check our siblings. */
11160 if (code
== TREE_LIST
)
11161 WALK_SUBTREE_TAIL (TREE_CHAIN (*tp
));
11162 else if (code
== OMP_CLAUSE
)
11163 WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp
));
11170 result
= (*lh
) (tp
, &walk_subtrees
, func
, data
, pset
);
11171 if (result
|| !walk_subtrees
)
11178 case IDENTIFIER_NODE
:
11185 case PLACEHOLDER_EXPR
:
11189 /* None of these have subtrees other than those already walked
11194 WALK_SUBTREE (TREE_VALUE (*tp
));
11195 WALK_SUBTREE_TAIL (TREE_CHAIN (*tp
));
11200 int len
= TREE_VEC_LENGTH (*tp
);
11205 /* Walk all elements but the first. */
11207 WALK_SUBTREE (TREE_VEC_ELT (*tp
, len
));
11209 /* Now walk the first one as a tail call. */
11210 WALK_SUBTREE_TAIL (TREE_VEC_ELT (*tp
, 0));
11214 WALK_SUBTREE (TREE_REALPART (*tp
));
11215 WALK_SUBTREE_TAIL (TREE_IMAGPART (*tp
));
11219 unsigned HOST_WIDE_INT idx
;
11220 constructor_elt
*ce
;
11222 for (idx
= 0; vec_safe_iterate (CONSTRUCTOR_ELTS (*tp
), idx
, &ce
);
11224 WALK_SUBTREE (ce
->value
);
11229 WALK_SUBTREE_TAIL (TREE_OPERAND (*tp
, 0));
11234 for (decl
= BIND_EXPR_VARS (*tp
); decl
; decl
= DECL_CHAIN (decl
))
11236 /* Walk the DECL_INITIAL and DECL_SIZE. We don't want to walk
11237 into declarations that are just mentioned, rather than
11238 declared; they don't really belong to this part of the tree.
11239 And, we can see cycles: the initializer for a declaration
11240 can refer to the declaration itself. */
11241 WALK_SUBTREE (DECL_INITIAL (decl
));
11242 WALK_SUBTREE (DECL_SIZE (decl
));
11243 WALK_SUBTREE (DECL_SIZE_UNIT (decl
));
11245 WALK_SUBTREE_TAIL (BIND_EXPR_BODY (*tp
));
11248 case STATEMENT_LIST
:
11250 tree_stmt_iterator i
;
11251 for (i
= tsi_start (*tp
); !tsi_end_p (i
); tsi_next (&i
))
11252 WALK_SUBTREE (*tsi_stmt_ptr (i
));
11257 switch (OMP_CLAUSE_CODE (*tp
))
11259 case OMP_CLAUSE_GANG
:
11260 case OMP_CLAUSE__GRIDDIM_
:
11261 WALK_SUBTREE (OMP_CLAUSE_OPERAND (*tp
, 1));
11264 case OMP_CLAUSE_ASYNC
:
11265 case OMP_CLAUSE_WAIT
:
11266 case OMP_CLAUSE_WORKER
:
11267 case OMP_CLAUSE_VECTOR
:
11268 case OMP_CLAUSE_NUM_GANGS
:
11269 case OMP_CLAUSE_NUM_WORKERS
:
11270 case OMP_CLAUSE_VECTOR_LENGTH
:
11271 case OMP_CLAUSE_PRIVATE
:
11272 case OMP_CLAUSE_SHARED
:
11273 case OMP_CLAUSE_FIRSTPRIVATE
:
11274 case OMP_CLAUSE_COPYIN
:
11275 case OMP_CLAUSE_COPYPRIVATE
:
11276 case OMP_CLAUSE_FINAL
:
11277 case OMP_CLAUSE_IF
:
11278 case OMP_CLAUSE_NUM_THREADS
:
11279 case OMP_CLAUSE_SCHEDULE
:
11280 case OMP_CLAUSE_UNIFORM
:
11281 case OMP_CLAUSE_DEPEND
:
11282 case OMP_CLAUSE_NUM_TEAMS
:
11283 case OMP_CLAUSE_THREAD_LIMIT
:
11284 case OMP_CLAUSE_DEVICE
:
11285 case OMP_CLAUSE_DIST_SCHEDULE
:
11286 case OMP_CLAUSE_SAFELEN
:
11287 case OMP_CLAUSE_SIMDLEN
:
11288 case OMP_CLAUSE_ORDERED
:
11289 case OMP_CLAUSE_PRIORITY
:
11290 case OMP_CLAUSE_GRAINSIZE
:
11291 case OMP_CLAUSE_NUM_TASKS
:
11292 case OMP_CLAUSE_HINT
:
11293 case OMP_CLAUSE_TO_DECLARE
:
11294 case OMP_CLAUSE_LINK
:
11295 case OMP_CLAUSE_USE_DEVICE_PTR
:
11296 case OMP_CLAUSE_IS_DEVICE_PTR
:
11297 case OMP_CLAUSE__LOOPTEMP_
:
11298 case OMP_CLAUSE__SIMDUID_
:
11299 WALK_SUBTREE (OMP_CLAUSE_OPERAND (*tp
, 0));
11302 case OMP_CLAUSE_INDEPENDENT
:
11303 case OMP_CLAUSE_NOWAIT
:
11304 case OMP_CLAUSE_DEFAULT
:
11305 case OMP_CLAUSE_UNTIED
:
11306 case OMP_CLAUSE_MERGEABLE
:
11307 case OMP_CLAUSE_PROC_BIND
:
11308 case OMP_CLAUSE_INBRANCH
:
11309 case OMP_CLAUSE_NOTINBRANCH
:
11310 case OMP_CLAUSE_FOR
:
11311 case OMP_CLAUSE_PARALLEL
:
11312 case OMP_CLAUSE_SECTIONS
:
11313 case OMP_CLAUSE_TASKGROUP
:
11314 case OMP_CLAUSE_NOGROUP
:
11315 case OMP_CLAUSE_THREADS
:
11316 case OMP_CLAUSE_SIMD
:
11317 case OMP_CLAUSE_DEFAULTMAP
:
11318 case OMP_CLAUSE_AUTO
:
11319 case OMP_CLAUSE_SEQ
:
11320 case OMP_CLAUSE_TILE
:
11321 case OMP_CLAUSE__SIMT_
:
11322 WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp
));
11324 case OMP_CLAUSE_LASTPRIVATE
:
11325 WALK_SUBTREE (OMP_CLAUSE_DECL (*tp
));
11326 WALK_SUBTREE (OMP_CLAUSE_LASTPRIVATE_STMT (*tp
));
11327 WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp
));
11329 case OMP_CLAUSE_COLLAPSE
:
11332 for (i
= 0; i
< 3; i
++)
11333 WALK_SUBTREE (OMP_CLAUSE_OPERAND (*tp
, i
));
11334 WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp
));
11337 case OMP_CLAUSE_LINEAR
:
11338 WALK_SUBTREE (OMP_CLAUSE_DECL (*tp
));
11339 WALK_SUBTREE (OMP_CLAUSE_LINEAR_STEP (*tp
));
11340 WALK_SUBTREE (OMP_CLAUSE_LINEAR_STMT (*tp
));
11341 WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp
));
11343 case OMP_CLAUSE_ALIGNED
:
11344 case OMP_CLAUSE_FROM
:
11345 case OMP_CLAUSE_TO
:
11346 case OMP_CLAUSE_MAP
:
11347 case OMP_CLAUSE__CACHE_
:
11348 WALK_SUBTREE (OMP_CLAUSE_DECL (*tp
));
11349 WALK_SUBTREE (OMP_CLAUSE_OPERAND (*tp
, 1));
11350 WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp
));
11352 case OMP_CLAUSE_REDUCTION
:
11355 for (i
= 0; i
< 5; i
++)
11356 WALK_SUBTREE (OMP_CLAUSE_OPERAND (*tp
, i
));
11357 WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp
));
11361 gcc_unreachable ();
11369 /* TARGET_EXPRs are peculiar: operands 1 and 3 can be the same.
11370 But, we only want to walk once. */
11371 len
= (TREE_OPERAND (*tp
, 3) == TREE_OPERAND (*tp
, 1)) ? 2 : 3;
11372 for (i
= 0; i
< len
; ++i
)
11373 WALK_SUBTREE (TREE_OPERAND (*tp
, i
));
11374 WALK_SUBTREE_TAIL (TREE_OPERAND (*tp
, len
));
11378 /* If this is a TYPE_DECL, walk into the fields of the type that it's
11379 defining. We only want to walk into these fields of a type in this
11380 case and not in the general case of a mere reference to the type.
11382 The criterion is as follows: if the field can be an expression, it
11383 must be walked only here. This should be in keeping with the fields
11384 that are directly gimplified in gimplify_type_sizes in order for the
11385 mark/copy-if-shared/unmark machinery of the gimplifier to work with
11386 variable-sized types.
11388 Note that DECLs get walked as part of processing the BIND_EXPR. */
11389 if (TREE_CODE (DECL_EXPR_DECL (*tp
)) == TYPE_DECL
)
11391 tree
*type_p
= &TREE_TYPE (DECL_EXPR_DECL (*tp
));
11392 if (TREE_CODE (*type_p
) == ERROR_MARK
)
11395 /* Call the function for the type. See if it returns anything or
11396 doesn't want us to continue. If we are to continue, walk both
11397 the normal fields and those for the declaration case. */
11398 result
= (*func
) (type_p
, &walk_subtrees
, data
);
11399 if (result
|| !walk_subtrees
)
11402 /* But do not walk a pointed-to type since it may itself need to
11403 be walked in the declaration case if it isn't anonymous. */
11404 if (!POINTER_TYPE_P (*type_p
))
11406 result
= walk_type_fields (*type_p
, func
, data
, pset
, lh
);
11411 /* If this is a record type, also walk the fields. */
11412 if (RECORD_OR_UNION_TYPE_P (*type_p
))
11416 for (field
= TYPE_FIELDS (*type_p
); field
;
11417 field
= DECL_CHAIN (field
))
11419 /* We'd like to look at the type of the field, but we can
11420 easily get infinite recursion. So assume it's pointed
11421 to elsewhere in the tree. Also, ignore things that
11423 if (TREE_CODE (field
) != FIELD_DECL
)
11426 WALK_SUBTREE (DECL_FIELD_OFFSET (field
));
11427 WALK_SUBTREE (DECL_SIZE (field
));
11428 WALK_SUBTREE (DECL_SIZE_UNIT (field
));
11429 if (TREE_CODE (*type_p
) == QUAL_UNION_TYPE
)
11430 WALK_SUBTREE (DECL_QUALIFIER (field
));
11434 /* Same for scalar types. */
11435 else if (TREE_CODE (*type_p
) == BOOLEAN_TYPE
11436 || TREE_CODE (*type_p
) == ENUMERAL_TYPE
11437 || TREE_CODE (*type_p
) == INTEGER_TYPE
11438 || TREE_CODE (*type_p
) == FIXED_POINT_TYPE
11439 || TREE_CODE (*type_p
) == REAL_TYPE
)
11441 WALK_SUBTREE (TYPE_MIN_VALUE (*type_p
));
11442 WALK_SUBTREE (TYPE_MAX_VALUE (*type_p
));
11445 WALK_SUBTREE (TYPE_SIZE (*type_p
));
11446 WALK_SUBTREE_TAIL (TYPE_SIZE_UNIT (*type_p
));
11451 if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (code
)))
11455 /* Walk over all the sub-trees of this operand. */
11456 len
= TREE_OPERAND_LENGTH (*tp
);
11458 /* Go through the subtrees. We need to do this in forward order so
11459 that the scope of a FOR_EXPR is handled properly. */
11462 for (i
= 0; i
< len
- 1; ++i
)
11463 WALK_SUBTREE (TREE_OPERAND (*tp
, i
));
11464 WALK_SUBTREE_TAIL (TREE_OPERAND (*tp
, len
- 1));
11467 /* If this is a type, walk the needed fields in the type. */
11468 else if (TYPE_P (*tp
))
11469 return walk_type_fields (*tp
, func
, data
, pset
, lh
);
11473 /* We didn't find what we were looking for. */
11476 #undef WALK_SUBTREE_TAIL
11478 #undef WALK_SUBTREE
11480 /* Like walk_tree, but does not walk duplicate nodes more than once. */
11483 walk_tree_without_duplicates_1 (tree
*tp
, walk_tree_fn func
, void *data
,
11488 hash_set
<tree
> pset
;
11489 result
= walk_tree_1 (tp
, func
, data
, &pset
, lh
);
11495 tree_block (tree t
)
11497 const enum tree_code_class c
= TREE_CODE_CLASS (TREE_CODE (t
));
11499 if (IS_EXPR_CODE_CLASS (c
))
11500 return LOCATION_BLOCK (t
->exp
.locus
);
11501 gcc_unreachable ();
11506 tree_set_block (tree t
, tree b
)
11508 const enum tree_code_class c
= TREE_CODE_CLASS (TREE_CODE (t
));
11510 if (IS_EXPR_CODE_CLASS (c
))
11512 t
->exp
.locus
= set_block (t
->exp
.locus
, b
);
11515 gcc_unreachable ();
11518 /* Create a nameless artificial label and put it in the current
11519 function context. The label has a location of LOC. Returns the
11520 newly created label. */
11523 create_artificial_label (location_t loc
)
11525 tree lab
= build_decl (loc
,
11526 LABEL_DECL
, NULL_TREE
, void_type_node
);
11528 DECL_ARTIFICIAL (lab
) = 1;
11529 DECL_IGNORED_P (lab
) = 1;
11530 DECL_CONTEXT (lab
) = current_function_decl
;
11534 /* Given a tree, try to return a useful variable name that we can use
11535 to prefix a temporary that is being assigned the value of the tree.
11536 I.E. given <temp> = &A, return A. */
11541 tree stripped_decl
;
11544 STRIP_NOPS (stripped_decl
);
11545 if (DECL_P (stripped_decl
) && DECL_NAME (stripped_decl
))
11546 return IDENTIFIER_POINTER (DECL_NAME (stripped_decl
));
11547 else if (TREE_CODE (stripped_decl
) == SSA_NAME
)
11549 tree name
= SSA_NAME_IDENTIFIER (stripped_decl
);
11552 return IDENTIFIER_POINTER (name
);
11556 switch (TREE_CODE (stripped_decl
))
11559 return get_name (TREE_OPERAND (stripped_decl
, 0));
11566 /* Return true if TYPE has a variable argument list. */
11569 stdarg_p (const_tree fntype
)
11571 function_args_iterator args_iter
;
11572 tree n
= NULL_TREE
, t
;
11577 FOREACH_FUNCTION_ARGS (fntype
, t
, args_iter
)
11582 return n
!= NULL_TREE
&& n
!= void_type_node
;
11585 /* Return true if TYPE has a prototype. */
11588 prototype_p (const_tree fntype
)
11592 gcc_assert (fntype
!= NULL_TREE
);
11594 t
= TYPE_ARG_TYPES (fntype
);
11595 return (t
!= NULL_TREE
);
11598 /* If BLOCK is inlined from an __attribute__((__artificial__))
11599 routine, return pointer to location from where it has been
11602 block_nonartificial_location (tree block
)
11604 location_t
*ret
= NULL
;
11606 while (block
&& TREE_CODE (block
) == BLOCK
11607 && BLOCK_ABSTRACT_ORIGIN (block
))
11609 tree ao
= BLOCK_ABSTRACT_ORIGIN (block
);
11611 while (TREE_CODE (ao
) == BLOCK
11612 && BLOCK_ABSTRACT_ORIGIN (ao
)
11613 && BLOCK_ABSTRACT_ORIGIN (ao
) != ao
)
11614 ao
= BLOCK_ABSTRACT_ORIGIN (ao
);
11616 if (TREE_CODE (ao
) == FUNCTION_DECL
)
11618 /* If AO is an artificial inline, point RET to the
11619 call site locus at which it has been inlined and continue
11620 the loop, in case AO's caller is also an artificial
11622 if (DECL_DECLARED_INLINE_P (ao
)
11623 && lookup_attribute ("artificial", DECL_ATTRIBUTES (ao
)))
11624 ret
= &BLOCK_SOURCE_LOCATION (block
);
11628 else if (TREE_CODE (ao
) != BLOCK
)
11631 block
= BLOCK_SUPERCONTEXT (block
);
11637 /* If EXP is inlined from an __attribute__((__artificial__))
11638 function, return the location of the original call expression. */
11641 tree_nonartificial_location (tree exp
)
11643 location_t
*loc
= block_nonartificial_location (TREE_BLOCK (exp
));
11648 return EXPR_LOCATION (exp
);
11652 /* These are the hash table functions for the hash table of OPTIMIZATION_NODEq
11655 /* Return the hash code X, an OPTIMIZATION_NODE or TARGET_OPTION code. */
11658 cl_option_hasher::hash (tree x
)
11660 const_tree
const t
= x
;
11664 hashval_t hash
= 0;
11666 if (TREE_CODE (t
) == OPTIMIZATION_NODE
)
11668 p
= (const char *)TREE_OPTIMIZATION (t
);
11669 len
= sizeof (struct cl_optimization
);
11672 else if (TREE_CODE (t
) == TARGET_OPTION_NODE
)
11673 return cl_target_option_hash (TREE_TARGET_OPTION (t
));
11676 gcc_unreachable ();
11678 /* assume most opt flags are just 0/1, some are 2-3, and a few might be
11680 for (i
= 0; i
< len
; i
++)
11682 hash
= (hash
<< 4) ^ ((i
<< 2) | p
[i
]);
11687 /* Return nonzero if the value represented by *X (an OPTIMIZATION or
11688 TARGET_OPTION tree node) is the same as that given by *Y, which is the
11692 cl_option_hasher::equal (tree x
, tree y
)
11694 const_tree
const xt
= x
;
11695 const_tree
const yt
= y
;
11700 if (TREE_CODE (xt
) != TREE_CODE (yt
))
11703 if (TREE_CODE (xt
) == OPTIMIZATION_NODE
)
11705 xp
= (const char *)TREE_OPTIMIZATION (xt
);
11706 yp
= (const char *)TREE_OPTIMIZATION (yt
);
11707 len
= sizeof (struct cl_optimization
);
11710 else if (TREE_CODE (xt
) == TARGET_OPTION_NODE
)
11712 return cl_target_option_eq (TREE_TARGET_OPTION (xt
),
11713 TREE_TARGET_OPTION (yt
));
11717 gcc_unreachable ();
11719 return (memcmp (xp
, yp
, len
) == 0);
11722 /* Build an OPTIMIZATION_NODE based on the options in OPTS. */
11725 build_optimization_node (struct gcc_options
*opts
)
11729 /* Use the cache of optimization nodes. */
11731 cl_optimization_save (TREE_OPTIMIZATION (cl_optimization_node
),
11734 tree
*slot
= cl_option_hash_table
->find_slot (cl_optimization_node
, INSERT
);
11738 /* Insert this one into the hash table. */
11739 t
= cl_optimization_node
;
11742 /* Make a new node for next time round. */
11743 cl_optimization_node
= make_node (OPTIMIZATION_NODE
);
11749 /* Build a TARGET_OPTION_NODE based on the options in OPTS. */
11752 build_target_option_node (struct gcc_options
*opts
)
11756 /* Use the cache of optimization nodes. */
11758 cl_target_option_save (TREE_TARGET_OPTION (cl_target_option_node
),
11761 tree
*slot
= cl_option_hash_table
->find_slot (cl_target_option_node
, INSERT
);
11765 /* Insert this one into the hash table. */
11766 t
= cl_target_option_node
;
11769 /* Make a new node for next time round. */
11770 cl_target_option_node
= make_node (TARGET_OPTION_NODE
);
11776 /* Clear TREE_TARGET_GLOBALS of all TARGET_OPTION_NODE trees,
11777 so that they aren't saved during PCH writing. */
11780 prepare_target_option_nodes_for_pch (void)
11782 hash_table
<cl_option_hasher
>::iterator iter
= cl_option_hash_table
->begin ();
11783 for (; iter
!= cl_option_hash_table
->end (); ++iter
)
11784 if (TREE_CODE (*iter
) == TARGET_OPTION_NODE
)
11785 TREE_TARGET_GLOBALS (*iter
) = NULL
;
11788 /* Determine the "ultimate origin" of a block. The block may be an inlined
11789 instance of an inlined instance of a block which is local to an inline
11790 function, so we have to trace all of the way back through the origin chain
11791 to find out what sort of node actually served as the original seed for the
11795 block_ultimate_origin (const_tree block
)
11797 tree immediate_origin
= BLOCK_ABSTRACT_ORIGIN (block
);
11799 /* BLOCK_ABSTRACT_ORIGIN can point to itself; ignore that if
11800 we're trying to output the abstract instance of this function. */
11801 if (BLOCK_ABSTRACT (block
) && immediate_origin
== block
)
11804 if (immediate_origin
== NULL_TREE
)
11809 tree lookahead
= immediate_origin
;
11813 ret_val
= lookahead
;
11814 lookahead
= (TREE_CODE (ret_val
) == BLOCK
11815 ? BLOCK_ABSTRACT_ORIGIN (ret_val
) : NULL
);
11817 while (lookahead
!= NULL
&& lookahead
!= ret_val
);
11819 /* The block's abstract origin chain may not be the *ultimate* origin of
11820 the block. It could lead to a DECL that has an abstract origin set.
11821 If so, we want that DECL's abstract origin (which is what DECL_ORIGIN
11822 will give us if it has one). Note that DECL's abstract origins are
11823 supposed to be the most distant ancestor (or so decl_ultimate_origin
11824 claims), so we don't need to loop following the DECL origins. */
11825 if (DECL_P (ret_val
))
11826 return DECL_ORIGIN (ret_val
);
11832 /* Return true iff conversion from INNER_TYPE to OUTER_TYPE generates
11836 tree_nop_conversion_p (const_tree outer_type
, const_tree inner_type
)
11838 /* Do not strip casts into or out of differing address spaces. */
11839 if (POINTER_TYPE_P (outer_type
)
11840 && TYPE_ADDR_SPACE (TREE_TYPE (outer_type
)) != ADDR_SPACE_GENERIC
)
11842 if (!POINTER_TYPE_P (inner_type
)
11843 || (TYPE_ADDR_SPACE (TREE_TYPE (outer_type
))
11844 != TYPE_ADDR_SPACE (TREE_TYPE (inner_type
))))
11847 else if (POINTER_TYPE_P (inner_type
)
11848 && TYPE_ADDR_SPACE (TREE_TYPE (inner_type
)) != ADDR_SPACE_GENERIC
)
11850 /* We already know that outer_type is not a pointer with
11851 a non-generic address space. */
11855 /* Use precision rather then machine mode when we can, which gives
11856 the correct answer even for submode (bit-field) types. */
11857 if ((INTEGRAL_TYPE_P (outer_type
)
11858 || POINTER_TYPE_P (outer_type
)
11859 || TREE_CODE (outer_type
) == OFFSET_TYPE
)
11860 && (INTEGRAL_TYPE_P (inner_type
)
11861 || POINTER_TYPE_P (inner_type
)
11862 || TREE_CODE (inner_type
) == OFFSET_TYPE
))
11863 return TYPE_PRECISION (outer_type
) == TYPE_PRECISION (inner_type
);
11865 /* Otherwise fall back on comparing machine modes (e.g. for
11866 aggregate types, floats). */
11867 return TYPE_MODE (outer_type
) == TYPE_MODE (inner_type
);
11870 /* Return true iff conversion in EXP generates no instruction. Mark
11871 it inline so that we fully inline into the stripping functions even
11872 though we have two uses of this function. */
11875 tree_nop_conversion (const_tree exp
)
11877 tree outer_type
, inner_type
;
11879 if (!CONVERT_EXPR_P (exp
)
11880 && TREE_CODE (exp
) != NON_LVALUE_EXPR
)
11882 if (TREE_OPERAND (exp
, 0) == error_mark_node
)
11885 outer_type
= TREE_TYPE (exp
);
11886 inner_type
= TREE_TYPE (TREE_OPERAND (exp
, 0));
11891 return tree_nop_conversion_p (outer_type
, inner_type
);
11894 /* Return true iff conversion in EXP generates no instruction. Don't
11895 consider conversions changing the signedness. */
11898 tree_sign_nop_conversion (const_tree exp
)
11900 tree outer_type
, inner_type
;
11902 if (!tree_nop_conversion (exp
))
11905 outer_type
= TREE_TYPE (exp
);
11906 inner_type
= TREE_TYPE (TREE_OPERAND (exp
, 0));
11908 return (TYPE_UNSIGNED (outer_type
) == TYPE_UNSIGNED (inner_type
)
11909 && POINTER_TYPE_P (outer_type
) == POINTER_TYPE_P (inner_type
));
11912 /* Strip conversions from EXP according to tree_nop_conversion and
11913 return the resulting expression. */
11916 tree_strip_nop_conversions (tree exp
)
11918 while (tree_nop_conversion (exp
))
11919 exp
= TREE_OPERAND (exp
, 0);
11923 /* Strip conversions from EXP according to tree_sign_nop_conversion
11924 and return the resulting expression. */
11927 tree_strip_sign_nop_conversions (tree exp
)
11929 while (tree_sign_nop_conversion (exp
))
11930 exp
= TREE_OPERAND (exp
, 0);
11934 /* Avoid any floating point extensions from EXP. */
11936 strip_float_extensions (tree exp
)
11938 tree sub
, expt
, subt
;
11940 /* For floating point constant look up the narrowest type that can hold
11941 it properly and handle it like (type)(narrowest_type)constant.
11942 This way we can optimize for instance a=a*2.0 where "a" is float
11943 but 2.0 is double constant. */
11944 if (TREE_CODE (exp
) == REAL_CST
&& !DECIMAL_FLOAT_TYPE_P (TREE_TYPE (exp
)))
11946 REAL_VALUE_TYPE orig
;
11949 orig
= TREE_REAL_CST (exp
);
11950 if (TYPE_PRECISION (TREE_TYPE (exp
)) > TYPE_PRECISION (float_type_node
)
11951 && exact_real_truncate (TYPE_MODE (float_type_node
), &orig
))
11952 type
= float_type_node
;
11953 else if (TYPE_PRECISION (TREE_TYPE (exp
))
11954 > TYPE_PRECISION (double_type_node
)
11955 && exact_real_truncate (TYPE_MODE (double_type_node
), &orig
))
11956 type
= double_type_node
;
11958 return build_real_truncate (type
, orig
);
11961 if (!CONVERT_EXPR_P (exp
))
11964 sub
= TREE_OPERAND (exp
, 0);
11965 subt
= TREE_TYPE (sub
);
11966 expt
= TREE_TYPE (exp
);
11968 if (!FLOAT_TYPE_P (subt
))
11971 if (DECIMAL_FLOAT_TYPE_P (expt
) != DECIMAL_FLOAT_TYPE_P (subt
))
11974 if (TYPE_PRECISION (subt
) > TYPE_PRECISION (expt
))
11977 return strip_float_extensions (sub
);
11980 /* Strip out all handled components that produce invariant
11984 strip_invariant_refs (const_tree op
)
11986 while (handled_component_p (op
))
11988 switch (TREE_CODE (op
))
11991 case ARRAY_RANGE_REF
:
11992 if (!is_gimple_constant (TREE_OPERAND (op
, 1))
11993 || TREE_OPERAND (op
, 2) != NULL_TREE
11994 || TREE_OPERAND (op
, 3) != NULL_TREE
)
11998 case COMPONENT_REF
:
11999 if (TREE_OPERAND (op
, 2) != NULL_TREE
)
12005 op
= TREE_OPERAND (op
, 0);
12011 static GTY(()) tree gcc_eh_personality_decl
;
12013 /* Return the GCC personality function decl. */
12016 lhd_gcc_personality (void)
12018 if (!gcc_eh_personality_decl
)
12019 gcc_eh_personality_decl
= build_personality_function ("gcc");
12020 return gcc_eh_personality_decl
;
12023 /* TARGET is a call target of GIMPLE call statement
12024 (obtained by gimple_call_fn). Return true if it is
12025 OBJ_TYPE_REF representing an virtual call of C++ method.
12026 (As opposed to OBJ_TYPE_REF representing objc calls
12027 through a cast where middle-end devirtualization machinery
12031 virtual_method_call_p (const_tree target
)
12033 if (TREE_CODE (target
) != OBJ_TYPE_REF
)
12035 tree t
= TREE_TYPE (target
);
12036 gcc_checking_assert (TREE_CODE (t
) == POINTER_TYPE
);
12038 if (TREE_CODE (t
) == FUNCTION_TYPE
)
12040 gcc_checking_assert (TREE_CODE (t
) == METHOD_TYPE
);
12041 /* If we do not have BINFO associated, it means that type was built
12042 without devirtualization enabled. Do not consider this a virtual
12044 if (!TYPE_BINFO (obj_type_ref_class (target
)))
12049 /* REF is OBJ_TYPE_REF, return the class the ref corresponds to. */
12052 obj_type_ref_class (const_tree ref
)
12054 gcc_checking_assert (TREE_CODE (ref
) == OBJ_TYPE_REF
);
12055 ref
= TREE_TYPE (ref
);
12056 gcc_checking_assert (TREE_CODE (ref
) == POINTER_TYPE
);
12057 ref
= TREE_TYPE (ref
);
12058 /* We look for type THIS points to. ObjC also builds
12059 OBJ_TYPE_REF with non-method calls, Their first parameter
12060 ID however also corresponds to class type. */
12061 gcc_checking_assert (TREE_CODE (ref
) == METHOD_TYPE
12062 || TREE_CODE (ref
) == FUNCTION_TYPE
);
12063 ref
= TREE_VALUE (TYPE_ARG_TYPES (ref
));
12064 gcc_checking_assert (TREE_CODE (ref
) == POINTER_TYPE
);
12065 return TREE_TYPE (ref
);
12068 /* Lookup sub-BINFO of BINFO of TYPE at offset POS. */
12071 lookup_binfo_at_offset (tree binfo
, tree type
, HOST_WIDE_INT pos
)
12074 tree base_binfo
, b
;
12076 for (i
= 0; BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
12077 if (pos
== tree_to_shwi (BINFO_OFFSET (base_binfo
))
12078 && types_same_for_odr (TREE_TYPE (base_binfo
), type
))
12080 else if ((b
= lookup_binfo_at_offset (base_binfo
, type
, pos
)) != NULL
)
12085 /* Try to find a base info of BINFO that would have its field decl at offset
12086 OFFSET within the BINFO type and which is of EXPECTED_TYPE. If it can be
12087 found, return, otherwise return NULL_TREE. */
12090 get_binfo_at_offset (tree binfo
, HOST_WIDE_INT offset
, tree expected_type
)
12092 tree type
= BINFO_TYPE (binfo
);
12096 HOST_WIDE_INT pos
, size
;
12100 if (types_same_for_odr (type
, expected_type
))
12105 for (fld
= TYPE_FIELDS (type
); fld
; fld
= DECL_CHAIN (fld
))
12107 if (TREE_CODE (fld
) != FIELD_DECL
|| !DECL_ARTIFICIAL (fld
))
12110 pos
= int_bit_position (fld
);
12111 size
= tree_to_uhwi (DECL_SIZE (fld
));
12112 if (pos
<= offset
&& (pos
+ size
) > offset
)
12115 if (!fld
|| TREE_CODE (TREE_TYPE (fld
)) != RECORD_TYPE
)
12118 /* Offset 0 indicates the primary base, whose vtable contents are
12119 represented in the binfo for the derived class. */
12120 else if (offset
!= 0)
12122 tree found_binfo
= NULL
, base_binfo
;
12123 /* Offsets in BINFO are in bytes relative to the whole structure
12124 while POS is in bits relative to the containing field. */
12125 int binfo_offset
= (tree_to_shwi (BINFO_OFFSET (binfo
)) + pos
12128 for (i
= 0; BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
12129 if (tree_to_shwi (BINFO_OFFSET (base_binfo
)) == binfo_offset
12130 && types_same_for_odr (TREE_TYPE (base_binfo
), TREE_TYPE (fld
)))
12132 found_binfo
= base_binfo
;
12136 binfo
= found_binfo
;
12138 binfo
= lookup_binfo_at_offset (binfo
, TREE_TYPE (fld
),
12142 type
= TREE_TYPE (fld
);
12147 /* Returns true if X is a typedef decl. */
12150 is_typedef_decl (const_tree x
)
12152 return (x
&& TREE_CODE (x
) == TYPE_DECL
12153 && DECL_ORIGINAL_TYPE (x
) != NULL_TREE
);
12156 /* Returns true iff TYPE is a type variant created for a typedef. */
12159 typedef_variant_p (const_tree type
)
12161 return is_typedef_decl (TYPE_NAME (type
));
12164 /* Warn about a use of an identifier which was marked deprecated. */
12166 warn_deprecated_use (tree node
, tree attr
)
12170 if (node
== 0 || !warn_deprecated_decl
)
12176 attr
= DECL_ATTRIBUTES (node
);
12177 else if (TYPE_P (node
))
12179 tree decl
= TYPE_STUB_DECL (node
);
12181 attr
= lookup_attribute ("deprecated",
12182 TYPE_ATTRIBUTES (TREE_TYPE (decl
)));
12187 attr
= lookup_attribute ("deprecated", attr
);
12190 msg
= TREE_STRING_POINTER (TREE_VALUE (TREE_VALUE (attr
)));
12198 w
= warning (OPT_Wdeprecated_declarations
,
12199 "%qD is deprecated: %s", node
, msg
);
12201 w
= warning (OPT_Wdeprecated_declarations
,
12202 "%qD is deprecated", node
);
12204 inform (DECL_SOURCE_LOCATION (node
), "declared here");
12206 else if (TYPE_P (node
))
12208 tree what
= NULL_TREE
;
12209 tree decl
= TYPE_STUB_DECL (node
);
12211 if (TYPE_NAME (node
))
12213 if (TREE_CODE (TYPE_NAME (node
)) == IDENTIFIER_NODE
)
12214 what
= TYPE_NAME (node
);
12215 else if (TREE_CODE (TYPE_NAME (node
)) == TYPE_DECL
12216 && DECL_NAME (TYPE_NAME (node
)))
12217 what
= DECL_NAME (TYPE_NAME (node
));
12225 w
= warning (OPT_Wdeprecated_declarations
,
12226 "%qE is deprecated: %s", what
, msg
);
12228 w
= warning (OPT_Wdeprecated_declarations
,
12229 "%qE is deprecated", what
);
12234 w
= warning (OPT_Wdeprecated_declarations
,
12235 "type is deprecated: %s", msg
);
12237 w
= warning (OPT_Wdeprecated_declarations
,
12238 "type is deprecated");
12241 inform (DECL_SOURCE_LOCATION (decl
), "declared here");
12248 warning (OPT_Wdeprecated_declarations
, "%qE is deprecated: %s",
12251 warning (OPT_Wdeprecated_declarations
, "%qE is deprecated", what
);
12256 warning (OPT_Wdeprecated_declarations
, "type is deprecated: %s",
12259 warning (OPT_Wdeprecated_declarations
, "type is deprecated");
12265 /* Return true if REF has a COMPONENT_REF with a bit-field field declaration
12266 somewhere in it. */
12269 contains_bitfld_component_ref_p (const_tree ref
)
12271 while (handled_component_p (ref
))
12273 if (TREE_CODE (ref
) == COMPONENT_REF
12274 && DECL_BIT_FIELD (TREE_OPERAND (ref
, 1)))
12276 ref
= TREE_OPERAND (ref
, 0);
12282 /* Try to determine whether a TRY_CATCH expression can fall through.
12283 This is a subroutine of block_may_fallthru. */
12286 try_catch_may_fallthru (const_tree stmt
)
12288 tree_stmt_iterator i
;
12290 /* If the TRY block can fall through, the whole TRY_CATCH can
12292 if (block_may_fallthru (TREE_OPERAND (stmt
, 0)))
12295 i
= tsi_start (TREE_OPERAND (stmt
, 1));
12296 switch (TREE_CODE (tsi_stmt (i
)))
12299 /* We expect to see a sequence of CATCH_EXPR trees, each with a
12300 catch expression and a body. The whole TRY_CATCH may fall
12301 through iff any of the catch bodies falls through. */
12302 for (; !tsi_end_p (i
); tsi_next (&i
))
12304 if (block_may_fallthru (CATCH_BODY (tsi_stmt (i
))))
12309 case EH_FILTER_EXPR
:
12310 /* The exception filter expression only matters if there is an
12311 exception. If the exception does not match EH_FILTER_TYPES,
12312 we will execute EH_FILTER_FAILURE, and we will fall through
12313 if that falls through. If the exception does match
12314 EH_FILTER_TYPES, the stack unwinder will continue up the
12315 stack, so we will not fall through. We don't know whether we
12316 will throw an exception which matches EH_FILTER_TYPES or not,
12317 so we just ignore EH_FILTER_TYPES and assume that we might
12318 throw an exception which doesn't match. */
12319 return block_may_fallthru (EH_FILTER_FAILURE (tsi_stmt (i
)));
12322 /* This case represents statements to be executed when an
12323 exception occurs. Those statements are implicitly followed
12324 by a RESX statement to resume execution after the exception.
12325 So in this case the TRY_CATCH never falls through. */
12330 /* Try to determine if we can fall out of the bottom of BLOCK. This guess
12331 need not be 100% accurate; simply be conservative and return true if we
12332 don't know. This is used only to avoid stupidly generating extra code.
12333 If we're wrong, we'll just delete the extra code later. */
12336 block_may_fallthru (const_tree block
)
12338 /* This CONST_CAST is okay because expr_last returns its argument
12339 unmodified and we assign it to a const_tree. */
12340 const_tree stmt
= expr_last (CONST_CAST_TREE (block
));
12342 switch (stmt
? TREE_CODE (stmt
) : ERROR_MARK
)
12346 /* Easy cases. If the last statement of the block implies
12347 control transfer, then we can't fall through. */
12354 if (block_may_fallthru (COND_EXPR_THEN (stmt
)))
12356 return block_may_fallthru (COND_EXPR_ELSE (stmt
));
12359 return block_may_fallthru (BIND_EXPR_BODY (stmt
));
12361 case TRY_CATCH_EXPR
:
12362 return try_catch_may_fallthru (stmt
);
12364 case TRY_FINALLY_EXPR
:
12365 /* The finally clause is always executed after the try clause,
12366 so if it does not fall through, then the try-finally will not
12367 fall through. Otherwise, if the try clause does not fall
12368 through, then when the finally clause falls through it will
12369 resume execution wherever the try clause was going. So the
12370 whole try-finally will only fall through if both the try
12371 clause and the finally clause fall through. */
12372 return (block_may_fallthru (TREE_OPERAND (stmt
, 0))
12373 && block_may_fallthru (TREE_OPERAND (stmt
, 1)));
12376 if (TREE_CODE (TREE_OPERAND (stmt
, 1)) == CALL_EXPR
)
12377 stmt
= TREE_OPERAND (stmt
, 1);
12383 /* Functions that do not return do not fall through. */
12384 return (call_expr_flags (stmt
) & ECF_NORETURN
) == 0;
12386 case CLEANUP_POINT_EXPR
:
12387 return block_may_fallthru (TREE_OPERAND (stmt
, 0));
12390 return block_may_fallthru (TREE_OPERAND (stmt
, 1));
12396 return lang_hooks
.block_may_fallthru (stmt
);
12400 /* True if we are using EH to handle cleanups. */
12401 static bool using_eh_for_cleanups_flag
= false;
12403 /* This routine is called from front ends to indicate eh should be used for
12406 using_eh_for_cleanups (void)
12408 using_eh_for_cleanups_flag
= true;
12411 /* Query whether EH is used for cleanups. */
12413 using_eh_for_cleanups_p (void)
12415 return using_eh_for_cleanups_flag
;
12418 /* Wrapper for tree_code_name to ensure that tree code is valid */
12420 get_tree_code_name (enum tree_code code
)
12422 const char *invalid
= "<invalid tree code>";
12424 if (code
>= MAX_TREE_CODES
)
12427 return tree_code_name
[code
];
12430 /* Drops the TREE_OVERFLOW flag from T. */
12433 drop_tree_overflow (tree t
)
12435 gcc_checking_assert (TREE_OVERFLOW (t
));
12437 /* For tree codes with a sharing machinery re-build the result. */
12438 if (TREE_CODE (t
) == INTEGER_CST
)
12439 return wide_int_to_tree (TREE_TYPE (t
), wi::to_wide (t
));
12441 /* Otherwise, as all tcc_constants are possibly shared, copy the node
12442 and drop the flag. */
12444 TREE_OVERFLOW (t
) = 0;
12446 /* For constants that contain nested constants, drop the flag
12447 from those as well. */
12448 if (TREE_CODE (t
) == COMPLEX_CST
)
12450 if (TREE_OVERFLOW (TREE_REALPART (t
)))
12451 TREE_REALPART (t
) = drop_tree_overflow (TREE_REALPART (t
));
12452 if (TREE_OVERFLOW (TREE_IMAGPART (t
)))
12453 TREE_IMAGPART (t
) = drop_tree_overflow (TREE_IMAGPART (t
));
12455 if (TREE_CODE (t
) == VECTOR_CST
)
12457 for (unsigned i
= 0; i
< VECTOR_CST_NELTS (t
); ++i
)
12459 tree
& elt
= VECTOR_CST_ELT (t
, i
);
12460 if (TREE_OVERFLOW (elt
))
12461 elt
= drop_tree_overflow (elt
);
12467 /* Given a memory reference expression T, return its base address.
12468 The base address of a memory reference expression is the main
12469 object being referenced. For instance, the base address for
12470 'array[i].fld[j]' is 'array'. You can think of this as stripping
12471 away the offset part from a memory address.
12473 This function calls handled_component_p to strip away all the inner
12474 parts of the memory reference until it reaches the base object. */
12477 get_base_address (tree t
)
12479 while (handled_component_p (t
))
12480 t
= TREE_OPERAND (t
, 0);
12482 if ((TREE_CODE (t
) == MEM_REF
12483 || TREE_CODE (t
) == TARGET_MEM_REF
)
12484 && TREE_CODE (TREE_OPERAND (t
, 0)) == ADDR_EXPR
)
12485 t
= TREE_OPERAND (TREE_OPERAND (t
, 0), 0);
12487 /* ??? Either the alias oracle or all callers need to properly deal
12488 with WITH_SIZE_EXPRs before we can look through those. */
12489 if (TREE_CODE (t
) == WITH_SIZE_EXPR
)
12495 /* Return a tree of sizetype representing the size, in bytes, of the element
12496 of EXP, an ARRAY_REF or an ARRAY_RANGE_REF. */
12499 array_ref_element_size (tree exp
)
12501 tree aligned_size
= TREE_OPERAND (exp
, 3);
12502 tree elmt_type
= TREE_TYPE (TREE_TYPE (TREE_OPERAND (exp
, 0)));
12503 location_t loc
= EXPR_LOCATION (exp
);
12505 /* If a size was specified in the ARRAY_REF, it's the size measured
12506 in alignment units of the element type. So multiply by that value. */
12509 /* ??? tree_ssa_useless_type_conversion will eliminate casts to
12510 sizetype from another type of the same width and signedness. */
12511 if (TREE_TYPE (aligned_size
) != sizetype
)
12512 aligned_size
= fold_convert_loc (loc
, sizetype
, aligned_size
);
12513 return size_binop_loc (loc
, MULT_EXPR
, aligned_size
,
12514 size_int (TYPE_ALIGN_UNIT (elmt_type
)));
12517 /* Otherwise, take the size from that of the element type. Substitute
12518 any PLACEHOLDER_EXPR that we have. */
12520 return SUBSTITUTE_PLACEHOLDER_IN_EXPR (TYPE_SIZE_UNIT (elmt_type
), exp
);
12523 /* Return a tree representing the lower bound of the array mentioned in
12524 EXP, an ARRAY_REF or an ARRAY_RANGE_REF. */
12527 array_ref_low_bound (tree exp
)
12529 tree domain_type
= TYPE_DOMAIN (TREE_TYPE (TREE_OPERAND (exp
, 0)));
12531 /* If a lower bound is specified in EXP, use it. */
12532 if (TREE_OPERAND (exp
, 2))
12533 return TREE_OPERAND (exp
, 2);
12535 /* Otherwise, if there is a domain type and it has a lower bound, use it,
12536 substituting for a PLACEHOLDER_EXPR as needed. */
12537 if (domain_type
&& TYPE_MIN_VALUE (domain_type
))
12538 return SUBSTITUTE_PLACEHOLDER_IN_EXPR (TYPE_MIN_VALUE (domain_type
), exp
);
12540 /* Otherwise, return a zero of the appropriate type. */
12541 return build_int_cst (TREE_TYPE (TREE_OPERAND (exp
, 1)), 0);
12544 /* Return a tree representing the upper bound of the array mentioned in
12545 EXP, an ARRAY_REF or an ARRAY_RANGE_REF. */
12548 array_ref_up_bound (tree exp
)
12550 tree domain_type
= TYPE_DOMAIN (TREE_TYPE (TREE_OPERAND (exp
, 0)));
12552 /* If there is a domain type and it has an upper bound, use it, substituting
12553 for a PLACEHOLDER_EXPR as needed. */
12554 if (domain_type
&& TYPE_MAX_VALUE (domain_type
))
12555 return SUBSTITUTE_PLACEHOLDER_IN_EXPR (TYPE_MAX_VALUE (domain_type
), exp
);
12557 /* Otherwise fail. */
12561 /* Returns true if REF is an array reference or a component reference
12562 to an array at the end of a structure.
12563 If this is the case, the array may be allocated larger
12564 than its upper bound implies. */
12567 array_at_struct_end_p (tree ref
)
12571 if (TREE_CODE (ref
) == ARRAY_REF
12572 || TREE_CODE (ref
) == ARRAY_RANGE_REF
)
12574 atype
= TREE_TYPE (TREE_OPERAND (ref
, 0));
12575 ref
= TREE_OPERAND (ref
, 0);
12577 else if (TREE_CODE (ref
) == COMPONENT_REF
12578 && TREE_CODE (TREE_TYPE (TREE_OPERAND (ref
, 1))) == ARRAY_TYPE
)
12579 atype
= TREE_TYPE (TREE_OPERAND (ref
, 1));
12583 if (TREE_CODE (ref
) == STRING_CST
)
12586 while (handled_component_p (ref
))
12588 /* If the reference chain contains a component reference to a
12589 non-union type and there follows another field the reference
12590 is not at the end of a structure. */
12591 if (TREE_CODE (ref
) == COMPONENT_REF
)
12593 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (ref
, 0))) == RECORD_TYPE
)
12595 tree nextf
= DECL_CHAIN (TREE_OPERAND (ref
, 1));
12596 while (nextf
&& TREE_CODE (nextf
) != FIELD_DECL
)
12597 nextf
= DECL_CHAIN (nextf
);
12602 /* If we have a multi-dimensional array we do not consider
12603 a non-innermost dimension as flex array if the whole
12604 multi-dimensional array is at struct end.
12605 Same for an array of aggregates with a trailing array
12607 else if (TREE_CODE (ref
) == ARRAY_REF
)
12609 else if (TREE_CODE (ref
) == ARRAY_RANGE_REF
)
12611 /* If we view an underlying object as sth else then what we
12612 gathered up to now is what we have to rely on. */
12613 else if (TREE_CODE (ref
) == VIEW_CONVERT_EXPR
)
12616 gcc_unreachable ();
12618 ref
= TREE_OPERAND (ref
, 0);
12621 /* The array now is at struct end. Treat flexible arrays as
12622 always subject to extend, even into just padding constrained by
12623 an underlying decl. */
12624 if (! TYPE_SIZE (atype
))
12629 if (TREE_CODE (ref
) == MEM_REF
12630 && TREE_CODE (TREE_OPERAND (ref
, 0)) == ADDR_EXPR
)
12632 size
= TYPE_SIZE (TREE_TYPE (ref
));
12633 ref
= TREE_OPERAND (TREE_OPERAND (ref
, 0), 0);
12636 /* If the reference is based on a declared entity, the size of the array
12637 is constrained by its given domain. (Do not trust commons PR/69368). */
12639 /* Be sure the size of MEM_REF target match. For example:
12642 struct foo *str = (struct foo *)&buf;
12644 str->trailin_array[2] = 1;
12646 is valid because BUF allocate enough space. */
12648 && (!size
|| (DECL_SIZE (ref
) != NULL
12649 && operand_equal_p (DECL_SIZE (ref
), size
, 0)))
12650 && !(flag_unconstrained_commons
12651 && VAR_P (ref
) && DECL_COMMON (ref
)))
12657 /* Return a tree representing the offset, in bytes, of the field referenced
12658 by EXP. This does not include any offset in DECL_FIELD_BIT_OFFSET. */
12661 component_ref_field_offset (tree exp
)
12663 tree aligned_offset
= TREE_OPERAND (exp
, 2);
12664 tree field
= TREE_OPERAND (exp
, 1);
12665 location_t loc
= EXPR_LOCATION (exp
);
12667 /* If an offset was specified in the COMPONENT_REF, it's the offset measured
12668 in units of DECL_OFFSET_ALIGN / BITS_PER_UNIT. So multiply by that
12670 if (aligned_offset
)
12672 /* ??? tree_ssa_useless_type_conversion will eliminate casts to
12673 sizetype from another type of the same width and signedness. */
12674 if (TREE_TYPE (aligned_offset
) != sizetype
)
12675 aligned_offset
= fold_convert_loc (loc
, sizetype
, aligned_offset
);
12676 return size_binop_loc (loc
, MULT_EXPR
, aligned_offset
,
12677 size_int (DECL_OFFSET_ALIGN (field
)
12681 /* Otherwise, take the offset from that of the field. Substitute
12682 any PLACEHOLDER_EXPR that we have. */
12684 return SUBSTITUTE_PLACEHOLDER_IN_EXPR (DECL_FIELD_OFFSET (field
), exp
);
12687 /* Return the machine mode of T. For vectors, returns the mode of the
12688 inner type. The main use case is to feed the result to HONOR_NANS,
12689 avoiding the BLKmode that a direct TYPE_MODE (T) might return. */
12692 element_mode (const_tree t
)
12696 if (VECTOR_TYPE_P (t
) || TREE_CODE (t
) == COMPLEX_TYPE
)
12698 return TYPE_MODE (t
);
12701 /* Vector types need to re-check the target flags each time we report
12702 the machine mode. We need to do this because attribute target can
12703 change the result of vector_mode_supported_p and have_regs_of_mode
12704 on a per-function basis. Thus the TYPE_MODE of a VECTOR_TYPE can
12705 change on a per-function basis. */
12706 /* ??? Possibly a better solution is to run through all the types
12707 referenced by a function and re-compute the TYPE_MODE once, rather
12708 than make the TYPE_MODE macro call a function. */
12711 vector_type_mode (const_tree t
)
12715 gcc_assert (TREE_CODE (t
) == VECTOR_TYPE
);
12717 mode
= t
->type_common
.mode
;
12718 if (VECTOR_MODE_P (mode
)
12719 && (!targetm
.vector_mode_supported_p (mode
)
12720 || !have_regs_of_mode
[mode
]))
12722 scalar_int_mode innermode
;
12724 /* For integers, try mapping it to a same-sized scalar mode. */
12725 if (is_int_mode (TREE_TYPE (t
)->type_common
.mode
, &innermode
))
12727 unsigned int size
= (TYPE_VECTOR_SUBPARTS (t
)
12728 * GET_MODE_BITSIZE (innermode
));
12729 scalar_int_mode mode
;
12730 if (int_mode_for_size (size
, 0).exists (&mode
)
12731 && have_regs_of_mode
[mode
])
12741 /* Verify that basic properties of T match TV and thus T can be a variant of
12742 TV. TV should be the more specified variant (i.e. the main variant). */
12745 verify_type_variant (const_tree t
, tree tv
)
12747 /* Type variant can differ by:
12749 - TYPE_QUALS: TYPE_READONLY, TYPE_VOLATILE, TYPE_ATOMIC, TYPE_RESTRICT,
12750 ENCODE_QUAL_ADDR_SPACE.
12751 - main variant may be TYPE_COMPLETE_P and variant types !TYPE_COMPLETE_P
12752 in this case some values may not be set in the variant types
12753 (see TYPE_COMPLETE_P checks).
12754 - it is possible to have TYPE_ARTIFICIAL variant of non-artifical type
12755 - by TYPE_NAME and attributes (i.e. when variant originate by typedef)
12756 - TYPE_CANONICAL (TYPE_ALIAS_SET is the same among variants)
12757 - by the alignment: TYPE_ALIGN and TYPE_USER_ALIGN
12758 - during LTO by TYPE_CONTEXT if type is TYPE_FILE_SCOPE_P
12759 this is necessary to make it possible to merge types form different TUs
12760 - arrays, pointers and references may have TREE_TYPE that is a variant
12761 of TREE_TYPE of their main variants.
12762 - aggregates may have new TYPE_FIELDS list that list variants of
12763 the main variant TYPE_FIELDS.
12764 - vector types may differ by TYPE_VECTOR_OPAQUE
12767 /* Convenience macro for matching individual fields. */
12768 #define verify_variant_match(flag) \
12770 if (flag (tv) != flag (t)) \
12772 error ("type variant differs by " #flag "."); \
12778 /* tree_base checks. */
12780 verify_variant_match (TREE_CODE
);
12781 /* FIXME: Ada builds non-artificial variants of artificial types. */
12782 if (TYPE_ARTIFICIAL (tv
) && 0)
12783 verify_variant_match (TYPE_ARTIFICIAL
);
12784 if (POINTER_TYPE_P (tv
))
12785 verify_variant_match (TYPE_REF_CAN_ALIAS_ALL
);
12786 /* FIXME: TYPE_SIZES_GIMPLIFIED may differs for Ada build. */
12787 verify_variant_match (TYPE_UNSIGNED
);
12788 verify_variant_match (TYPE_PACKED
);
12789 if (TREE_CODE (t
) == REFERENCE_TYPE
)
12790 verify_variant_match (TYPE_REF_IS_RVALUE
);
12791 if (AGGREGATE_TYPE_P (t
))
12792 verify_variant_match (TYPE_REVERSE_STORAGE_ORDER
);
12794 verify_variant_match (TYPE_SATURATING
);
12795 /* FIXME: This check trigger during libstdc++ build. */
12796 if (RECORD_OR_UNION_TYPE_P (t
) && COMPLETE_TYPE_P (t
) && 0)
12797 verify_variant_match (TYPE_FINAL_P
);
12799 /* tree_type_common checks. */
12801 if (COMPLETE_TYPE_P (t
))
12803 verify_variant_match (TYPE_MODE
);
12804 if (TREE_CODE (TYPE_SIZE (t
)) != PLACEHOLDER_EXPR
12805 && TREE_CODE (TYPE_SIZE (tv
)) != PLACEHOLDER_EXPR
)
12806 verify_variant_match (TYPE_SIZE
);
12807 if (TREE_CODE (TYPE_SIZE_UNIT (t
)) != PLACEHOLDER_EXPR
12808 && TREE_CODE (TYPE_SIZE_UNIT (tv
)) != PLACEHOLDER_EXPR
12809 && TYPE_SIZE_UNIT (t
) != TYPE_SIZE_UNIT (tv
))
12811 gcc_assert (!operand_equal_p (TYPE_SIZE_UNIT (t
),
12812 TYPE_SIZE_UNIT (tv
), 0));
12813 error ("type variant has different TYPE_SIZE_UNIT");
12815 error ("type variant's TYPE_SIZE_UNIT");
12816 debug_tree (TYPE_SIZE_UNIT (tv
));
12817 error ("type's TYPE_SIZE_UNIT");
12818 debug_tree (TYPE_SIZE_UNIT (t
));
12822 verify_variant_match (TYPE_PRECISION
);
12823 verify_variant_match (TYPE_NEEDS_CONSTRUCTING
);
12824 if (RECORD_OR_UNION_TYPE_P (t
))
12825 verify_variant_match (TYPE_TRANSPARENT_AGGR
);
12826 else if (TREE_CODE (t
) == ARRAY_TYPE
)
12827 verify_variant_match (TYPE_NONALIASED_COMPONENT
);
12828 /* During LTO we merge variant lists from diferent translation units
12829 that may differ BY TYPE_CONTEXT that in turn may point
12830 to TRANSLATION_UNIT_DECL.
12831 Ada also builds variants of types with different TYPE_CONTEXT. */
12832 if ((!in_lto_p
|| !TYPE_FILE_SCOPE_P (t
)) && 0)
12833 verify_variant_match (TYPE_CONTEXT
);
12834 verify_variant_match (TYPE_STRING_FLAG
);
12835 if (TYPE_ALIAS_SET_KNOWN_P (t
))
12837 error ("type variant with TYPE_ALIAS_SET_KNOWN_P");
12842 /* tree_type_non_common checks. */
12844 /* FIXME: C FE uses TYPE_VFIELD to record C_TYPE_INCOMPLETE_VARS
12845 and dangle the pointer from time to time. */
12846 if (RECORD_OR_UNION_TYPE_P (t
) && TYPE_VFIELD (t
) != TYPE_VFIELD (tv
)
12847 && (in_lto_p
|| !TYPE_VFIELD (tv
)
12848 || TREE_CODE (TYPE_VFIELD (tv
)) != TREE_LIST
))
12850 error ("type variant has different TYPE_VFIELD");
12854 if ((TREE_CODE (t
) == ENUMERAL_TYPE
&& COMPLETE_TYPE_P (t
))
12855 || TREE_CODE (t
) == INTEGER_TYPE
12856 || TREE_CODE (t
) == BOOLEAN_TYPE
12857 || TREE_CODE (t
) == REAL_TYPE
12858 || TREE_CODE (t
) == FIXED_POINT_TYPE
)
12860 verify_variant_match (TYPE_MAX_VALUE
);
12861 verify_variant_match (TYPE_MIN_VALUE
);
12863 if (TREE_CODE (t
) == METHOD_TYPE
)
12864 verify_variant_match (TYPE_METHOD_BASETYPE
);
12865 if (TREE_CODE (t
) == OFFSET_TYPE
)
12866 verify_variant_match (TYPE_OFFSET_BASETYPE
);
12867 if (TREE_CODE (t
) == ARRAY_TYPE
)
12868 verify_variant_match (TYPE_ARRAY_MAX_SIZE
);
12869 /* FIXME: Be lax and allow TYPE_BINFO to be missing in variant types
12870 or even type's main variant. This is needed to make bootstrap pass
12871 and the bug seems new in GCC 5.
12872 C++ FE should be updated to make this consistent and we should check
12873 that TYPE_BINFO is always NULL for !COMPLETE_TYPE_P and otherwise there
12874 is a match with main variant.
12876 Also disable the check for Java for now because of parser hack that builds
12877 first an dummy BINFO and then sometimes replace it by real BINFO in some
12879 if (RECORD_OR_UNION_TYPE_P (t
) && TYPE_BINFO (t
) && TYPE_BINFO (tv
)
12880 && TYPE_BINFO (t
) != TYPE_BINFO (tv
)
12881 /* FIXME: Java sometimes keep dump TYPE_BINFOs on variant types.
12882 Since there is no cheap way to tell C++/Java type w/o LTO, do checking
12883 at LTO time only. */
12884 && (in_lto_p
&& odr_type_p (t
)))
12886 error ("type variant has different TYPE_BINFO");
12888 error ("type variant's TYPE_BINFO");
12889 debug_tree (TYPE_BINFO (tv
));
12890 error ("type's TYPE_BINFO");
12891 debug_tree (TYPE_BINFO (t
));
12895 /* Check various uses of TYPE_VALUES_RAW. */
12896 if (TREE_CODE (t
) == ENUMERAL_TYPE
)
12897 verify_variant_match (TYPE_VALUES
);
12898 else if (TREE_CODE (t
) == ARRAY_TYPE
)
12899 verify_variant_match (TYPE_DOMAIN
);
12900 /* Permit incomplete variants of complete type. While FEs may complete
12901 all variants, this does not happen for C++ templates in all cases. */
12902 else if (RECORD_OR_UNION_TYPE_P (t
)
12903 && COMPLETE_TYPE_P (t
)
12904 && TYPE_FIELDS (t
) != TYPE_FIELDS (tv
))
12908 /* Fortran builds qualified variants as new records with items of
12909 qualified type. Verify that they looks same. */
12910 for (f1
= TYPE_FIELDS (t
), f2
= TYPE_FIELDS (tv
);
12912 f1
= TREE_CHAIN (f1
), f2
= TREE_CHAIN (f2
))
12913 if (TREE_CODE (f1
) != FIELD_DECL
|| TREE_CODE (f2
) != FIELD_DECL
12914 || (TYPE_MAIN_VARIANT (TREE_TYPE (f1
))
12915 != TYPE_MAIN_VARIANT (TREE_TYPE (f2
))
12916 /* FIXME: gfc_nonrestricted_type builds all types as variants
12917 with exception of pointer types. It deeply copies the type
12918 which means that we may end up with a variant type
12919 referring non-variant pointer. We may change it to
12920 produce types as variants, too, like
12921 objc_get_protocol_qualified_type does. */
12922 && !POINTER_TYPE_P (TREE_TYPE (f1
)))
12923 || DECL_FIELD_OFFSET (f1
) != DECL_FIELD_OFFSET (f2
)
12924 || DECL_FIELD_BIT_OFFSET (f1
) != DECL_FIELD_BIT_OFFSET (f2
))
12928 error ("type variant has different TYPE_FIELDS");
12930 error ("first mismatch is field");
12932 error ("and field");
12937 else if ((TREE_CODE (t
) == FUNCTION_TYPE
|| TREE_CODE (t
) == METHOD_TYPE
))
12938 verify_variant_match (TYPE_ARG_TYPES
);
12939 /* For C++ the qualified variant of array type is really an array type
12940 of qualified TREE_TYPE.
12941 objc builds variants of pointer where pointer to type is a variant, too
12942 in objc_get_protocol_qualified_type. */
12943 if (TREE_TYPE (t
) != TREE_TYPE (tv
)
12944 && ((TREE_CODE (t
) != ARRAY_TYPE
12945 && !POINTER_TYPE_P (t
))
12946 || TYPE_MAIN_VARIANT (TREE_TYPE (t
))
12947 != TYPE_MAIN_VARIANT (TREE_TYPE (tv
))))
12949 error ("type variant has different TREE_TYPE");
12951 error ("type variant's TREE_TYPE");
12952 debug_tree (TREE_TYPE (tv
));
12953 error ("type's TREE_TYPE");
12954 debug_tree (TREE_TYPE (t
));
12957 if (type_with_alias_set_p (t
)
12958 && !gimple_canonical_types_compatible_p (t
, tv
, false))
12960 error ("type is not compatible with its variant");
12962 error ("type variant's TREE_TYPE");
12963 debug_tree (TREE_TYPE (tv
));
12964 error ("type's TREE_TYPE");
12965 debug_tree (TREE_TYPE (t
));
12969 #undef verify_variant_match
12973 /* The TYPE_CANONICAL merging machinery. It should closely resemble
12974 the middle-end types_compatible_p function. It needs to avoid
12975 claiming types are different for types that should be treated
12976 the same with respect to TBAA. Canonical types are also used
12977 for IL consistency checks via the useless_type_conversion_p
12978 predicate which does not handle all type kinds itself but falls
12979 back to pointer-comparison of TYPE_CANONICAL for aggregates
12982 /* Return true if TYPE_UNSIGNED of TYPE should be ignored for canonical
12983 type calculation because we need to allow inter-operability between signed
12984 and unsigned variants. */
12987 type_with_interoperable_signedness (const_tree type
)
12989 /* Fortran standard require C_SIGNED_CHAR to be interoperable with both
12990 signed char and unsigned char. Similarly fortran FE builds
12991 C_SIZE_T as signed type, while C defines it unsigned. */
12993 return tree_code_for_canonical_type_merging (TREE_CODE (type
))
12995 && (TYPE_PRECISION (type
) == TYPE_PRECISION (signed_char_type_node
)
12996 || TYPE_PRECISION (type
) == TYPE_PRECISION (size_type_node
));
12999 /* Return true iff T1 and T2 are structurally identical for what
13001 This function is used both by lto.c canonical type merging and by the
13002 verifier. If TRUST_TYPE_CANONICAL we do not look into structure of types
13003 that have TYPE_CANONICAL defined and assume them equivalent. This is useful
13004 only for LTO because only in these cases TYPE_CANONICAL equivalence
13005 correspond to one defined by gimple_canonical_types_compatible_p. */
13008 gimple_canonical_types_compatible_p (const_tree t1
, const_tree t2
,
13009 bool trust_type_canonical
)
13011 /* Type variants should be same as the main variant. When not doing sanity
13012 checking to verify this fact, go to main variants and save some work. */
13013 if (trust_type_canonical
)
13015 t1
= TYPE_MAIN_VARIANT (t1
);
13016 t2
= TYPE_MAIN_VARIANT (t2
);
13019 /* Check first for the obvious case of pointer identity. */
13023 /* Check that we have two types to compare. */
13024 if (t1
== NULL_TREE
|| t2
== NULL_TREE
)
13027 /* We consider complete types always compatible with incomplete type.
13028 This does not make sense for canonical type calculation and thus we
13029 need to ensure that we are never called on it.
13031 FIXME: For more correctness the function probably should have three modes
13032 1) mode assuming that types are complete mathcing their structure
13033 2) mode allowing incomplete types but producing equivalence classes
13034 and thus ignoring all info from complete types
13035 3) mode allowing incomplete types to match complete but checking
13036 compatibility between complete types.
13038 1 and 2 can be used for canonical type calculation. 3 is the real
13039 definition of type compatibility that can be used i.e. for warnings during
13040 declaration merging. */
13042 gcc_assert (!trust_type_canonical
13043 || (type_with_alias_set_p (t1
) && type_with_alias_set_p (t2
)));
13044 /* If the types have been previously registered and found equal
13047 if (TYPE_CANONICAL (t1
) && TYPE_CANONICAL (t2
)
13048 && trust_type_canonical
)
13050 /* Do not use TYPE_CANONICAL of pointer types. For LTO streamed types
13051 they are always NULL, but they are set to non-NULL for types
13052 constructed by build_pointer_type and variants. In this case the
13053 TYPE_CANONICAL is more fine grained than the equivalnce we test (where
13054 all pointers are considered equal. Be sure to not return false
13056 gcc_checking_assert (canonical_type_used_p (t1
)
13057 && canonical_type_used_p (t2
));
13058 return TYPE_CANONICAL (t1
) == TYPE_CANONICAL (t2
);
13061 /* Can't be the same type if the types don't have the same code. */
13062 enum tree_code code
= tree_code_for_canonical_type_merging (TREE_CODE (t1
));
13063 if (code
!= tree_code_for_canonical_type_merging (TREE_CODE (t2
)))
13066 /* Qualifiers do not matter for canonical type comparison purposes. */
13068 /* Void types and nullptr types are always the same. */
13069 if (TREE_CODE (t1
) == VOID_TYPE
13070 || TREE_CODE (t1
) == NULLPTR_TYPE
)
13073 /* Can't be the same type if they have different mode. */
13074 if (TYPE_MODE (t1
) != TYPE_MODE (t2
))
13077 /* Non-aggregate types can be handled cheaply. */
13078 if (INTEGRAL_TYPE_P (t1
)
13079 || SCALAR_FLOAT_TYPE_P (t1
)
13080 || FIXED_POINT_TYPE_P (t1
)
13081 || TREE_CODE (t1
) == VECTOR_TYPE
13082 || TREE_CODE (t1
) == COMPLEX_TYPE
13083 || TREE_CODE (t1
) == OFFSET_TYPE
13084 || POINTER_TYPE_P (t1
))
13086 /* Can't be the same type if they have different recision. */
13087 if (TYPE_PRECISION (t1
) != TYPE_PRECISION (t2
))
13090 /* In some cases the signed and unsigned types are required to be
13092 if (TYPE_UNSIGNED (t1
) != TYPE_UNSIGNED (t2
)
13093 && !type_with_interoperable_signedness (t1
))
13096 /* Fortran's C_SIGNED_CHAR is !TYPE_STRING_FLAG but needs to be
13097 interoperable with "signed char". Unless all frontends are revisited
13098 to agree on these types, we must ignore the flag completely. */
13100 /* Fortran standard define C_PTR type that is compatible with every
13101 C pointer. For this reason we need to glob all pointers into one.
13102 Still pointers in different address spaces are not compatible. */
13103 if (POINTER_TYPE_P (t1
))
13105 if (TYPE_ADDR_SPACE (TREE_TYPE (t1
))
13106 != TYPE_ADDR_SPACE (TREE_TYPE (t2
)))
13110 /* Tail-recurse to components. */
13111 if (TREE_CODE (t1
) == VECTOR_TYPE
13112 || TREE_CODE (t1
) == COMPLEX_TYPE
)
13113 return gimple_canonical_types_compatible_p (TREE_TYPE (t1
),
13115 trust_type_canonical
);
13120 /* Do type-specific comparisons. */
13121 switch (TREE_CODE (t1
))
13124 /* Array types are the same if the element types are the same and
13125 the number of elements are the same. */
13126 if (!gimple_canonical_types_compatible_p (TREE_TYPE (t1
), TREE_TYPE (t2
),
13127 trust_type_canonical
)
13128 || TYPE_STRING_FLAG (t1
) != TYPE_STRING_FLAG (t2
)
13129 || TYPE_REVERSE_STORAGE_ORDER (t1
) != TYPE_REVERSE_STORAGE_ORDER (t2
)
13130 || TYPE_NONALIASED_COMPONENT (t1
) != TYPE_NONALIASED_COMPONENT (t2
))
13134 tree i1
= TYPE_DOMAIN (t1
);
13135 tree i2
= TYPE_DOMAIN (t2
);
13137 /* For an incomplete external array, the type domain can be
13138 NULL_TREE. Check this condition also. */
13139 if (i1
== NULL_TREE
&& i2
== NULL_TREE
)
13141 else if (i1
== NULL_TREE
|| i2
== NULL_TREE
)
13145 tree min1
= TYPE_MIN_VALUE (i1
);
13146 tree min2
= TYPE_MIN_VALUE (i2
);
13147 tree max1
= TYPE_MAX_VALUE (i1
);
13148 tree max2
= TYPE_MAX_VALUE (i2
);
13150 /* The minimum/maximum values have to be the same. */
13153 && ((TREE_CODE (min1
) == PLACEHOLDER_EXPR
13154 && TREE_CODE (min2
) == PLACEHOLDER_EXPR
)
13155 || operand_equal_p (min1
, min2
, 0))))
13158 && ((TREE_CODE (max1
) == PLACEHOLDER_EXPR
13159 && TREE_CODE (max2
) == PLACEHOLDER_EXPR
)
13160 || operand_equal_p (max1
, max2
, 0)))))
13168 case FUNCTION_TYPE
:
13169 /* Function types are the same if the return type and arguments types
13171 if (!gimple_canonical_types_compatible_p (TREE_TYPE (t1
), TREE_TYPE (t2
),
13172 trust_type_canonical
))
13175 if (TYPE_ARG_TYPES (t1
) == TYPE_ARG_TYPES (t2
))
13179 tree parms1
, parms2
;
13181 for (parms1
= TYPE_ARG_TYPES (t1
), parms2
= TYPE_ARG_TYPES (t2
);
13183 parms1
= TREE_CHAIN (parms1
), parms2
= TREE_CHAIN (parms2
))
13185 if (!gimple_canonical_types_compatible_p
13186 (TREE_VALUE (parms1
), TREE_VALUE (parms2
),
13187 trust_type_canonical
))
13191 if (parms1
|| parms2
)
13199 case QUAL_UNION_TYPE
:
13203 /* Don't try to compare variants of an incomplete type, before
13204 TYPE_FIELDS has been copied around. */
13205 if (!COMPLETE_TYPE_P (t1
) && !COMPLETE_TYPE_P (t2
))
13209 if (TYPE_REVERSE_STORAGE_ORDER (t1
) != TYPE_REVERSE_STORAGE_ORDER (t2
))
13212 /* For aggregate types, all the fields must be the same. */
13213 for (f1
= TYPE_FIELDS (t1
), f2
= TYPE_FIELDS (t2
);
13215 f1
= TREE_CHAIN (f1
), f2
= TREE_CHAIN (f2
))
13217 /* Skip non-fields and zero-sized fields. */
13218 while (f1
&& (TREE_CODE (f1
) != FIELD_DECL
13220 && integer_zerop (DECL_SIZE (f1
)))))
13221 f1
= TREE_CHAIN (f1
);
13222 while (f2
&& (TREE_CODE (f2
) != FIELD_DECL
13224 && integer_zerop (DECL_SIZE (f2
)))))
13225 f2
= TREE_CHAIN (f2
);
13228 /* The fields must have the same name, offset and type. */
13229 if (DECL_NONADDRESSABLE_P (f1
) != DECL_NONADDRESSABLE_P (f2
)
13230 || !gimple_compare_field_offset (f1
, f2
)
13231 || !gimple_canonical_types_compatible_p
13232 (TREE_TYPE (f1
), TREE_TYPE (f2
),
13233 trust_type_canonical
))
13237 /* If one aggregate has more fields than the other, they
13238 are not the same. */
13246 /* Consider all types with language specific trees in them mutually
13247 compatible. This is executed only from verify_type and false
13248 positives can be tolerated. */
13249 gcc_assert (!in_lto_p
);
13254 /* Verify type T. */
13257 verify_type (const_tree t
)
13259 bool error_found
= false;
13260 tree mv
= TYPE_MAIN_VARIANT (t
);
13263 error ("Main variant is not defined");
13264 error_found
= true;
13266 else if (mv
!= TYPE_MAIN_VARIANT (mv
))
13268 error ("TYPE_MAIN_VARIANT has different TYPE_MAIN_VARIANT");
13270 error_found
= true;
13272 else if (t
!= mv
&& !verify_type_variant (t
, mv
))
13273 error_found
= true;
13275 tree ct
= TYPE_CANONICAL (t
);
13278 else if (TYPE_CANONICAL (t
) != ct
)
13280 error ("TYPE_CANONICAL has different TYPE_CANONICAL");
13282 error_found
= true;
13284 /* Method and function types can not be used to address memory and thus
13285 TYPE_CANONICAL really matters only for determining useless conversions.
13287 FIXME: C++ FE produce declarations of builtin functions that are not
13288 compatible with main variants. */
13289 else if (TREE_CODE (t
) == FUNCTION_TYPE
)
13292 /* FIXME: gimple_canonical_types_compatible_p can not compare types
13293 with variably sized arrays because their sizes possibly
13294 gimplified to different variables. */
13295 && !variably_modified_type_p (ct
, NULL
)
13296 && !gimple_canonical_types_compatible_p (t
, ct
, false))
13298 error ("TYPE_CANONICAL is not compatible");
13300 error_found
= true;
13303 if (COMPLETE_TYPE_P (t
) && TYPE_CANONICAL (t
)
13304 && TYPE_MODE (t
) != TYPE_MODE (TYPE_CANONICAL (t
)))
13306 error ("TYPE_MODE of TYPE_CANONICAL is not compatible");
13308 error_found
= true;
13310 if (TYPE_MAIN_VARIANT (t
) == t
&& ct
&& TYPE_MAIN_VARIANT (ct
) != ct
)
13312 error ("TYPE_CANONICAL of main variant is not main variant");
13314 debug_tree (TYPE_MAIN_VARIANT (ct
));
13315 error_found
= true;
13319 /* Check various uses of TYPE_MIN_VALUE_RAW. */
13320 if (RECORD_OR_UNION_TYPE_P (t
))
13322 /* FIXME: C FE uses TYPE_VFIELD to record C_TYPE_INCOMPLETE_VARS
13323 and danagle the pointer from time to time. */
13324 if (TYPE_VFIELD (t
)
13325 && TREE_CODE (TYPE_VFIELD (t
)) != FIELD_DECL
13326 && TREE_CODE (TYPE_VFIELD (t
)) != TREE_LIST
)
13328 error ("TYPE_VFIELD is not FIELD_DECL nor TREE_LIST");
13329 debug_tree (TYPE_VFIELD (t
));
13330 error_found
= true;
13333 else if (TREE_CODE (t
) == POINTER_TYPE
)
13335 if (TYPE_NEXT_PTR_TO (t
)
13336 && TREE_CODE (TYPE_NEXT_PTR_TO (t
)) != POINTER_TYPE
)
13338 error ("TYPE_NEXT_PTR_TO is not POINTER_TYPE");
13339 debug_tree (TYPE_NEXT_PTR_TO (t
));
13340 error_found
= true;
13343 else if (TREE_CODE (t
) == REFERENCE_TYPE
)
13345 if (TYPE_NEXT_REF_TO (t
)
13346 && TREE_CODE (TYPE_NEXT_REF_TO (t
)) != REFERENCE_TYPE
)
13348 error ("TYPE_NEXT_REF_TO is not REFERENCE_TYPE");
13349 debug_tree (TYPE_NEXT_REF_TO (t
));
13350 error_found
= true;
13353 else if (INTEGRAL_TYPE_P (t
) || TREE_CODE (t
) == REAL_TYPE
13354 || TREE_CODE (t
) == FIXED_POINT_TYPE
)
13356 /* FIXME: The following check should pass:
13357 useless_type_conversion_p (const_cast <tree> (t),
13358 TREE_TYPE (TYPE_MIN_VALUE (t))
13359 but does not for C sizetypes in LTO. */
13362 /* Check various uses of TYPE_MAXVAL_RAW. */
13363 if (RECORD_OR_UNION_TYPE_P (t
))
13365 if (!TYPE_BINFO (t
))
13367 else if (TREE_CODE (TYPE_BINFO (t
)) != TREE_BINFO
)
13369 error ("TYPE_BINFO is not TREE_BINFO");
13370 debug_tree (TYPE_BINFO (t
));
13371 error_found
= true;
13373 else if (TREE_TYPE (TYPE_BINFO (t
)) != TYPE_MAIN_VARIANT (t
))
13375 error ("TYPE_BINFO type is not TYPE_MAIN_VARIANT");
13376 debug_tree (TREE_TYPE (TYPE_BINFO (t
)));
13377 error_found
= true;
13380 else if (TREE_CODE (t
) == FUNCTION_TYPE
|| TREE_CODE (t
) == METHOD_TYPE
)
13382 if (TYPE_METHOD_BASETYPE (t
)
13383 && TREE_CODE (TYPE_METHOD_BASETYPE (t
)) != RECORD_TYPE
13384 && TREE_CODE (TYPE_METHOD_BASETYPE (t
)) != UNION_TYPE
)
13386 error ("TYPE_METHOD_BASETYPE is not record nor union");
13387 debug_tree (TYPE_METHOD_BASETYPE (t
));
13388 error_found
= true;
13391 else if (TREE_CODE (t
) == OFFSET_TYPE
)
13393 if (TYPE_OFFSET_BASETYPE (t
)
13394 && TREE_CODE (TYPE_OFFSET_BASETYPE (t
)) != RECORD_TYPE
13395 && TREE_CODE (TYPE_OFFSET_BASETYPE (t
)) != UNION_TYPE
)
13397 error ("TYPE_OFFSET_BASETYPE is not record nor union");
13398 debug_tree (TYPE_OFFSET_BASETYPE (t
));
13399 error_found
= true;
13402 else if (INTEGRAL_TYPE_P (t
) || TREE_CODE (t
) == REAL_TYPE
13403 || TREE_CODE (t
) == FIXED_POINT_TYPE
)
13405 /* FIXME: The following check should pass:
13406 useless_type_conversion_p (const_cast <tree> (t),
13407 TREE_TYPE (TYPE_MAX_VALUE (t))
13408 but does not for C sizetypes in LTO. */
13410 else if (TREE_CODE (t
) == ARRAY_TYPE
)
13412 if (TYPE_ARRAY_MAX_SIZE (t
)
13413 && TREE_CODE (TYPE_ARRAY_MAX_SIZE (t
)) != INTEGER_CST
)
13415 error ("TYPE_ARRAY_MAX_SIZE not INTEGER_CST");
13416 debug_tree (TYPE_ARRAY_MAX_SIZE (t
));
13417 error_found
= true;
13420 else if (TYPE_MAX_VALUE_RAW (t
))
13422 error ("TYPE_MAX_VALUE_RAW non-NULL");
13423 debug_tree (TYPE_MAX_VALUE_RAW (t
));
13424 error_found
= true;
13427 if (TYPE_LANG_SLOT_1 (t
) && in_lto_p
)
13429 error ("TYPE_LANG_SLOT_1 (binfo) field is non-NULL");
13430 debug_tree (TYPE_LANG_SLOT_1 (t
));
13431 error_found
= true;
13434 /* Check various uses of TYPE_VALUES_RAW. */
13435 if (TREE_CODE (t
) == ENUMERAL_TYPE
)
13436 for (tree l
= TYPE_VALUES (t
); l
; l
= TREE_CHAIN (l
))
13438 tree value
= TREE_VALUE (l
);
13439 tree name
= TREE_PURPOSE (l
);
13441 /* C FE porduce INTEGER_CST of INTEGER_TYPE, while C++ FE uses
13442 CONST_DECL of ENUMERAL TYPE. */
13443 if (TREE_CODE (value
) != INTEGER_CST
&& TREE_CODE (value
) != CONST_DECL
)
13445 error ("Enum value is not CONST_DECL or INTEGER_CST");
13446 debug_tree (value
);
13448 error_found
= true;
13450 if (TREE_CODE (TREE_TYPE (value
)) != INTEGER_TYPE
13451 && !useless_type_conversion_p (const_cast <tree
> (t
), TREE_TYPE (value
)))
13453 error ("Enum value type is not INTEGER_TYPE nor convertible to the enum");
13454 debug_tree (value
);
13456 error_found
= true;
13458 if (TREE_CODE (name
) != IDENTIFIER_NODE
)
13460 error ("Enum value name is not IDENTIFIER_NODE");
13461 debug_tree (value
);
13463 error_found
= true;
13466 else if (TREE_CODE (t
) == ARRAY_TYPE
)
13468 if (TYPE_DOMAIN (t
) && TREE_CODE (TYPE_DOMAIN (t
)) != INTEGER_TYPE
)
13470 error ("Array TYPE_DOMAIN is not integer type");
13471 debug_tree (TYPE_DOMAIN (t
));
13472 error_found
= true;
13475 else if (RECORD_OR_UNION_TYPE_P (t
))
13477 if (TYPE_FIELDS (t
) && !COMPLETE_TYPE_P (t
) && in_lto_p
)
13479 error ("TYPE_FIELDS defined in incomplete type");
13480 error_found
= true;
13482 for (tree fld
= TYPE_FIELDS (t
); fld
; fld
= TREE_CHAIN (fld
))
13484 /* TODO: verify properties of decls. */
13485 if (TREE_CODE (fld
) == FIELD_DECL
)
13487 else if (TREE_CODE (fld
) == TYPE_DECL
)
13489 else if (TREE_CODE (fld
) == CONST_DECL
)
13491 else if (VAR_P (fld
))
13493 else if (TREE_CODE (fld
) == TEMPLATE_DECL
)
13495 else if (TREE_CODE (fld
) == USING_DECL
)
13497 else if (TREE_CODE (fld
) == FUNCTION_DECL
)
13501 error ("Wrong tree in TYPE_FIELDS list");
13503 error_found
= true;
13507 else if (TREE_CODE (t
) == INTEGER_TYPE
13508 || TREE_CODE (t
) == BOOLEAN_TYPE
13509 || TREE_CODE (t
) == OFFSET_TYPE
13510 || TREE_CODE (t
) == REFERENCE_TYPE
13511 || TREE_CODE (t
) == NULLPTR_TYPE
13512 || TREE_CODE (t
) == POINTER_TYPE
)
13514 if (TYPE_CACHED_VALUES_P (t
) != (TYPE_CACHED_VALUES (t
) != NULL
))
13516 error ("TYPE_CACHED_VALUES_P is %i while TYPE_CACHED_VALUES is %p",
13517 TYPE_CACHED_VALUES_P (t
), (void *)TYPE_CACHED_VALUES (t
));
13518 error_found
= true;
13520 else if (TYPE_CACHED_VALUES_P (t
) && TREE_CODE (TYPE_CACHED_VALUES (t
)) != TREE_VEC
)
13522 error ("TYPE_CACHED_VALUES is not TREE_VEC");
13523 debug_tree (TYPE_CACHED_VALUES (t
));
13524 error_found
= true;
13526 /* Verify just enough of cache to ensure that no one copied it to new type.
13527 All copying should go by copy_node that should clear it. */
13528 else if (TYPE_CACHED_VALUES_P (t
))
13531 for (i
= 0; i
< TREE_VEC_LENGTH (TYPE_CACHED_VALUES (t
)); i
++)
13532 if (TREE_VEC_ELT (TYPE_CACHED_VALUES (t
), i
)
13533 && TREE_TYPE (TREE_VEC_ELT (TYPE_CACHED_VALUES (t
), i
)) != t
)
13535 error ("wrong TYPE_CACHED_VALUES entry");
13536 debug_tree (TREE_VEC_ELT (TYPE_CACHED_VALUES (t
), i
));
13537 error_found
= true;
13542 else if (TREE_CODE (t
) == FUNCTION_TYPE
|| TREE_CODE (t
) == METHOD_TYPE
)
13543 for (tree l
= TYPE_ARG_TYPES (t
); l
; l
= TREE_CHAIN (l
))
13545 /* C++ FE uses TREE_PURPOSE to store initial values. */
13546 if (TREE_PURPOSE (l
) && in_lto_p
)
13548 error ("TREE_PURPOSE is non-NULL in TYPE_ARG_TYPES list");
13550 error_found
= true;
13552 if (!TYPE_P (TREE_VALUE (l
)))
13554 error ("Wrong entry in TYPE_ARG_TYPES list");
13556 error_found
= true;
13559 else if (!is_lang_specific (t
) && TYPE_VALUES_RAW (t
))
13561 error ("TYPE_VALUES_RAW field is non-NULL");
13562 debug_tree (TYPE_VALUES_RAW (t
));
13563 error_found
= true;
13565 if (TREE_CODE (t
) != INTEGER_TYPE
13566 && TREE_CODE (t
) != BOOLEAN_TYPE
13567 && TREE_CODE (t
) != OFFSET_TYPE
13568 && TREE_CODE (t
) != REFERENCE_TYPE
13569 && TREE_CODE (t
) != NULLPTR_TYPE
13570 && TREE_CODE (t
) != POINTER_TYPE
13571 && TYPE_CACHED_VALUES_P (t
))
13573 error ("TYPE_CACHED_VALUES_P is set while it should not");
13574 error_found
= true;
13576 if (TYPE_STRING_FLAG (t
)
13577 && TREE_CODE (t
) != ARRAY_TYPE
&& TREE_CODE (t
) != INTEGER_TYPE
)
13579 error ("TYPE_STRING_FLAG is set on wrong type code");
13580 error_found
= true;
13583 /* ipa-devirt makes an assumption that TYPE_METHOD_BASETYPE is always
13584 TYPE_MAIN_VARIANT and it would be odd to add methods only to variatns
13586 if (TREE_CODE (t
) == METHOD_TYPE
13587 && TYPE_MAIN_VARIANT (TYPE_METHOD_BASETYPE (t
)) != TYPE_METHOD_BASETYPE (t
))
13589 error ("TYPE_METHOD_BASETYPE is not main variant");
13590 error_found
= true;
13595 debug_tree (const_cast <tree
> (t
));
13596 internal_error ("verify_type failed");
13601 /* Return 1 if ARG interpreted as signed in its precision is known to be
13602 always positive or 2 if ARG is known to be always negative, or 3 if
13603 ARG may be positive or negative. */
13606 get_range_pos_neg (tree arg
)
13608 if (arg
== error_mark_node
)
13611 int prec
= TYPE_PRECISION (TREE_TYPE (arg
));
13613 if (TREE_CODE (arg
) == INTEGER_CST
)
13615 wide_int w
= wi::sext (wi::to_wide (arg
), prec
);
13621 while (CONVERT_EXPR_P (arg
)
13622 && INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (arg
, 0)))
13623 && TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (arg
, 0))) <= prec
)
13625 arg
= TREE_OPERAND (arg
, 0);
13626 /* Narrower value zero extended into wider type
13627 will always result in positive values. */
13628 if (TYPE_UNSIGNED (TREE_TYPE (arg
))
13629 && TYPE_PRECISION (TREE_TYPE (arg
)) < prec
)
13631 prec
= TYPE_PRECISION (TREE_TYPE (arg
));
13636 if (TREE_CODE (arg
) != SSA_NAME
)
13638 wide_int arg_min
, arg_max
;
13639 while (get_range_info (arg
, &arg_min
, &arg_max
) != VR_RANGE
)
13641 gimple
*g
= SSA_NAME_DEF_STMT (arg
);
13642 if (is_gimple_assign (g
)
13643 && CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (g
)))
13645 tree t
= gimple_assign_rhs1 (g
);
13646 if (INTEGRAL_TYPE_P (TREE_TYPE (t
))
13647 && TYPE_PRECISION (TREE_TYPE (t
)) <= prec
)
13649 if (TYPE_UNSIGNED (TREE_TYPE (t
))
13650 && TYPE_PRECISION (TREE_TYPE (t
)) < prec
)
13652 prec
= TYPE_PRECISION (TREE_TYPE (t
));
13661 if (TYPE_UNSIGNED (TREE_TYPE (arg
)))
13663 /* For unsigned values, the "positive" range comes
13664 below the "negative" range. */
13665 if (!wi::neg_p (wi::sext (arg_max
, prec
), SIGNED
))
13667 if (wi::neg_p (wi::sext (arg_min
, prec
), SIGNED
))
13672 if (!wi::neg_p (wi::sext (arg_min
, prec
), SIGNED
))
13674 if (wi::neg_p (wi::sext (arg_max
, prec
), SIGNED
))
13683 /* Return true if ARG is marked with the nonnull attribute in the
13684 current function signature. */
13687 nonnull_arg_p (const_tree arg
)
13689 tree t
, attrs
, fntype
;
13690 unsigned HOST_WIDE_INT arg_num
;
13692 gcc_assert (TREE_CODE (arg
) == PARM_DECL
13693 && (POINTER_TYPE_P (TREE_TYPE (arg
))
13694 || TREE_CODE (TREE_TYPE (arg
)) == OFFSET_TYPE
));
13696 /* The static chain decl is always non null. */
13697 if (arg
== cfun
->static_chain_decl
)
13700 /* THIS argument of method is always non-NULL. */
13701 if (TREE_CODE (TREE_TYPE (cfun
->decl
)) == METHOD_TYPE
13702 && arg
== DECL_ARGUMENTS (cfun
->decl
)
13703 && flag_delete_null_pointer_checks
)
13706 /* Values passed by reference are always non-NULL. */
13707 if (TREE_CODE (TREE_TYPE (arg
)) == REFERENCE_TYPE
13708 && flag_delete_null_pointer_checks
)
13711 fntype
= TREE_TYPE (cfun
->decl
);
13712 for (attrs
= TYPE_ATTRIBUTES (fntype
); attrs
; attrs
= TREE_CHAIN (attrs
))
13714 attrs
= lookup_attribute ("nonnull", attrs
);
13716 /* If "nonnull" wasn't specified, we know nothing about the argument. */
13717 if (attrs
== NULL_TREE
)
13720 /* If "nonnull" applies to all the arguments, then ARG is non-null. */
13721 if (TREE_VALUE (attrs
) == NULL_TREE
)
13724 /* Get the position number for ARG in the function signature. */
13725 for (arg_num
= 1, t
= DECL_ARGUMENTS (cfun
->decl
);
13727 t
= DECL_CHAIN (t
), arg_num
++)
13733 gcc_assert (t
== arg
);
13735 /* Now see if ARG_NUM is mentioned in the nonnull list. */
13736 for (t
= TREE_VALUE (attrs
); t
; t
= TREE_CHAIN (t
))
13738 if (compare_tree_int (TREE_VALUE (t
), arg_num
) == 0)
13746 /* Combine LOC and BLOCK to a combined adhoc loc, retaining any range
13750 set_block (location_t loc
, tree block
)
13752 location_t pure_loc
= get_pure_location (loc
);
13753 source_range src_range
= get_range_from_loc (line_table
, loc
);
13754 return COMBINE_LOCATION_DATA (line_table
, pure_loc
, src_range
, block
);
13758 set_source_range (tree expr
, location_t start
, location_t finish
)
13760 source_range src_range
;
13761 src_range
.m_start
= start
;
13762 src_range
.m_finish
= finish
;
13763 return set_source_range (expr
, src_range
);
13767 set_source_range (tree expr
, source_range src_range
)
13769 if (!EXPR_P (expr
))
13770 return UNKNOWN_LOCATION
;
13772 location_t pure_loc
= get_pure_location (EXPR_LOCATION (expr
));
13773 location_t adhoc
= COMBINE_LOCATION_DATA (line_table
,
13777 SET_EXPR_LOCATION (expr
, adhoc
);
13781 /* Return the name of combined function FN, for debugging purposes. */
13784 combined_fn_name (combined_fn fn
)
13786 if (builtin_fn_p (fn
))
13788 tree fndecl
= builtin_decl_explicit (as_builtin_fn (fn
));
13789 return IDENTIFIER_POINTER (DECL_NAME (fndecl
));
13792 return internal_fn_name (as_internal_fn (fn
));
13795 /* Return a bitmap with a bit set corresponding to each argument in
13796 a function call type FNTYPE declared with attribute nonnull,
13797 or null if none of the function's argument are nonnull. The caller
13798 must free the bitmap. */
13801 get_nonnull_args (const_tree fntype
)
13803 if (fntype
== NULL_TREE
)
13806 tree attrs
= TYPE_ATTRIBUTES (fntype
);
13810 bitmap argmap
= NULL
;
13812 /* A function declaration can specify multiple attribute nonnull,
13813 each with zero or more arguments. The loop below creates a bitmap
13814 representing a union of all the arguments. An empty (but non-null)
13815 bitmap means that all arguments have been declaraed nonnull. */
13816 for ( ; attrs
; attrs
= TREE_CHAIN (attrs
))
13818 attrs
= lookup_attribute ("nonnull", attrs
);
13823 argmap
= BITMAP_ALLOC (NULL
);
13825 if (!TREE_VALUE (attrs
))
13827 /* Clear the bitmap in case a previous attribute nonnull
13828 set it and this one overrides it for all arguments. */
13829 bitmap_clear (argmap
);
13833 /* Iterate over the indices of the format arguments declared nonnull
13834 and set a bit for each. */
13835 for (tree idx
= TREE_VALUE (attrs
); idx
; idx
= TREE_CHAIN (idx
))
13837 unsigned int val
= TREE_INT_CST_LOW (TREE_VALUE (idx
)) - 1;
13838 bitmap_set_bit (argmap
, val
);
13845 /* Returns true if TYPE is a type where it and all of its subobjects
13846 (recursively) are of structure, union, or array type. */
13849 default_is_empty_type (tree type
)
13851 if (RECORD_OR_UNION_TYPE_P (type
))
13853 for (tree field
= TYPE_FIELDS (type
); field
; field
= DECL_CHAIN (field
))
13854 if (TREE_CODE (field
) == FIELD_DECL
13855 && !DECL_PADDING_P (field
)
13856 && !default_is_empty_type (TREE_TYPE (field
)))
13860 else if (TREE_CODE (type
) == ARRAY_TYPE
)
13861 return (integer_minus_onep (array_type_nelts (type
))
13862 || TYPE_DOMAIN (type
) == NULL_TREE
13863 || default_is_empty_type (TREE_TYPE (type
)));
13867 /* Implement TARGET_EMPTY_RECORD_P. Return true if TYPE is an empty type
13868 that shouldn't be passed via stack. */
13871 default_is_empty_record (const_tree type
)
13873 if (!abi_version_at_least (12))
13876 if (type
== error_mark_node
)
13879 if (TREE_ADDRESSABLE (type
))
13882 return default_is_empty_type (TYPE_MAIN_VARIANT (type
));
13885 /* Like int_size_in_bytes, but handle empty records specially. */
13888 arg_int_size_in_bytes (const_tree type
)
13890 return TYPE_EMPTY_P (type
) ? 0 : int_size_in_bytes (type
);
13893 /* Like size_in_bytes, but handle empty records specially. */
13896 arg_size_in_bytes (const_tree type
)
13898 return TYPE_EMPTY_P (type
) ? size_zero_node
: size_in_bytes (type
);
13901 /* Return true if an expression with CODE has to have the same result type as
13902 its first operand. */
13905 expr_type_first_operand_type_p (tree_code code
)
13918 case TRUNC_DIV_EXPR
:
13919 case CEIL_DIV_EXPR
:
13920 case FLOOR_DIV_EXPR
:
13921 case ROUND_DIV_EXPR
:
13922 case TRUNC_MOD_EXPR
:
13923 case CEIL_MOD_EXPR
:
13924 case FLOOR_MOD_EXPR
:
13925 case ROUND_MOD_EXPR
:
13927 case EXACT_DIV_EXPR
:
13945 /* List of pointer types used to declare builtins before we have seen their
13948 Keep the size up to date in tree.h ! */
13949 const builtin_structptr_type builtin_structptr_types
[6] =
13951 { fileptr_type_node
, ptr_type_node
, "FILE" },
13952 { const_tm_ptr_type_node
, const_ptr_type_node
, "tm" },
13953 { fenv_t_ptr_type_node
, ptr_type_node
, "fenv_t" },
13954 { const_fenv_t_ptr_type_node
, const_ptr_type_node
, "fenv_t" },
13955 { fexcept_t_ptr_type_node
, ptr_type_node
, "fexcept_t" },
13956 { const_fexcept_t_ptr_type_node
, const_ptr_type_node
, "fexcept_t" }
13961 namespace selftest
{
13963 /* Selftests for tree. */
13965 /* Verify that integer constants are sane. */
13968 test_integer_constants ()
13970 ASSERT_TRUE (integer_type_node
!= NULL
);
13971 ASSERT_TRUE (build_int_cst (integer_type_node
, 0) != NULL
);
13973 tree type
= integer_type_node
;
13975 tree zero
= build_zero_cst (type
);
13976 ASSERT_EQ (INTEGER_CST
, TREE_CODE (zero
));
13977 ASSERT_EQ (type
, TREE_TYPE (zero
));
13979 tree one
= build_int_cst (type
, 1);
13980 ASSERT_EQ (INTEGER_CST
, TREE_CODE (one
));
13981 ASSERT_EQ (type
, TREE_TYPE (zero
));
13984 /* Verify identifiers. */
13987 test_identifiers ()
13989 tree identifier
= get_identifier ("foo");
13990 ASSERT_EQ (3, IDENTIFIER_LENGTH (identifier
));
13991 ASSERT_STREQ ("foo", IDENTIFIER_POINTER (identifier
));
13994 /* Verify LABEL_DECL. */
13999 tree identifier
= get_identifier ("err");
14000 tree label_decl
= build_decl (UNKNOWN_LOCATION
, LABEL_DECL
,
14001 identifier
, void_type_node
);
14002 ASSERT_EQ (-1, LABEL_DECL_UID (label_decl
));
14003 ASSERT_FALSE (FORCED_LABEL (label_decl
));
14006 /* Run all of the selftests within this file. */
14011 test_integer_constants ();
14012 test_identifiers ();
14016 } // namespace selftest
14018 #endif /* CHECKING_P */
14020 #include "gt-tree.h"