1 /* Language-independent node constructors for parse phase of GNU compiler.
2 Copyright (C) 1987-2019 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"
69 #include "tree-vector-builder.h"
71 /* Tree code classes. */
73 #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) TYPE,
74 #define END_OF_BASE_TREE_CODES tcc_exceptional,
76 const enum tree_code_class tree_code_type
[] = {
77 #include "all-tree.def"
81 #undef END_OF_BASE_TREE_CODES
83 /* Table indexed by tree code giving number of expression
84 operands beyond the fixed part of the node structure.
85 Not used for types or decls. */
87 #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) LENGTH,
88 #define END_OF_BASE_TREE_CODES 0,
90 const unsigned char tree_code_length
[] = {
91 #include "all-tree.def"
95 #undef END_OF_BASE_TREE_CODES
97 /* Names of tree components.
98 Used for printing out the tree and error messages. */
99 #define DEFTREECODE(SYM, NAME, TYPE, LEN) NAME,
100 #define END_OF_BASE_TREE_CODES "@dummy",
102 static const char *const tree_code_name
[] = {
103 #include "all-tree.def"
107 #undef END_OF_BASE_TREE_CODES
109 /* Each tree code class has an associated string representation.
110 These must correspond to the tree_code_class entries. */
112 const char *const tree_code_class_strings
[] =
127 /* obstack.[ch] explicitly declined to prototype this. */
128 extern int _obstack_allocated_p (struct obstack
*h
, void *obj
);
130 /* Statistics-gathering stuff. */
132 static uint64_t tree_code_counts
[MAX_TREE_CODES
];
133 uint64_t tree_node_counts
[(int) all_kinds
];
134 uint64_t tree_node_sizes
[(int) all_kinds
];
136 /* Keep in sync with tree.h:enum tree_node_kind. */
137 static const char * const tree_node_kind_names
[] = {
156 /* Unique id for next decl created. */
157 static GTY(()) int next_decl_uid
;
158 /* Unique id for next type created. */
159 static GTY(()) unsigned next_type_uid
= 1;
160 /* Unique id for next debug decl created. Use negative numbers,
161 to catch erroneous uses. */
162 static GTY(()) int next_debug_decl_uid
;
164 /* Since we cannot rehash a type after it is in the table, we have to
165 keep the hash code. */
167 struct GTY((for_user
)) type_hash
{
172 /* Initial size of the hash table (rounded to next prime). */
173 #define TYPE_HASH_INITIAL_SIZE 1000
175 struct type_cache_hasher
: ggc_cache_ptr_hash
<type_hash
>
177 static hashval_t
hash (type_hash
*t
) { return t
->hash
; }
178 static bool equal (type_hash
*a
, type_hash
*b
);
181 keep_cache_entry (type_hash
*&t
)
183 return ggc_marked_p (t
->type
);
187 /* Now here is the hash table. When recording a type, it is added to
188 the slot whose index is the hash code. Note that the hash table is
189 used for several kinds of types (function types, array types and
190 array index range types, for now). While all these live in the
191 same table, they are completely independent, and the hash code is
192 computed differently for each of these. */
194 static GTY ((cache
)) hash_table
<type_cache_hasher
> *type_hash_table
;
196 /* Hash table and temporary node for larger integer const values. */
197 static GTY (()) tree int_cst_node
;
199 struct int_cst_hasher
: ggc_cache_ptr_hash
<tree_node
>
201 static hashval_t
hash (tree t
);
202 static bool equal (tree x
, tree y
);
205 static GTY ((cache
)) hash_table
<int_cst_hasher
> *int_cst_hash_table
;
207 /* Class and variable for making sure that there is a single POLY_INT_CST
208 for a given value. */
209 struct poly_int_cst_hasher
: ggc_cache_ptr_hash
<tree_node
>
211 typedef std::pair
<tree
, const poly_wide_int
*> compare_type
;
212 static hashval_t
hash (tree t
);
213 static bool equal (tree x
, const compare_type
&y
);
216 static GTY ((cache
)) hash_table
<poly_int_cst_hasher
> *poly_int_cst_hash_table
;
218 /* Hash table for optimization flags and target option flags. Use the same
219 hash table for both sets of options. Nodes for building the current
220 optimization and target option nodes. The assumption is most of the time
221 the options created will already be in the hash table, so we avoid
222 allocating and freeing up a node repeatably. */
223 static GTY (()) tree cl_optimization_node
;
224 static GTY (()) tree cl_target_option_node
;
226 struct cl_option_hasher
: ggc_cache_ptr_hash
<tree_node
>
228 static hashval_t
hash (tree t
);
229 static bool equal (tree x
, tree y
);
232 static GTY ((cache
)) hash_table
<cl_option_hasher
> *cl_option_hash_table
;
234 /* General tree->tree mapping structure for use in hash tables. */
238 hash_table
<tree_decl_map_cache_hasher
> *debug_expr_for_decl
;
241 hash_table
<tree_decl_map_cache_hasher
> *value_expr_for_decl
;
243 struct tree_vec_map_cache_hasher
: ggc_cache_ptr_hash
<tree_vec_map
>
245 static hashval_t
hash (tree_vec_map
*m
) { return DECL_UID (m
->base
.from
); }
248 equal (tree_vec_map
*a
, tree_vec_map
*b
)
250 return a
->base
.from
== b
->base
.from
;
254 keep_cache_entry (tree_vec_map
*&m
)
256 return ggc_marked_p (m
->base
.from
);
261 hash_table
<tree_vec_map_cache_hasher
> *debug_args_for_decl
;
263 static void set_type_quals (tree
, int);
264 static void print_type_hash_statistics (void);
265 static void print_debug_expr_statistics (void);
266 static void print_value_expr_statistics (void);
268 static tree
build_array_type_1 (tree
, tree
, bool, bool);
270 tree global_trees
[TI_MAX
];
271 tree integer_types
[itk_none
];
273 bool int_n_enabled_p
[NUM_INT_N_ENTS
];
274 struct int_n_trees_t int_n_trees
[NUM_INT_N_ENTS
];
276 bool tree_contains_struct
[MAX_TREE_CODES
][64];
278 /* Number of operands for each OpenMP clause. */
279 unsigned const char omp_clause_num_ops
[] =
281 0, /* OMP_CLAUSE_ERROR */
282 1, /* OMP_CLAUSE_PRIVATE */
283 1, /* OMP_CLAUSE_SHARED */
284 1, /* OMP_CLAUSE_FIRSTPRIVATE */
285 2, /* OMP_CLAUSE_LASTPRIVATE */
286 5, /* OMP_CLAUSE_REDUCTION */
287 5, /* OMP_CLAUSE_TASK_REDUCTION */
288 5, /* OMP_CLAUSE_IN_REDUCTION */
289 1, /* OMP_CLAUSE_COPYIN */
290 1, /* OMP_CLAUSE_COPYPRIVATE */
291 3, /* OMP_CLAUSE_LINEAR */
292 2, /* OMP_CLAUSE_ALIGNED */
293 1, /* OMP_CLAUSE_DEPEND */
294 1, /* OMP_CLAUSE_NONTEMPORAL */
295 1, /* OMP_CLAUSE_UNIFORM */
296 1, /* OMP_CLAUSE_TO_DECLARE */
297 1, /* OMP_CLAUSE_LINK */
298 2, /* OMP_CLAUSE_FROM */
299 2, /* OMP_CLAUSE_TO */
300 2, /* OMP_CLAUSE_MAP */
301 1, /* OMP_CLAUSE_USE_DEVICE_PTR */
302 1, /* OMP_CLAUSE_IS_DEVICE_PTR */
303 1, /* OMP_CLAUSE_INCLUSIVE */
304 1, /* OMP_CLAUSE_EXCLUSIVE */
305 2, /* OMP_CLAUSE__CACHE_ */
306 2, /* OMP_CLAUSE_GANG */
307 1, /* OMP_CLAUSE_ASYNC */
308 1, /* OMP_CLAUSE_WAIT */
309 0, /* OMP_CLAUSE_AUTO */
310 0, /* OMP_CLAUSE_SEQ */
311 1, /* OMP_CLAUSE__LOOPTEMP_ */
312 1, /* OMP_CLAUSE__REDUCTEMP_ */
313 1, /* OMP_CLAUSE__CONDTEMP_ */
314 1, /* OMP_CLAUSE_IF */
315 1, /* OMP_CLAUSE_NUM_THREADS */
316 1, /* OMP_CLAUSE_SCHEDULE */
317 0, /* OMP_CLAUSE_NOWAIT */
318 1, /* OMP_CLAUSE_ORDERED */
319 0, /* OMP_CLAUSE_DEFAULT */
320 3, /* OMP_CLAUSE_COLLAPSE */
321 0, /* OMP_CLAUSE_UNTIED */
322 1, /* OMP_CLAUSE_FINAL */
323 0, /* OMP_CLAUSE_MERGEABLE */
324 1, /* OMP_CLAUSE_DEVICE */
325 1, /* OMP_CLAUSE_DIST_SCHEDULE */
326 0, /* OMP_CLAUSE_INBRANCH */
327 0, /* OMP_CLAUSE_NOTINBRANCH */
328 1, /* OMP_CLAUSE_NUM_TEAMS */
329 1, /* OMP_CLAUSE_THREAD_LIMIT */
330 0, /* OMP_CLAUSE_PROC_BIND */
331 1, /* OMP_CLAUSE_SAFELEN */
332 1, /* OMP_CLAUSE_SIMDLEN */
333 0, /* OMP_CLAUSE_FOR */
334 0, /* OMP_CLAUSE_PARALLEL */
335 0, /* OMP_CLAUSE_SECTIONS */
336 0, /* OMP_CLAUSE_TASKGROUP */
337 1, /* OMP_CLAUSE_PRIORITY */
338 1, /* OMP_CLAUSE_GRAINSIZE */
339 1, /* OMP_CLAUSE_NUM_TASKS */
340 0, /* OMP_CLAUSE_NOGROUP */
341 0, /* OMP_CLAUSE_THREADS */
342 0, /* OMP_CLAUSE_SIMD */
343 1, /* OMP_CLAUSE_HINT */
344 0, /* OMP_CLAUSE_DEFALTMAP */
345 1, /* OMP_CLAUSE__SIMDUID_ */
346 0, /* OMP_CLAUSE__SIMT_ */
347 0, /* OMP_CLAUSE_INDEPENDENT */
348 1, /* OMP_CLAUSE_WORKER */
349 1, /* OMP_CLAUSE_VECTOR */
350 1, /* OMP_CLAUSE_NUM_GANGS */
351 1, /* OMP_CLAUSE_NUM_WORKERS */
352 1, /* OMP_CLAUSE_VECTOR_LENGTH */
353 3, /* OMP_CLAUSE_TILE */
354 2, /* OMP_CLAUSE__GRIDDIM_ */
355 0, /* OMP_CLAUSE_IF_PRESENT */
356 0, /* OMP_CLAUSE_FINALIZE */
359 const char * const omp_clause_code_name
[] =
440 /* Return the tree node structure used by tree code CODE. */
442 static inline enum tree_node_structure_enum
443 tree_node_structure_for_code (enum tree_code code
)
445 switch (TREE_CODE_CLASS (code
))
447 case tcc_declaration
:
452 return TS_FIELD_DECL
;
458 return TS_LABEL_DECL
;
460 return TS_RESULT_DECL
;
461 case DEBUG_EXPR_DECL
:
464 return TS_CONST_DECL
;
468 return TS_FUNCTION_DECL
;
469 case TRANSLATION_UNIT_DECL
:
470 return TS_TRANSLATION_UNIT_DECL
;
472 return TS_DECL_NON_COMMON
;
476 return TS_TYPE_NON_COMMON
;
485 default: /* tcc_constant and tcc_exceptional */
490 /* tcc_constant cases. */
491 case VOID_CST
: return TS_TYPED
;
492 case INTEGER_CST
: return TS_INT_CST
;
493 case POLY_INT_CST
: return TS_POLY_INT_CST
;
494 case REAL_CST
: return TS_REAL_CST
;
495 case FIXED_CST
: return TS_FIXED_CST
;
496 case COMPLEX_CST
: return TS_COMPLEX
;
497 case VECTOR_CST
: return TS_VECTOR
;
498 case STRING_CST
: return TS_STRING
;
499 /* tcc_exceptional cases. */
500 case ERROR_MARK
: return TS_COMMON
;
501 case IDENTIFIER_NODE
: return TS_IDENTIFIER
;
502 case TREE_LIST
: return TS_LIST
;
503 case TREE_VEC
: return TS_VEC
;
504 case SSA_NAME
: return TS_SSA_NAME
;
505 case PLACEHOLDER_EXPR
: return TS_COMMON
;
506 case STATEMENT_LIST
: return TS_STATEMENT_LIST
;
507 case BLOCK
: return TS_BLOCK
;
508 case CONSTRUCTOR
: return TS_CONSTRUCTOR
;
509 case TREE_BINFO
: return TS_BINFO
;
510 case OMP_CLAUSE
: return TS_OMP_CLAUSE
;
511 case OPTIMIZATION_NODE
: return TS_OPTIMIZATION
;
512 case TARGET_OPTION_NODE
: return TS_TARGET_OPTION
;
520 /* Initialize tree_contains_struct to describe the hierarchy of tree
524 initialize_tree_contains_struct (void)
528 for (i
= ERROR_MARK
; i
< LAST_AND_UNUSED_TREE_CODE
; i
++)
531 enum tree_node_structure_enum ts_code
;
533 code
= (enum tree_code
) i
;
534 ts_code
= tree_node_structure_for_code (code
);
536 /* Mark the TS structure itself. */
537 tree_contains_struct
[code
][ts_code
] = 1;
539 /* Mark all the structures that TS is derived from. */
544 case TS_OPTIMIZATION
:
545 case TS_TARGET_OPTION
:
551 case TS_POLY_INT_CST
:
560 case TS_STATEMENT_LIST
:
561 MARK_TS_TYPED (code
);
565 case TS_DECL_MINIMAL
:
571 MARK_TS_COMMON (code
);
574 case TS_TYPE_WITH_LANG_SPECIFIC
:
575 MARK_TS_TYPE_COMMON (code
);
578 case TS_TYPE_NON_COMMON
:
579 MARK_TS_TYPE_WITH_LANG_SPECIFIC (code
);
583 MARK_TS_DECL_MINIMAL (code
);
588 MARK_TS_DECL_COMMON (code
);
591 case TS_DECL_NON_COMMON
:
592 MARK_TS_DECL_WITH_VIS (code
);
595 case TS_DECL_WITH_VIS
:
599 MARK_TS_DECL_WRTL (code
);
603 MARK_TS_DECL_COMMON (code
);
607 MARK_TS_DECL_WITH_VIS (code
);
611 case TS_FUNCTION_DECL
:
612 MARK_TS_DECL_NON_COMMON (code
);
615 case TS_TRANSLATION_UNIT_DECL
:
616 MARK_TS_DECL_COMMON (code
);
624 /* Basic consistency checks for attributes used in fold. */
625 gcc_assert (tree_contains_struct
[FUNCTION_DECL
][TS_DECL_NON_COMMON
]);
626 gcc_assert (tree_contains_struct
[TYPE_DECL
][TS_DECL_NON_COMMON
]);
627 gcc_assert (tree_contains_struct
[CONST_DECL
][TS_DECL_COMMON
]);
628 gcc_assert (tree_contains_struct
[VAR_DECL
][TS_DECL_COMMON
]);
629 gcc_assert (tree_contains_struct
[PARM_DECL
][TS_DECL_COMMON
]);
630 gcc_assert (tree_contains_struct
[RESULT_DECL
][TS_DECL_COMMON
]);
631 gcc_assert (tree_contains_struct
[FUNCTION_DECL
][TS_DECL_COMMON
]);
632 gcc_assert (tree_contains_struct
[TYPE_DECL
][TS_DECL_COMMON
]);
633 gcc_assert (tree_contains_struct
[TRANSLATION_UNIT_DECL
][TS_DECL_COMMON
]);
634 gcc_assert (tree_contains_struct
[LABEL_DECL
][TS_DECL_COMMON
]);
635 gcc_assert (tree_contains_struct
[FIELD_DECL
][TS_DECL_COMMON
]);
636 gcc_assert (tree_contains_struct
[VAR_DECL
][TS_DECL_WRTL
]);
637 gcc_assert (tree_contains_struct
[PARM_DECL
][TS_DECL_WRTL
]);
638 gcc_assert (tree_contains_struct
[RESULT_DECL
][TS_DECL_WRTL
]);
639 gcc_assert (tree_contains_struct
[FUNCTION_DECL
][TS_DECL_WRTL
]);
640 gcc_assert (tree_contains_struct
[LABEL_DECL
][TS_DECL_WRTL
]);
641 gcc_assert (tree_contains_struct
[CONST_DECL
][TS_DECL_MINIMAL
]);
642 gcc_assert (tree_contains_struct
[VAR_DECL
][TS_DECL_MINIMAL
]);
643 gcc_assert (tree_contains_struct
[PARM_DECL
][TS_DECL_MINIMAL
]);
644 gcc_assert (tree_contains_struct
[RESULT_DECL
][TS_DECL_MINIMAL
]);
645 gcc_assert (tree_contains_struct
[FUNCTION_DECL
][TS_DECL_MINIMAL
]);
646 gcc_assert (tree_contains_struct
[TYPE_DECL
][TS_DECL_MINIMAL
]);
647 gcc_assert (tree_contains_struct
[TRANSLATION_UNIT_DECL
][TS_DECL_MINIMAL
]);
648 gcc_assert (tree_contains_struct
[LABEL_DECL
][TS_DECL_MINIMAL
]);
649 gcc_assert (tree_contains_struct
[FIELD_DECL
][TS_DECL_MINIMAL
]);
650 gcc_assert (tree_contains_struct
[VAR_DECL
][TS_DECL_WITH_VIS
]);
651 gcc_assert (tree_contains_struct
[FUNCTION_DECL
][TS_DECL_WITH_VIS
]);
652 gcc_assert (tree_contains_struct
[TYPE_DECL
][TS_DECL_WITH_VIS
]);
653 gcc_assert (tree_contains_struct
[VAR_DECL
][TS_VAR_DECL
]);
654 gcc_assert (tree_contains_struct
[FIELD_DECL
][TS_FIELD_DECL
]);
655 gcc_assert (tree_contains_struct
[PARM_DECL
][TS_PARM_DECL
]);
656 gcc_assert (tree_contains_struct
[LABEL_DECL
][TS_LABEL_DECL
]);
657 gcc_assert (tree_contains_struct
[RESULT_DECL
][TS_RESULT_DECL
]);
658 gcc_assert (tree_contains_struct
[CONST_DECL
][TS_CONST_DECL
]);
659 gcc_assert (tree_contains_struct
[TYPE_DECL
][TS_TYPE_DECL
]);
660 gcc_assert (tree_contains_struct
[FUNCTION_DECL
][TS_FUNCTION_DECL
]);
661 gcc_assert (tree_contains_struct
[IMPORTED_DECL
][TS_DECL_MINIMAL
]);
662 gcc_assert (tree_contains_struct
[IMPORTED_DECL
][TS_DECL_COMMON
]);
663 gcc_assert (tree_contains_struct
[NAMELIST_DECL
][TS_DECL_MINIMAL
]);
664 gcc_assert (tree_contains_struct
[NAMELIST_DECL
][TS_DECL_COMMON
]);
673 /* Initialize the hash table of types. */
675 = hash_table
<type_cache_hasher
>::create_ggc (TYPE_HASH_INITIAL_SIZE
);
678 = hash_table
<tree_decl_map_cache_hasher
>::create_ggc (512);
681 = hash_table
<tree_decl_map_cache_hasher
>::create_ggc (512);
683 int_cst_hash_table
= hash_table
<int_cst_hasher
>::create_ggc (1024);
685 poly_int_cst_hash_table
= hash_table
<poly_int_cst_hasher
>::create_ggc (64);
687 int_cst_node
= make_int_cst (1, 1);
689 cl_option_hash_table
= hash_table
<cl_option_hasher
>::create_ggc (64);
691 cl_optimization_node
= make_node (OPTIMIZATION_NODE
);
692 cl_target_option_node
= make_node (TARGET_OPTION_NODE
);
694 /* Initialize the tree_contains_struct array. */
695 initialize_tree_contains_struct ();
696 lang_hooks
.init_ts ();
700 /* The name of the object as the assembler will see it (but before any
701 translations made by ASM_OUTPUT_LABELREF). Often this is the same
702 as DECL_NAME. It is an IDENTIFIER_NODE. */
704 decl_assembler_name (tree decl
)
706 if (!DECL_ASSEMBLER_NAME_SET_P (decl
))
707 lang_hooks
.set_decl_assembler_name (decl
);
708 return DECL_ASSEMBLER_NAME_RAW (decl
);
711 /* The DECL_ASSEMBLER_NAME_RAW of DECL is being explicitly set to NAME
712 (either of which may be NULL). Inform the FE, if this changes the
716 overwrite_decl_assembler_name (tree decl
, tree name
)
718 if (DECL_ASSEMBLER_NAME_RAW (decl
) != name
)
719 lang_hooks
.overwrite_decl_assembler_name (decl
, name
);
722 /* When the target supports COMDAT groups, this indicates which group the
723 DECL is associated with. This can be either an IDENTIFIER_NODE or a
724 decl, in which case its DECL_ASSEMBLER_NAME identifies the group. */
726 decl_comdat_group (const_tree node
)
728 struct symtab_node
*snode
= symtab_node::get (node
);
731 return snode
->get_comdat_group ();
734 /* Likewise, but make sure it's been reduced to an IDENTIFIER_NODE. */
736 decl_comdat_group_id (const_tree node
)
738 struct symtab_node
*snode
= symtab_node::get (node
);
741 return snode
->get_comdat_group_id ();
744 /* When the target supports named section, return its name as IDENTIFIER_NODE
745 or NULL if it is in no section. */
747 decl_section_name (const_tree node
)
749 struct symtab_node
*snode
= symtab_node::get (node
);
752 return snode
->get_section ();
755 /* Set section name of NODE to VALUE (that is expected to be
758 set_decl_section_name (tree node
, const char *value
)
760 struct symtab_node
*snode
;
764 snode
= symtab_node::get (node
);
768 else if (VAR_P (node
))
769 snode
= varpool_node::get_create (node
);
771 snode
= cgraph_node::get_create (node
);
772 snode
->set_section (value
);
775 /* Return TLS model of a variable NODE. */
777 decl_tls_model (const_tree node
)
779 struct varpool_node
*snode
= varpool_node::get (node
);
781 return TLS_MODEL_NONE
;
782 return snode
->tls_model
;
785 /* Set TLS model of variable NODE to MODEL. */
787 set_decl_tls_model (tree node
, enum tls_model model
)
789 struct varpool_node
*vnode
;
791 if (model
== TLS_MODEL_NONE
)
793 vnode
= varpool_node::get (node
);
798 vnode
= varpool_node::get_create (node
);
799 vnode
->tls_model
= model
;
802 /* Compute the number of bytes occupied by a tree with code CODE.
803 This function cannot be used for nodes that have variable sizes,
804 including TREE_VEC, INTEGER_CST, STRING_CST, and CALL_EXPR. */
806 tree_code_size (enum tree_code code
)
808 switch (TREE_CODE_CLASS (code
))
810 case tcc_declaration
: /* A decl node */
813 case FIELD_DECL
: return sizeof (tree_field_decl
);
814 case PARM_DECL
: return sizeof (tree_parm_decl
);
815 case VAR_DECL
: return sizeof (tree_var_decl
);
816 case LABEL_DECL
: return sizeof (tree_label_decl
);
817 case RESULT_DECL
: return sizeof (tree_result_decl
);
818 case CONST_DECL
: return sizeof (tree_const_decl
);
819 case TYPE_DECL
: return sizeof (tree_type_decl
);
820 case FUNCTION_DECL
: return sizeof (tree_function_decl
);
821 case DEBUG_EXPR_DECL
: return sizeof (tree_decl_with_rtl
);
822 case TRANSLATION_UNIT_DECL
: return sizeof (tree_translation_unit_decl
);
825 case NAMELIST_DECL
: return sizeof (tree_decl_non_common
);
827 gcc_checking_assert (code
>= NUM_TREE_CODES
);
828 return lang_hooks
.tree_size (code
);
831 case tcc_type
: /* a type node */
842 case FIXED_POINT_TYPE
:
848 case QUAL_UNION_TYPE
:
852 case LANG_TYPE
: return sizeof (tree_type_non_common
);
854 gcc_checking_assert (code
>= NUM_TREE_CODES
);
855 return lang_hooks
.tree_size (code
);
858 case tcc_reference
: /* a reference */
859 case tcc_expression
: /* an expression */
860 case tcc_statement
: /* an expression with side effects */
861 case tcc_comparison
: /* a comparison expression */
862 case tcc_unary
: /* a unary arithmetic expression */
863 case tcc_binary
: /* a binary arithmetic expression */
864 return (sizeof (struct tree_exp
)
865 + (TREE_CODE_LENGTH (code
) - 1) * sizeof (tree
));
867 case tcc_constant
: /* a constant */
870 case VOID_CST
: return sizeof (tree_typed
);
871 case INTEGER_CST
: gcc_unreachable ();
872 case POLY_INT_CST
: return sizeof (tree_poly_int_cst
);
873 case REAL_CST
: return sizeof (tree_real_cst
);
874 case FIXED_CST
: return sizeof (tree_fixed_cst
);
875 case COMPLEX_CST
: return sizeof (tree_complex
);
876 case VECTOR_CST
: gcc_unreachable ();
877 case STRING_CST
: gcc_unreachable ();
879 gcc_checking_assert (code
>= NUM_TREE_CODES
);
880 return lang_hooks
.tree_size (code
);
883 case tcc_exceptional
: /* something random, like an identifier. */
886 case IDENTIFIER_NODE
: return lang_hooks
.identifier_size
;
887 case TREE_LIST
: return sizeof (tree_list
);
890 case PLACEHOLDER_EXPR
: return sizeof (tree_common
);
892 case TREE_VEC
: gcc_unreachable ();
893 case OMP_CLAUSE
: gcc_unreachable ();
895 case SSA_NAME
: return sizeof (tree_ssa_name
);
897 case STATEMENT_LIST
: return sizeof (tree_statement_list
);
898 case BLOCK
: return sizeof (struct tree_block
);
899 case CONSTRUCTOR
: return sizeof (tree_constructor
);
900 case OPTIMIZATION_NODE
: return sizeof (tree_optimization_option
);
901 case TARGET_OPTION_NODE
: return sizeof (tree_target_option
);
904 gcc_checking_assert (code
>= NUM_TREE_CODES
);
905 return lang_hooks
.tree_size (code
);
913 /* Compute the number of bytes occupied by NODE. This routine only
914 looks at TREE_CODE, except for those nodes that have variable sizes. */
916 tree_size (const_tree node
)
918 const enum tree_code code
= TREE_CODE (node
);
922 return (sizeof (struct tree_int_cst
)
923 + (TREE_INT_CST_EXT_NUNITS (node
) - 1) * sizeof (HOST_WIDE_INT
));
926 return (offsetof (struct tree_binfo
, base_binfos
)
928 ::embedded_size (BINFO_N_BASE_BINFOS (node
)));
931 return (sizeof (struct tree_vec
)
932 + (TREE_VEC_LENGTH (node
) - 1) * sizeof (tree
));
935 return (sizeof (struct tree_vector
)
936 + (vector_cst_encoded_nelts (node
) - 1) * sizeof (tree
));
939 return TREE_STRING_LENGTH (node
) + offsetof (struct tree_string
, str
) + 1;
942 return (sizeof (struct tree_omp_clause
)
943 + (omp_clause_num_ops
[OMP_CLAUSE_CODE (node
)] - 1)
947 if (TREE_CODE_CLASS (code
) == tcc_vl_exp
)
948 return (sizeof (struct tree_exp
)
949 + (VL_EXP_OPERAND_LENGTH (node
) - 1) * sizeof (tree
));
951 return tree_code_size (code
);
955 /* Return tree node kind based on tree CODE. */
957 static tree_node_kind
958 get_stats_node_kind (enum tree_code code
)
960 enum tree_code_class type
= TREE_CODE_CLASS (code
);
964 case tcc_declaration
: /* A decl node */
966 case tcc_type
: /* a type node */
968 case tcc_statement
: /* an expression with side effects */
970 case tcc_reference
: /* a reference */
972 case tcc_expression
: /* an expression */
973 case tcc_comparison
: /* a comparison expression */
974 case tcc_unary
: /* a unary arithmetic expression */
975 case tcc_binary
: /* a binary arithmetic expression */
977 case tcc_constant
: /* a constant */
979 case tcc_exceptional
: /* something random, like an identifier. */
982 case IDENTIFIER_NODE
:
989 return ssa_name_kind
;
995 return omp_clause_kind
;
1007 /* Record interesting allocation statistics for a tree node with CODE
1011 record_node_allocation_statistics (enum tree_code code
, size_t length
)
1013 if (!GATHER_STATISTICS
)
1016 tree_node_kind kind
= get_stats_node_kind (code
);
1018 tree_code_counts
[(int) code
]++;
1019 tree_node_counts
[(int) kind
]++;
1020 tree_node_sizes
[(int) kind
] += length
;
1023 /* Allocate and return a new UID from the DECL_UID namespace. */
1026 allocate_decl_uid (void)
1028 return next_decl_uid
++;
1031 /* Return a newly allocated node of code CODE. For decl and type
1032 nodes, some other fields are initialized. The rest of the node is
1033 initialized to zero. This function cannot be used for TREE_VEC,
1034 INTEGER_CST or OMP_CLAUSE nodes, which is enforced by asserts in
1037 Achoo! I got a code in the node. */
1040 make_node (enum tree_code code MEM_STAT_DECL
)
1043 enum tree_code_class type
= TREE_CODE_CLASS (code
);
1044 size_t length
= tree_code_size (code
);
1046 record_node_allocation_statistics (code
, length
);
1048 t
= ggc_alloc_cleared_tree_node_stat (length PASS_MEM_STAT
);
1049 TREE_SET_CODE (t
, code
);
1054 if (code
!= DEBUG_BEGIN_STMT
)
1055 TREE_SIDE_EFFECTS (t
) = 1;
1058 case tcc_declaration
:
1059 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_COMMON
))
1061 if (code
== FUNCTION_DECL
)
1063 SET_DECL_ALIGN (t
, FUNCTION_ALIGNMENT (FUNCTION_BOUNDARY
));
1064 SET_DECL_MODE (t
, FUNCTION_MODE
);
1067 SET_DECL_ALIGN (t
, 1);
1069 DECL_SOURCE_LOCATION (t
) = input_location
;
1070 if (TREE_CODE (t
) == DEBUG_EXPR_DECL
)
1071 DECL_UID (t
) = --next_debug_decl_uid
;
1074 DECL_UID (t
) = allocate_decl_uid ();
1075 SET_DECL_PT_UID (t
, -1);
1077 if (TREE_CODE (t
) == LABEL_DECL
)
1078 LABEL_DECL_UID (t
) = -1;
1083 TYPE_UID (t
) = next_type_uid
++;
1084 SET_TYPE_ALIGN (t
, BITS_PER_UNIT
);
1085 TYPE_USER_ALIGN (t
) = 0;
1086 TYPE_MAIN_VARIANT (t
) = t
;
1087 TYPE_CANONICAL (t
) = t
;
1089 /* Default to no attributes for type, but let target change that. */
1090 TYPE_ATTRIBUTES (t
) = NULL_TREE
;
1091 targetm
.set_default_type_attributes (t
);
1093 /* We have not yet computed the alias set for this type. */
1094 TYPE_ALIAS_SET (t
) = -1;
1098 TREE_CONSTANT (t
) = 1;
1101 case tcc_expression
:
1107 case PREDECREMENT_EXPR
:
1108 case PREINCREMENT_EXPR
:
1109 case POSTDECREMENT_EXPR
:
1110 case POSTINCREMENT_EXPR
:
1111 /* All of these have side-effects, no matter what their
1113 TREE_SIDE_EFFECTS (t
) = 1;
1121 case tcc_exceptional
:
1124 case TARGET_OPTION_NODE
:
1125 TREE_TARGET_OPTION(t
)
1126 = ggc_cleared_alloc
<struct cl_target_option
> ();
1129 case OPTIMIZATION_NODE
:
1130 TREE_OPTIMIZATION (t
)
1131 = ggc_cleared_alloc
<struct cl_optimization
> ();
1140 /* Other classes need no special treatment. */
1147 /* Free tree node. */
1150 free_node (tree node
)
1152 enum tree_code code
= TREE_CODE (node
);
1153 if (GATHER_STATISTICS
)
1155 enum tree_node_kind kind
= get_stats_node_kind (code
);
1157 gcc_checking_assert (tree_code_counts
[(int) TREE_CODE (node
)] != 0);
1158 gcc_checking_assert (tree_node_counts
[(int) kind
] != 0);
1159 gcc_checking_assert (tree_node_sizes
[(int) kind
] >= tree_size (node
));
1161 tree_code_counts
[(int) TREE_CODE (node
)]--;
1162 tree_node_counts
[(int) kind
]--;
1163 tree_node_sizes
[(int) kind
] -= tree_size (node
);
1165 if (CODE_CONTAINS_STRUCT (code
, TS_CONSTRUCTOR
))
1166 vec_free (CONSTRUCTOR_ELTS (node
));
1167 else if (code
== BLOCK
)
1168 vec_free (BLOCK_NONLOCALIZED_VARS (node
));
1169 else if (code
== TREE_BINFO
)
1170 vec_free (BINFO_BASE_ACCESSES (node
));
1174 /* Return a new node with the same contents as NODE except that its
1175 TREE_CHAIN, if it has one, is zero and it has a fresh uid. */
1178 copy_node (tree node MEM_STAT_DECL
)
1181 enum tree_code code
= TREE_CODE (node
);
1184 gcc_assert (code
!= STATEMENT_LIST
);
1186 length
= tree_size (node
);
1187 record_node_allocation_statistics (code
, length
);
1188 t
= ggc_alloc_tree_node_stat (length PASS_MEM_STAT
);
1189 memcpy (t
, node
, length
);
1191 if (CODE_CONTAINS_STRUCT (code
, TS_COMMON
))
1193 TREE_ASM_WRITTEN (t
) = 0;
1194 TREE_VISITED (t
) = 0;
1196 if (TREE_CODE_CLASS (code
) == tcc_declaration
)
1198 if (code
== DEBUG_EXPR_DECL
)
1199 DECL_UID (t
) = --next_debug_decl_uid
;
1202 DECL_UID (t
) = allocate_decl_uid ();
1203 if (DECL_PT_UID_SET_P (node
))
1204 SET_DECL_PT_UID (t
, DECL_PT_UID (node
));
1206 if ((TREE_CODE (node
) == PARM_DECL
|| VAR_P (node
))
1207 && DECL_HAS_VALUE_EXPR_P (node
))
1209 SET_DECL_VALUE_EXPR (t
, DECL_VALUE_EXPR (node
));
1210 DECL_HAS_VALUE_EXPR_P (t
) = 1;
1212 /* DECL_DEBUG_EXPR is copied explicitely by callers. */
1215 DECL_HAS_DEBUG_EXPR_P (t
) = 0;
1216 t
->decl_with_vis
.symtab_node
= NULL
;
1218 if (VAR_P (node
) && DECL_HAS_INIT_PRIORITY_P (node
))
1220 SET_DECL_INIT_PRIORITY (t
, DECL_INIT_PRIORITY (node
));
1221 DECL_HAS_INIT_PRIORITY_P (t
) = 1;
1223 if (TREE_CODE (node
) == FUNCTION_DECL
)
1225 DECL_STRUCT_FUNCTION (t
) = NULL
;
1226 t
->decl_with_vis
.symtab_node
= NULL
;
1229 else if (TREE_CODE_CLASS (code
) == tcc_type
)
1231 TYPE_UID (t
) = next_type_uid
++;
1232 /* The following is so that the debug code for
1233 the copy is different from the original type.
1234 The two statements usually duplicate each other
1235 (because they clear fields of the same union),
1236 but the optimizer should catch that. */
1237 TYPE_SYMTAB_ADDRESS (t
) = 0;
1238 TYPE_SYMTAB_DIE (t
) = 0;
1240 /* Do not copy the values cache. */
1241 if (TYPE_CACHED_VALUES_P (t
))
1243 TYPE_CACHED_VALUES_P (t
) = 0;
1244 TYPE_CACHED_VALUES (t
) = NULL_TREE
;
1247 else if (code
== TARGET_OPTION_NODE
)
1249 TREE_TARGET_OPTION (t
) = ggc_alloc
<struct cl_target_option
>();
1250 memcpy (TREE_TARGET_OPTION (t
), TREE_TARGET_OPTION (node
),
1251 sizeof (struct cl_target_option
));
1253 else if (code
== OPTIMIZATION_NODE
)
1255 TREE_OPTIMIZATION (t
) = ggc_alloc
<struct cl_optimization
>();
1256 memcpy (TREE_OPTIMIZATION (t
), TREE_OPTIMIZATION (node
),
1257 sizeof (struct cl_optimization
));
1263 /* Return a copy of a chain of nodes, chained through the TREE_CHAIN field.
1264 For example, this can copy a list made of TREE_LIST nodes. */
1267 copy_list (tree list
)
1275 head
= prev
= copy_node (list
);
1276 next
= TREE_CHAIN (list
);
1279 TREE_CHAIN (prev
) = copy_node (next
);
1280 prev
= TREE_CHAIN (prev
);
1281 next
= TREE_CHAIN (next
);
1287 /* Return the value that TREE_INT_CST_EXT_NUNITS should have for an
1288 INTEGER_CST with value CST and type TYPE. */
1291 get_int_cst_ext_nunits (tree type
, const wide_int
&cst
)
1293 gcc_checking_assert (cst
.get_precision () == TYPE_PRECISION (type
));
1294 /* We need extra HWIs if CST is an unsigned integer with its
1296 if (TYPE_UNSIGNED (type
) && wi::neg_p (cst
))
1297 return cst
.get_precision () / HOST_BITS_PER_WIDE_INT
+ 1;
1298 return cst
.get_len ();
1301 /* Return a new INTEGER_CST with value CST and type TYPE. */
1304 build_new_int_cst (tree type
, const wide_int
&cst
)
1306 unsigned int len
= cst
.get_len ();
1307 unsigned int ext_len
= get_int_cst_ext_nunits (type
, cst
);
1308 tree nt
= make_int_cst (len
, ext_len
);
1313 TREE_INT_CST_ELT (nt
, ext_len
)
1314 = zext_hwi (-1, cst
.get_precision () % HOST_BITS_PER_WIDE_INT
);
1315 for (unsigned int i
= len
; i
< ext_len
; ++i
)
1316 TREE_INT_CST_ELT (nt
, i
) = -1;
1318 else if (TYPE_UNSIGNED (type
)
1319 && cst
.get_precision () < len
* HOST_BITS_PER_WIDE_INT
)
1322 TREE_INT_CST_ELT (nt
, len
)
1323 = zext_hwi (cst
.elt (len
),
1324 cst
.get_precision () % HOST_BITS_PER_WIDE_INT
);
1327 for (unsigned int i
= 0; i
< len
; i
++)
1328 TREE_INT_CST_ELT (nt
, i
) = cst
.elt (i
);
1329 TREE_TYPE (nt
) = type
;
1333 /* Return a new POLY_INT_CST with coefficients COEFFS and type TYPE. */
1336 build_new_poly_int_cst (tree type
, tree (&coeffs
)[NUM_POLY_INT_COEFFS
]
1339 size_t length
= sizeof (struct tree_poly_int_cst
);
1340 record_node_allocation_statistics (POLY_INT_CST
, length
);
1342 tree t
= ggc_alloc_cleared_tree_node_stat (length PASS_MEM_STAT
);
1344 TREE_SET_CODE (t
, POLY_INT_CST
);
1345 TREE_CONSTANT (t
) = 1;
1346 TREE_TYPE (t
) = type
;
1347 for (unsigned int i
= 0; i
< NUM_POLY_INT_COEFFS
; ++i
)
1348 POLY_INT_CST_COEFF (t
, i
) = coeffs
[i
];
1352 /* Create a constant tree that contains CST sign-extended to TYPE. */
1355 build_int_cst (tree type
, poly_int64 cst
)
1357 /* Support legacy code. */
1359 type
= integer_type_node
;
1361 return wide_int_to_tree (type
, wi::shwi (cst
, TYPE_PRECISION (type
)));
1364 /* Create a constant tree that contains CST zero-extended to TYPE. */
1367 build_int_cstu (tree type
, poly_uint64 cst
)
1369 return wide_int_to_tree (type
, wi::uhwi (cst
, TYPE_PRECISION (type
)));
1372 /* Create a constant tree that contains CST sign-extended to TYPE. */
1375 build_int_cst_type (tree type
, poly_int64 cst
)
1378 return wide_int_to_tree (type
, wi::shwi (cst
, TYPE_PRECISION (type
)));
1381 /* Constructs tree in type TYPE from with value given by CST. Signedness
1382 of CST is assumed to be the same as the signedness of TYPE. */
1385 double_int_to_tree (tree type
, double_int cst
)
1387 return wide_int_to_tree (type
, widest_int::from (cst
, TYPE_SIGN (type
)));
1390 /* We force the wide_int CST to the range of the type TYPE by sign or
1391 zero extending it. OVERFLOWABLE indicates if we are interested in
1392 overflow of the value, when >0 we are only interested in signed
1393 overflow, for <0 we are interested in any overflow. OVERFLOWED
1394 indicates whether overflow has already occurred. CONST_OVERFLOWED
1395 indicates whether constant overflow has already occurred. We force
1396 T's value to be within range of T's type (by setting to 0 or 1 all
1397 the bits outside the type's range). We set TREE_OVERFLOWED if,
1398 OVERFLOWED is nonzero,
1399 or OVERFLOWABLE is >0 and signed overflow occurs
1400 or OVERFLOWABLE is <0 and any overflow occurs
1401 We return a new tree node for the extended wide_int. The node
1402 is shared if no overflow flags are set. */
1406 force_fit_type (tree type
, const poly_wide_int_ref
&cst
,
1407 int overflowable
, bool overflowed
)
1409 signop sign
= TYPE_SIGN (type
);
1411 /* If we need to set overflow flags, return a new unshared node. */
1412 if (overflowed
|| !wi::fits_to_tree_p (cst
, type
))
1416 || (overflowable
> 0 && sign
== SIGNED
))
1418 poly_wide_int tmp
= poly_wide_int::from (cst
, TYPE_PRECISION (type
),
1421 if (tmp
.is_constant ())
1422 t
= build_new_int_cst (type
, tmp
.coeffs
[0]);
1425 tree coeffs
[NUM_POLY_INT_COEFFS
];
1426 for (unsigned int i
= 0; i
< NUM_POLY_INT_COEFFS
; ++i
)
1428 coeffs
[i
] = build_new_int_cst (type
, tmp
.coeffs
[i
]);
1429 TREE_OVERFLOW (coeffs
[i
]) = 1;
1431 t
= build_new_poly_int_cst (type
, coeffs
);
1433 TREE_OVERFLOW (t
) = 1;
1438 /* Else build a shared node. */
1439 return wide_int_to_tree (type
, cst
);
1442 /* These are the hash table functions for the hash table of INTEGER_CST
1443 nodes of a sizetype. */
1445 /* Return the hash code X, an INTEGER_CST. */
1448 int_cst_hasher::hash (tree x
)
1450 const_tree
const t
= x
;
1451 hashval_t code
= TYPE_UID (TREE_TYPE (t
));
1454 for (i
= 0; i
< TREE_INT_CST_NUNITS (t
); i
++)
1455 code
= iterative_hash_host_wide_int (TREE_INT_CST_ELT(t
, i
), code
);
1460 /* Return nonzero if the value represented by *X (an INTEGER_CST tree node)
1461 is the same as that given by *Y, which is the same. */
1464 int_cst_hasher::equal (tree x
, tree y
)
1466 const_tree
const xt
= x
;
1467 const_tree
const yt
= y
;
1469 if (TREE_TYPE (xt
) != TREE_TYPE (yt
)
1470 || TREE_INT_CST_NUNITS (xt
) != TREE_INT_CST_NUNITS (yt
)
1471 || TREE_INT_CST_EXT_NUNITS (xt
) != TREE_INT_CST_EXT_NUNITS (yt
))
1474 for (int i
= 0; i
< TREE_INT_CST_NUNITS (xt
); i
++)
1475 if (TREE_INT_CST_ELT (xt
, i
) != TREE_INT_CST_ELT (yt
, i
))
1481 /* Create an INT_CST node of TYPE and value CST.
1482 The returned node is always shared. For small integers we use a
1483 per-type vector cache, for larger ones we use a single hash table.
1484 The value is extended from its precision according to the sign of
1485 the type to be a multiple of HOST_BITS_PER_WIDE_INT. This defines
1486 the upper bits and ensures that hashing and value equality based
1487 upon the underlying HOST_WIDE_INTs works without masking. */
1490 wide_int_to_tree_1 (tree type
, const wide_int_ref
&pcst
)
1497 unsigned int prec
= TYPE_PRECISION (type
);
1498 signop sgn
= TYPE_SIGN (type
);
1500 /* Verify that everything is canonical. */
1501 int l
= pcst
.get_len ();
1504 if (pcst
.elt (l
- 1) == 0)
1505 gcc_checking_assert (pcst
.elt (l
- 2) < 0);
1506 if (pcst
.elt (l
- 1) == HOST_WIDE_INT_M1
)
1507 gcc_checking_assert (pcst
.elt (l
- 2) >= 0);
1510 wide_int cst
= wide_int::from (pcst
, prec
, sgn
);
1511 unsigned int ext_len
= get_int_cst_ext_nunits (type
, cst
);
1515 /* We just need to store a single HOST_WIDE_INT. */
1517 if (TYPE_UNSIGNED (type
))
1518 hwi
= cst
.to_uhwi ();
1520 hwi
= cst
.to_shwi ();
1522 switch (TREE_CODE (type
))
1525 gcc_assert (hwi
== 0);
1529 case REFERENCE_TYPE
:
1530 /* Cache NULL pointer and zero bounds. */
1539 /* Cache false or true. */
1541 if (IN_RANGE (hwi
, 0, 1))
1547 if (TYPE_SIGN (type
) == UNSIGNED
)
1550 limit
= INTEGER_SHARE_LIMIT
;
1551 if (IN_RANGE (hwi
, 0, INTEGER_SHARE_LIMIT
- 1))
1556 /* Cache [-1, N). */
1557 limit
= INTEGER_SHARE_LIMIT
+ 1;
1558 if (IN_RANGE (hwi
, -1, INTEGER_SHARE_LIMIT
- 1))
1572 /* Look for it in the type's vector of small shared ints. */
1573 if (!TYPE_CACHED_VALUES_P (type
))
1575 TYPE_CACHED_VALUES_P (type
) = 1;
1576 TYPE_CACHED_VALUES (type
) = make_tree_vec (limit
);
1579 t
= TREE_VEC_ELT (TYPE_CACHED_VALUES (type
), ix
);
1581 /* Make sure no one is clobbering the shared constant. */
1582 gcc_checking_assert (TREE_TYPE (t
) == type
1583 && TREE_INT_CST_NUNITS (t
) == 1
1584 && TREE_INT_CST_OFFSET_NUNITS (t
) == 1
1585 && TREE_INT_CST_EXT_NUNITS (t
) == 1
1586 && TREE_INT_CST_ELT (t
, 0) == hwi
);
1589 /* Create a new shared int. */
1590 t
= build_new_int_cst (type
, cst
);
1591 TREE_VEC_ELT (TYPE_CACHED_VALUES (type
), ix
) = t
;
1596 /* Use the cache of larger shared ints, using int_cst_node as
1599 TREE_INT_CST_ELT (int_cst_node
, 0) = hwi
;
1600 TREE_TYPE (int_cst_node
) = type
;
1602 tree
*slot
= int_cst_hash_table
->find_slot (int_cst_node
, INSERT
);
1606 /* Insert this one into the hash table. */
1609 /* Make a new node for next time round. */
1610 int_cst_node
= make_int_cst (1, 1);
1616 /* The value either hashes properly or we drop it on the floor
1617 for the gc to take care of. There will not be enough of them
1620 tree nt
= build_new_int_cst (type
, cst
);
1621 tree
*slot
= int_cst_hash_table
->find_slot (nt
, INSERT
);
1625 /* Insert this one into the hash table. */
1637 poly_int_cst_hasher::hash (tree t
)
1639 inchash::hash hstate
;
1641 hstate
.add_int (TYPE_UID (TREE_TYPE (t
)));
1642 for (unsigned int i
= 0; i
< NUM_POLY_INT_COEFFS
; ++i
)
1643 hstate
.add_wide_int (wi::to_wide (POLY_INT_CST_COEFF (t
, i
)));
1645 return hstate
.end ();
1649 poly_int_cst_hasher::equal (tree x
, const compare_type
&y
)
1651 if (TREE_TYPE (x
) != y
.first
)
1653 for (unsigned int i
= 0; i
< NUM_POLY_INT_COEFFS
; ++i
)
1654 if (wi::to_wide (POLY_INT_CST_COEFF (x
, i
)) != y
.second
->coeffs
[i
])
1659 /* Build a POLY_INT_CST node with type TYPE and with the elements in VALUES.
1660 The elements must also have type TYPE. */
1663 build_poly_int_cst (tree type
, const poly_wide_int_ref
&values
)
1665 unsigned int prec
= TYPE_PRECISION (type
);
1666 gcc_assert (prec
<= values
.coeffs
[0].get_precision ());
1667 poly_wide_int c
= poly_wide_int::from (values
, prec
, SIGNED
);
1670 h
.add_int (TYPE_UID (type
));
1671 for (unsigned int i
= 0; i
< NUM_POLY_INT_COEFFS
; ++i
)
1672 h
.add_wide_int (c
.coeffs
[i
]);
1673 poly_int_cst_hasher::compare_type
comp (type
, &c
);
1674 tree
*slot
= poly_int_cst_hash_table
->find_slot_with_hash (comp
, h
.end (),
1676 if (*slot
== NULL_TREE
)
1678 tree coeffs
[NUM_POLY_INT_COEFFS
];
1679 for (unsigned int i
= 0; i
< NUM_POLY_INT_COEFFS
; ++i
)
1680 coeffs
[i
] = wide_int_to_tree_1 (type
, c
.coeffs
[i
]);
1681 *slot
= build_new_poly_int_cst (type
, coeffs
);
1686 /* Create a constant tree with value VALUE in type TYPE. */
1689 wide_int_to_tree (tree type
, const poly_wide_int_ref
&value
)
1691 if (value
.is_constant ())
1692 return wide_int_to_tree_1 (type
, value
.coeffs
[0]);
1693 return build_poly_int_cst (type
, value
);
1697 cache_integer_cst (tree t
)
1699 tree type
= TREE_TYPE (t
);
1702 int prec
= TYPE_PRECISION (type
);
1704 gcc_assert (!TREE_OVERFLOW (t
));
1706 switch (TREE_CODE (type
))
1709 gcc_assert (integer_zerop (t
));
1713 case REFERENCE_TYPE
:
1714 /* Cache NULL pointer. */
1715 if (integer_zerop (t
))
1723 /* Cache false or true. */
1725 if (wi::ltu_p (wi::to_wide (t
), 2))
1726 ix
= TREE_INT_CST_ELT (t
, 0);
1731 if (TYPE_UNSIGNED (type
))
1734 limit
= INTEGER_SHARE_LIMIT
;
1736 /* This is a little hokie, but if the prec is smaller than
1737 what is necessary to hold INTEGER_SHARE_LIMIT, then the
1738 obvious test will not get the correct answer. */
1739 if (prec
< HOST_BITS_PER_WIDE_INT
)
1741 if (tree_to_uhwi (t
) < (unsigned HOST_WIDE_INT
) INTEGER_SHARE_LIMIT
)
1742 ix
= tree_to_uhwi (t
);
1744 else if (wi::ltu_p (wi::to_wide (t
), INTEGER_SHARE_LIMIT
))
1745 ix
= tree_to_uhwi (t
);
1750 limit
= INTEGER_SHARE_LIMIT
+ 1;
1752 if (integer_minus_onep (t
))
1754 else if (!wi::neg_p (wi::to_wide (t
)))
1756 if (prec
< HOST_BITS_PER_WIDE_INT
)
1758 if (tree_to_shwi (t
) < INTEGER_SHARE_LIMIT
)
1759 ix
= tree_to_shwi (t
) + 1;
1761 else if (wi::ltu_p (wi::to_wide (t
), INTEGER_SHARE_LIMIT
))
1762 ix
= tree_to_shwi (t
) + 1;
1776 /* Look for it in the type's vector of small shared ints. */
1777 if (!TYPE_CACHED_VALUES_P (type
))
1779 TYPE_CACHED_VALUES_P (type
) = 1;
1780 TYPE_CACHED_VALUES (type
) = make_tree_vec (limit
);
1783 gcc_assert (TREE_VEC_ELT (TYPE_CACHED_VALUES (type
), ix
) == NULL_TREE
);
1784 TREE_VEC_ELT (TYPE_CACHED_VALUES (type
), ix
) = t
;
1788 /* Use the cache of larger shared ints. */
1789 tree
*slot
= int_cst_hash_table
->find_slot (t
, INSERT
);
1790 /* If there is already an entry for the number verify it's the
1793 gcc_assert (wi::to_wide (tree (*slot
)) == wi::to_wide (t
));
1795 /* Otherwise insert this one into the hash table. */
1801 /* Builds an integer constant in TYPE such that lowest BITS bits are ones
1802 and the rest are zeros. */
1805 build_low_bits_mask (tree type
, unsigned bits
)
1807 gcc_assert (bits
<= TYPE_PRECISION (type
));
1809 return wide_int_to_tree (type
, wi::mask (bits
, false,
1810 TYPE_PRECISION (type
)));
1813 /* Checks that X is integer constant that can be expressed in (unsigned)
1814 HOST_WIDE_INT without loss of precision. */
1817 cst_and_fits_in_hwi (const_tree x
)
1819 return (TREE_CODE (x
) == INTEGER_CST
1820 && (tree_fits_shwi_p (x
) || tree_fits_uhwi_p (x
)));
1823 /* Build a newly constructed VECTOR_CST with the given values of
1824 (VECTOR_CST_)LOG2_NPATTERNS and (VECTOR_CST_)NELTS_PER_PATTERN. */
1827 make_vector (unsigned log2_npatterns
,
1828 unsigned int nelts_per_pattern MEM_STAT_DECL
)
1830 gcc_assert (IN_RANGE (nelts_per_pattern
, 1, 3));
1832 unsigned npatterns
= 1 << log2_npatterns
;
1833 unsigned encoded_nelts
= npatterns
* nelts_per_pattern
;
1834 unsigned length
= (sizeof (struct tree_vector
)
1835 + (encoded_nelts
- 1) * sizeof (tree
));
1837 record_node_allocation_statistics (VECTOR_CST
, length
);
1839 t
= ggc_alloc_cleared_tree_node_stat (length PASS_MEM_STAT
);
1841 TREE_SET_CODE (t
, VECTOR_CST
);
1842 TREE_CONSTANT (t
) = 1;
1843 VECTOR_CST_LOG2_NPATTERNS (t
) = log2_npatterns
;
1844 VECTOR_CST_NELTS_PER_PATTERN (t
) = nelts_per_pattern
;
1849 /* Return a new VECTOR_CST node whose type is TYPE and whose values
1850 are extracted from V, a vector of CONSTRUCTOR_ELT. */
1853 build_vector_from_ctor (tree type
, vec
<constructor_elt
, va_gc
> *v
)
1855 unsigned HOST_WIDE_INT idx
, nelts
;
1858 /* We can't construct a VECTOR_CST for a variable number of elements. */
1859 nelts
= TYPE_VECTOR_SUBPARTS (type
).to_constant ();
1860 tree_vector_builder
vec (type
, nelts
, 1);
1861 FOR_EACH_CONSTRUCTOR_VALUE (v
, idx
, value
)
1863 if (TREE_CODE (value
) == VECTOR_CST
)
1865 /* If NELTS is constant then this must be too. */
1866 unsigned int sub_nelts
= VECTOR_CST_NELTS (value
).to_constant ();
1867 for (unsigned i
= 0; i
< sub_nelts
; ++i
)
1868 vec
.quick_push (VECTOR_CST_ELT (value
, i
));
1871 vec
.quick_push (value
);
1873 while (vec
.length () < nelts
)
1874 vec
.quick_push (build_zero_cst (TREE_TYPE (type
)));
1876 return vec
.build ();
1879 /* Build a vector of type VECTYPE where all the elements are SCs. */
1881 build_vector_from_val (tree vectype
, tree sc
)
1883 unsigned HOST_WIDE_INT i
, nunits
;
1885 if (sc
== error_mark_node
)
1888 /* Verify that the vector type is suitable for SC. Note that there
1889 is some inconsistency in the type-system with respect to restrict
1890 qualifications of pointers. Vector types always have a main-variant
1891 element type and the qualification is applied to the vector-type.
1892 So TREE_TYPE (vector-type) does not return a properly qualified
1893 vector element-type. */
1894 gcc_checking_assert (types_compatible_p (TYPE_MAIN_VARIANT (TREE_TYPE (sc
)),
1895 TREE_TYPE (vectype
)));
1897 if (CONSTANT_CLASS_P (sc
))
1899 tree_vector_builder
v (vectype
, 1, 1);
1903 else if (!TYPE_VECTOR_SUBPARTS (vectype
).is_constant (&nunits
))
1904 return fold_build1 (VEC_DUPLICATE_EXPR
, vectype
, sc
);
1907 vec
<constructor_elt
, va_gc
> *v
;
1908 vec_alloc (v
, nunits
);
1909 for (i
= 0; i
< nunits
; ++i
)
1910 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, sc
);
1911 return build_constructor (vectype
, v
);
1915 /* If TYPE is not a vector type, just return SC, otherwise return
1916 build_vector_from_val (TYPE, SC). */
1919 build_uniform_cst (tree type
, tree sc
)
1921 if (!VECTOR_TYPE_P (type
))
1924 return build_vector_from_val (type
, sc
);
1927 /* Build a vector series of type TYPE in which element I has the value
1928 BASE + I * STEP. The result is a constant if BASE and STEP are constant
1929 and a VEC_SERIES_EXPR otherwise. */
1932 build_vec_series (tree type
, tree base
, tree step
)
1934 if (integer_zerop (step
))
1935 return build_vector_from_val (type
, base
);
1936 if (TREE_CODE (base
) == INTEGER_CST
&& TREE_CODE (step
) == INTEGER_CST
)
1938 tree_vector_builder
builder (type
, 1, 3);
1939 tree elt1
= wide_int_to_tree (TREE_TYPE (base
),
1940 wi::to_wide (base
) + wi::to_wide (step
));
1941 tree elt2
= wide_int_to_tree (TREE_TYPE (base
),
1942 wi::to_wide (elt1
) + wi::to_wide (step
));
1943 builder
.quick_push (base
);
1944 builder
.quick_push (elt1
);
1945 builder
.quick_push (elt2
);
1946 return builder
.build ();
1948 return build2 (VEC_SERIES_EXPR
, type
, base
, step
);
1951 /* Return a vector with the same number of units and number of bits
1952 as VEC_TYPE, but in which the elements are a linear series of unsigned
1953 integers { BASE, BASE + STEP, BASE + STEP * 2, ... }. */
1956 build_index_vector (tree vec_type
, poly_uint64 base
, poly_uint64 step
)
1958 tree index_vec_type
= vec_type
;
1959 tree index_elt_type
= TREE_TYPE (vec_type
);
1960 poly_uint64 nunits
= TYPE_VECTOR_SUBPARTS (vec_type
);
1961 if (!INTEGRAL_TYPE_P (index_elt_type
) || !TYPE_UNSIGNED (index_elt_type
))
1963 index_elt_type
= build_nonstandard_integer_type
1964 (GET_MODE_BITSIZE (SCALAR_TYPE_MODE (index_elt_type
)), true);
1965 index_vec_type
= build_vector_type (index_elt_type
, nunits
);
1968 tree_vector_builder
v (index_vec_type
, 1, 3);
1969 for (unsigned int i
= 0; i
< 3; ++i
)
1970 v
.quick_push (build_int_cstu (index_elt_type
, base
+ i
* step
));
1974 /* Something has messed with the elements of CONSTRUCTOR C after it was built;
1975 calculate TREE_CONSTANT and TREE_SIDE_EFFECTS. */
1978 recompute_constructor_flags (tree c
)
1982 bool constant_p
= true;
1983 bool side_effects_p
= false;
1984 vec
<constructor_elt
, va_gc
> *vals
= CONSTRUCTOR_ELTS (c
);
1986 FOR_EACH_CONSTRUCTOR_VALUE (vals
, i
, val
)
1988 /* Mostly ctors will have elts that don't have side-effects, so
1989 the usual case is to scan all the elements. Hence a single
1990 loop for both const and side effects, rather than one loop
1991 each (with early outs). */
1992 if (!TREE_CONSTANT (val
))
1994 if (TREE_SIDE_EFFECTS (val
))
1995 side_effects_p
= true;
1998 TREE_SIDE_EFFECTS (c
) = side_effects_p
;
1999 TREE_CONSTANT (c
) = constant_p
;
2002 /* Make sure that TREE_CONSTANT and TREE_SIDE_EFFECTS are correct for
2006 verify_constructor_flags (tree c
)
2010 bool constant_p
= TREE_CONSTANT (c
);
2011 bool side_effects_p
= TREE_SIDE_EFFECTS (c
);
2012 vec
<constructor_elt
, va_gc
> *vals
= CONSTRUCTOR_ELTS (c
);
2014 FOR_EACH_CONSTRUCTOR_VALUE (vals
, i
, val
)
2016 if (constant_p
&& !TREE_CONSTANT (val
))
2017 internal_error ("non-constant element in constant CONSTRUCTOR");
2018 if (!side_effects_p
&& TREE_SIDE_EFFECTS (val
))
2019 internal_error ("side-effects element in no-side-effects CONSTRUCTOR");
2023 /* Return a new CONSTRUCTOR node whose type is TYPE and whose values
2024 are in the vec pointed to by VALS. */
2026 build_constructor (tree type
, vec
<constructor_elt
, va_gc
> *vals MEM_STAT_DECL
)
2028 tree c
= make_node (CONSTRUCTOR PASS_MEM_STAT
);
2030 TREE_TYPE (c
) = type
;
2031 CONSTRUCTOR_ELTS (c
) = vals
;
2033 recompute_constructor_flags (c
);
2038 /* Build a CONSTRUCTOR node made of a single initializer, with the specified
2041 build_constructor_single (tree type
, tree index
, tree value
)
2043 vec
<constructor_elt
, va_gc
> *v
;
2044 constructor_elt elt
= {index
, value
};
2047 v
->quick_push (elt
);
2049 return build_constructor (type
, v
);
2053 /* Return a new CONSTRUCTOR node whose type is TYPE and whose values
2054 are in a list pointed to by VALS. */
2056 build_constructor_from_list (tree type
, tree vals
)
2059 vec
<constructor_elt
, va_gc
> *v
= NULL
;
2063 vec_alloc (v
, list_length (vals
));
2064 for (t
= vals
; t
; t
= TREE_CHAIN (t
))
2065 CONSTRUCTOR_APPEND_ELT (v
, TREE_PURPOSE (t
), TREE_VALUE (t
));
2068 return build_constructor (type
, v
);
2071 /* Return a new CONSTRUCTOR node whose type is TYPE. NELTS is the number
2072 of elements, provided as index/value pairs. */
2075 build_constructor_va (tree type
, int nelts
, ...)
2077 vec
<constructor_elt
, va_gc
> *v
= NULL
;
2080 va_start (p
, nelts
);
2081 vec_alloc (v
, nelts
);
2084 tree index
= va_arg (p
, tree
);
2085 tree value
= va_arg (p
, tree
);
2086 CONSTRUCTOR_APPEND_ELT (v
, index
, value
);
2089 return build_constructor (type
, v
);
2092 /* Return a node of type TYPE for which TREE_CLOBBER_P is true. */
2095 build_clobber (tree type
)
2097 tree clobber
= build_constructor (type
, NULL
);
2098 TREE_THIS_VOLATILE (clobber
) = true;
2102 /* Return a new FIXED_CST node whose type is TYPE and value is F. */
2105 build_fixed (tree type
, FIXED_VALUE_TYPE f
)
2108 FIXED_VALUE_TYPE
*fp
;
2110 v
= make_node (FIXED_CST
);
2111 fp
= ggc_alloc
<fixed_value
> ();
2112 memcpy (fp
, &f
, sizeof (FIXED_VALUE_TYPE
));
2114 TREE_TYPE (v
) = type
;
2115 TREE_FIXED_CST_PTR (v
) = fp
;
2119 /* Return a new REAL_CST node whose type is TYPE and value is D. */
2122 build_real (tree type
, REAL_VALUE_TYPE d
)
2125 REAL_VALUE_TYPE
*dp
;
2128 /* ??? Used to check for overflow here via CHECK_FLOAT_TYPE.
2129 Consider doing it via real_convert now. */
2131 v
= make_node (REAL_CST
);
2132 dp
= ggc_alloc
<real_value
> ();
2133 memcpy (dp
, &d
, sizeof (REAL_VALUE_TYPE
));
2135 TREE_TYPE (v
) = type
;
2136 TREE_REAL_CST_PTR (v
) = dp
;
2137 TREE_OVERFLOW (v
) = overflow
;
2141 /* Like build_real, but first truncate D to the type. */
2144 build_real_truncate (tree type
, REAL_VALUE_TYPE d
)
2146 return build_real (type
, real_value_truncate (TYPE_MODE (type
), d
));
2149 /* Return a new REAL_CST node whose type is TYPE
2150 and whose value is the integer value of the INTEGER_CST node I. */
2153 real_value_from_int_cst (const_tree type
, const_tree i
)
2157 /* Clear all bits of the real value type so that we can later do
2158 bitwise comparisons to see if two values are the same. */
2159 memset (&d
, 0, sizeof d
);
2161 real_from_integer (&d
, type
? TYPE_MODE (type
) : VOIDmode
, wi::to_wide (i
),
2162 TYPE_SIGN (TREE_TYPE (i
)));
2166 /* Given a tree representing an integer constant I, return a tree
2167 representing the same value as a floating-point constant of type TYPE. */
2170 build_real_from_int_cst (tree type
, const_tree i
)
2173 int overflow
= TREE_OVERFLOW (i
);
2175 v
= build_real (type
, real_value_from_int_cst (type
, i
));
2177 TREE_OVERFLOW (v
) |= overflow
;
2181 /* Return a newly constructed STRING_CST node whose value is
2182 the LEN characters at STR.
2183 Note that for a C string literal, LEN should include the trailing NUL.
2184 The TREE_TYPE is not initialized. */
2187 build_string (int len
, const char *str
)
2192 /* Do not waste bytes provided by padding of struct tree_string. */
2193 length
= len
+ offsetof (struct tree_string
, str
) + 1;
2195 record_node_allocation_statistics (STRING_CST
, length
);
2197 s
= (tree
) ggc_internal_alloc (length
);
2199 memset (s
, 0, sizeof (struct tree_typed
));
2200 TREE_SET_CODE (s
, STRING_CST
);
2201 TREE_CONSTANT (s
) = 1;
2202 TREE_STRING_LENGTH (s
) = len
;
2203 memcpy (s
->string
.str
, str
, len
);
2204 s
->string
.str
[len
] = '\0';
2209 /* Return a newly constructed COMPLEX_CST node whose value is
2210 specified by the real and imaginary parts REAL and IMAG.
2211 Both REAL and IMAG should be constant nodes. TYPE, if specified,
2212 will be the type of the COMPLEX_CST; otherwise a new type will be made. */
2215 build_complex (tree type
, tree real
, tree imag
)
2217 gcc_assert (CONSTANT_CLASS_P (real
));
2218 gcc_assert (CONSTANT_CLASS_P (imag
));
2220 tree t
= make_node (COMPLEX_CST
);
2222 TREE_REALPART (t
) = real
;
2223 TREE_IMAGPART (t
) = imag
;
2224 TREE_TYPE (t
) = type
? type
: build_complex_type (TREE_TYPE (real
));
2225 TREE_OVERFLOW (t
) = TREE_OVERFLOW (real
) | TREE_OVERFLOW (imag
);
2229 /* Build a complex (inf +- 0i), such as for the result of cproj.
2230 TYPE is the complex tree type of the result. If NEG is true, the
2231 imaginary zero is negative. */
2234 build_complex_inf (tree type
, bool neg
)
2236 REAL_VALUE_TYPE rinf
, rzero
= dconst0
;
2240 return build_complex (type
, build_real (TREE_TYPE (type
), rinf
),
2241 build_real (TREE_TYPE (type
), rzero
));
2244 /* Return the constant 1 in type TYPE. If TYPE has several elements, each
2245 element is set to 1. In particular, this is 1 + i for complex types. */
2248 build_each_one_cst (tree type
)
2250 if (TREE_CODE (type
) == COMPLEX_TYPE
)
2252 tree scalar
= build_one_cst (TREE_TYPE (type
));
2253 return build_complex (type
, scalar
, scalar
);
2256 return build_one_cst (type
);
2259 /* Return a constant of arithmetic type TYPE which is the
2260 multiplicative identity of the set TYPE. */
2263 build_one_cst (tree type
)
2265 switch (TREE_CODE (type
))
2267 case INTEGER_TYPE
: case ENUMERAL_TYPE
: case BOOLEAN_TYPE
:
2268 case POINTER_TYPE
: case REFERENCE_TYPE
:
2270 return build_int_cst (type
, 1);
2273 return build_real (type
, dconst1
);
2275 case FIXED_POINT_TYPE
:
2276 /* We can only generate 1 for accum types. */
2277 gcc_assert (ALL_SCALAR_ACCUM_MODE_P (TYPE_MODE (type
)));
2278 return build_fixed (type
, FCONST1 (TYPE_MODE (type
)));
2282 tree scalar
= build_one_cst (TREE_TYPE (type
));
2284 return build_vector_from_val (type
, scalar
);
2288 return build_complex (type
,
2289 build_one_cst (TREE_TYPE (type
)),
2290 build_zero_cst (TREE_TYPE (type
)));
2297 /* Return an integer of type TYPE containing all 1's in as much precision as
2298 it contains, or a complex or vector whose subparts are such integers. */
2301 build_all_ones_cst (tree type
)
2303 if (TREE_CODE (type
) == COMPLEX_TYPE
)
2305 tree scalar
= build_all_ones_cst (TREE_TYPE (type
));
2306 return build_complex (type
, scalar
, scalar
);
2309 return build_minus_one_cst (type
);
2312 /* Return a constant of arithmetic type TYPE which is the
2313 opposite of the multiplicative identity of the set TYPE. */
2316 build_minus_one_cst (tree type
)
2318 switch (TREE_CODE (type
))
2320 case INTEGER_TYPE
: case ENUMERAL_TYPE
: case BOOLEAN_TYPE
:
2321 case POINTER_TYPE
: case REFERENCE_TYPE
:
2323 return build_int_cst (type
, -1);
2326 return build_real (type
, dconstm1
);
2328 case FIXED_POINT_TYPE
:
2329 /* We can only generate 1 for accum types. */
2330 gcc_assert (ALL_SCALAR_ACCUM_MODE_P (TYPE_MODE (type
)));
2331 return build_fixed (type
,
2332 fixed_from_double_int (double_int_minus_one
,
2333 SCALAR_TYPE_MODE (type
)));
2337 tree scalar
= build_minus_one_cst (TREE_TYPE (type
));
2339 return build_vector_from_val (type
, scalar
);
2343 return build_complex (type
,
2344 build_minus_one_cst (TREE_TYPE (type
)),
2345 build_zero_cst (TREE_TYPE (type
)));
2352 /* Build 0 constant of type TYPE. This is used by constructor folding
2353 and thus the constant should be represented in memory by
2357 build_zero_cst (tree type
)
2359 switch (TREE_CODE (type
))
2361 case INTEGER_TYPE
: case ENUMERAL_TYPE
: case BOOLEAN_TYPE
:
2362 case POINTER_TYPE
: case REFERENCE_TYPE
:
2363 case OFFSET_TYPE
: case NULLPTR_TYPE
:
2364 return build_int_cst (type
, 0);
2367 return build_real (type
, dconst0
);
2369 case FIXED_POINT_TYPE
:
2370 return build_fixed (type
, FCONST0 (TYPE_MODE (type
)));
2374 tree scalar
= build_zero_cst (TREE_TYPE (type
));
2376 return build_vector_from_val (type
, scalar
);
2381 tree zero
= build_zero_cst (TREE_TYPE (type
));
2383 return build_complex (type
, zero
, zero
);
2387 if (!AGGREGATE_TYPE_P (type
))
2388 return fold_convert (type
, integer_zero_node
);
2389 return build_constructor (type
, NULL
);
2394 /* Build a BINFO with LEN language slots. */
2397 make_tree_binfo (unsigned base_binfos MEM_STAT_DECL
)
2400 size_t length
= (offsetof (struct tree_binfo
, base_binfos
)
2401 + vec
<tree
, va_gc
>::embedded_size (base_binfos
));
2403 record_node_allocation_statistics (TREE_BINFO
, length
);
2405 t
= ggc_alloc_tree_node_stat (length PASS_MEM_STAT
);
2407 memset (t
, 0, offsetof (struct tree_binfo
, base_binfos
));
2409 TREE_SET_CODE (t
, TREE_BINFO
);
2411 BINFO_BASE_BINFOS (t
)->embedded_init (base_binfos
);
2416 /* Create a CASE_LABEL_EXPR tree node and return it. */
2419 build_case_label (tree low_value
, tree high_value
, tree label_decl
)
2421 tree t
= make_node (CASE_LABEL_EXPR
);
2423 TREE_TYPE (t
) = void_type_node
;
2424 SET_EXPR_LOCATION (t
, DECL_SOURCE_LOCATION (label_decl
));
2426 CASE_LOW (t
) = low_value
;
2427 CASE_HIGH (t
) = high_value
;
2428 CASE_LABEL (t
) = label_decl
;
2429 CASE_CHAIN (t
) = NULL_TREE
;
2434 /* Build a newly constructed INTEGER_CST node. LEN and EXT_LEN are the
2435 values of TREE_INT_CST_NUNITS and TREE_INT_CST_EXT_NUNITS respectively.
2436 The latter determines the length of the HOST_WIDE_INT vector. */
2439 make_int_cst (int len
, int ext_len MEM_STAT_DECL
)
2442 int length
= ((ext_len
- 1) * sizeof (HOST_WIDE_INT
)
2443 + sizeof (struct tree_int_cst
));
2446 record_node_allocation_statistics (INTEGER_CST
, length
);
2448 t
= ggc_alloc_cleared_tree_node_stat (length PASS_MEM_STAT
);
2450 TREE_SET_CODE (t
, INTEGER_CST
);
2451 TREE_INT_CST_NUNITS (t
) = len
;
2452 TREE_INT_CST_EXT_NUNITS (t
) = ext_len
;
2453 /* to_offset can only be applied to trees that are offset_int-sized
2454 or smaller. EXT_LEN is correct if it fits, otherwise the constant
2455 must be exactly the precision of offset_int and so LEN is correct. */
2456 if (ext_len
<= OFFSET_INT_ELTS
)
2457 TREE_INT_CST_OFFSET_NUNITS (t
) = ext_len
;
2459 TREE_INT_CST_OFFSET_NUNITS (t
) = len
;
2461 TREE_CONSTANT (t
) = 1;
2466 /* Build a newly constructed TREE_VEC node of length LEN. */
2469 make_tree_vec (int len MEM_STAT_DECL
)
2472 size_t length
= (len
- 1) * sizeof (tree
) + sizeof (struct tree_vec
);
2474 record_node_allocation_statistics (TREE_VEC
, length
);
2476 t
= ggc_alloc_cleared_tree_node_stat (length PASS_MEM_STAT
);
2478 TREE_SET_CODE (t
, TREE_VEC
);
2479 TREE_VEC_LENGTH (t
) = len
;
2484 /* Grow a TREE_VEC node to new length LEN. */
2487 grow_tree_vec (tree v
, int len MEM_STAT_DECL
)
2489 gcc_assert (TREE_CODE (v
) == TREE_VEC
);
2491 int oldlen
= TREE_VEC_LENGTH (v
);
2492 gcc_assert (len
> oldlen
);
2494 size_t oldlength
= (oldlen
- 1) * sizeof (tree
) + sizeof (struct tree_vec
);
2495 size_t length
= (len
- 1) * sizeof (tree
) + sizeof (struct tree_vec
);
2497 record_node_allocation_statistics (TREE_VEC
, length
- oldlength
);
2499 v
= (tree
) ggc_realloc (v
, length PASS_MEM_STAT
);
2501 TREE_VEC_LENGTH (v
) = len
;
2506 /* Return 1 if EXPR is the constant zero, whether it is integral, float or
2507 fixed, and scalar, complex or vector. */
2510 zerop (const_tree expr
)
2512 return (integer_zerop (expr
)
2513 || real_zerop (expr
)
2514 || fixed_zerop (expr
));
2517 /* Return 1 if EXPR is the integer constant zero or a complex constant
2518 of zero, or a location wrapper for such a constant. */
2521 integer_zerop (const_tree expr
)
2523 STRIP_ANY_LOCATION_WRAPPER (expr
);
2525 switch (TREE_CODE (expr
))
2528 return wi::to_wide (expr
) == 0;
2530 return (integer_zerop (TREE_REALPART (expr
))
2531 && integer_zerop (TREE_IMAGPART (expr
)));
2533 return (VECTOR_CST_NPATTERNS (expr
) == 1
2534 && VECTOR_CST_DUPLICATE_P (expr
)
2535 && integer_zerop (VECTOR_CST_ENCODED_ELT (expr
, 0)));
2541 /* Return 1 if EXPR is the integer constant one or the corresponding
2542 complex constant, or a location wrapper for such a constant. */
2545 integer_onep (const_tree expr
)
2547 STRIP_ANY_LOCATION_WRAPPER (expr
);
2549 switch (TREE_CODE (expr
))
2552 return wi::eq_p (wi::to_widest (expr
), 1);
2554 return (integer_onep (TREE_REALPART (expr
))
2555 && integer_zerop (TREE_IMAGPART (expr
)));
2557 return (VECTOR_CST_NPATTERNS (expr
) == 1
2558 && VECTOR_CST_DUPLICATE_P (expr
)
2559 && integer_onep (VECTOR_CST_ENCODED_ELT (expr
, 0)));
2565 /* Return 1 if EXPR is the integer constant one. For complex and vector,
2566 return 1 if every piece is the integer constant one.
2567 Also return 1 for location wrappers for such a constant. */
2570 integer_each_onep (const_tree expr
)
2572 STRIP_ANY_LOCATION_WRAPPER (expr
);
2574 if (TREE_CODE (expr
) == COMPLEX_CST
)
2575 return (integer_onep (TREE_REALPART (expr
))
2576 && integer_onep (TREE_IMAGPART (expr
)));
2578 return integer_onep (expr
);
2581 /* Return 1 if EXPR is an integer containing all 1's in as much precision as
2582 it contains, or a complex or vector whose subparts are such integers,
2583 or a location wrapper for such a constant. */
2586 integer_all_onesp (const_tree expr
)
2588 STRIP_ANY_LOCATION_WRAPPER (expr
);
2590 if (TREE_CODE (expr
) == COMPLEX_CST
2591 && integer_all_onesp (TREE_REALPART (expr
))
2592 && integer_all_onesp (TREE_IMAGPART (expr
)))
2595 else if (TREE_CODE (expr
) == VECTOR_CST
)
2596 return (VECTOR_CST_NPATTERNS (expr
) == 1
2597 && VECTOR_CST_DUPLICATE_P (expr
)
2598 && integer_all_onesp (VECTOR_CST_ENCODED_ELT (expr
, 0)));
2600 else if (TREE_CODE (expr
) != INTEGER_CST
)
2603 return (wi::max_value (TYPE_PRECISION (TREE_TYPE (expr
)), UNSIGNED
)
2604 == wi::to_wide (expr
));
2607 /* Return 1 if EXPR is the integer constant minus one, or a location wrapper
2608 for such a constant. */
2611 integer_minus_onep (const_tree expr
)
2613 STRIP_ANY_LOCATION_WRAPPER (expr
);
2615 if (TREE_CODE (expr
) == COMPLEX_CST
)
2616 return (integer_all_onesp (TREE_REALPART (expr
))
2617 && integer_zerop (TREE_IMAGPART (expr
)));
2619 return integer_all_onesp (expr
);
2622 /* Return 1 if EXPR is an integer constant that is a power of 2 (i.e., has only
2623 one bit on), or a location wrapper for such a constant. */
2626 integer_pow2p (const_tree expr
)
2628 STRIP_ANY_LOCATION_WRAPPER (expr
);
2630 if (TREE_CODE (expr
) == COMPLEX_CST
2631 && integer_pow2p (TREE_REALPART (expr
))
2632 && integer_zerop (TREE_IMAGPART (expr
)))
2635 if (TREE_CODE (expr
) != INTEGER_CST
)
2638 return wi::popcount (wi::to_wide (expr
)) == 1;
2641 /* Return 1 if EXPR is an integer constant other than zero or a
2642 complex constant other than zero, or a location wrapper for such a
2646 integer_nonzerop (const_tree expr
)
2648 STRIP_ANY_LOCATION_WRAPPER (expr
);
2650 return ((TREE_CODE (expr
) == INTEGER_CST
2651 && wi::to_wide (expr
) != 0)
2652 || (TREE_CODE (expr
) == COMPLEX_CST
2653 && (integer_nonzerop (TREE_REALPART (expr
))
2654 || integer_nonzerop (TREE_IMAGPART (expr
)))));
2657 /* Return 1 if EXPR is the integer constant one. For vector,
2658 return 1 if every piece is the integer constant minus one
2659 (representing the value TRUE).
2660 Also return 1 for location wrappers for such a constant. */
2663 integer_truep (const_tree expr
)
2665 STRIP_ANY_LOCATION_WRAPPER (expr
);
2667 if (TREE_CODE (expr
) == VECTOR_CST
)
2668 return integer_all_onesp (expr
);
2669 return integer_onep (expr
);
2672 /* Return 1 if EXPR is the fixed-point constant zero, or a location wrapper
2673 for such a constant. */
2676 fixed_zerop (const_tree expr
)
2678 STRIP_ANY_LOCATION_WRAPPER (expr
);
2680 return (TREE_CODE (expr
) == FIXED_CST
2681 && TREE_FIXED_CST (expr
).data
.is_zero ());
2684 /* Return the power of two represented by a tree node known to be a
2688 tree_log2 (const_tree expr
)
2690 if (TREE_CODE (expr
) == COMPLEX_CST
)
2691 return tree_log2 (TREE_REALPART (expr
));
2693 return wi::exact_log2 (wi::to_wide (expr
));
2696 /* Similar, but return the largest integer Y such that 2 ** Y is less
2697 than or equal to EXPR. */
2700 tree_floor_log2 (const_tree expr
)
2702 if (TREE_CODE (expr
) == COMPLEX_CST
)
2703 return tree_log2 (TREE_REALPART (expr
));
2705 return wi::floor_log2 (wi::to_wide (expr
));
2708 /* Return number of known trailing zero bits in EXPR, or, if the value of
2709 EXPR is known to be zero, the precision of it's type. */
2712 tree_ctz (const_tree expr
)
2714 if (!INTEGRAL_TYPE_P (TREE_TYPE (expr
))
2715 && !POINTER_TYPE_P (TREE_TYPE (expr
)))
2718 unsigned int ret1
, ret2
, prec
= TYPE_PRECISION (TREE_TYPE (expr
));
2719 switch (TREE_CODE (expr
))
2722 ret1
= wi::ctz (wi::to_wide (expr
));
2723 return MIN (ret1
, prec
);
2725 ret1
= wi::ctz (get_nonzero_bits (expr
));
2726 return MIN (ret1
, prec
);
2733 ret1
= tree_ctz (TREE_OPERAND (expr
, 0));
2736 ret2
= tree_ctz (TREE_OPERAND (expr
, 1));
2737 return MIN (ret1
, ret2
);
2738 case POINTER_PLUS_EXPR
:
2739 ret1
= tree_ctz (TREE_OPERAND (expr
, 0));
2740 ret2
= tree_ctz (TREE_OPERAND (expr
, 1));
2741 /* Second operand is sizetype, which could be in theory
2742 wider than pointer's precision. Make sure we never
2743 return more than prec. */
2744 ret2
= MIN (ret2
, prec
);
2745 return MIN (ret1
, ret2
);
2747 ret1
= tree_ctz (TREE_OPERAND (expr
, 0));
2748 ret2
= tree_ctz (TREE_OPERAND (expr
, 1));
2749 return MAX (ret1
, ret2
);
2751 ret1
= tree_ctz (TREE_OPERAND (expr
, 0));
2752 ret2
= tree_ctz (TREE_OPERAND (expr
, 1));
2753 return MIN (ret1
+ ret2
, prec
);
2755 ret1
= tree_ctz (TREE_OPERAND (expr
, 0));
2756 if (tree_fits_uhwi_p (TREE_OPERAND (expr
, 1))
2757 && (tree_to_uhwi (TREE_OPERAND (expr
, 1)) < prec
))
2759 ret2
= tree_to_uhwi (TREE_OPERAND (expr
, 1));
2760 return MIN (ret1
+ ret2
, prec
);
2764 if (tree_fits_uhwi_p (TREE_OPERAND (expr
, 1))
2765 && (tree_to_uhwi (TREE_OPERAND (expr
, 1)) < prec
))
2767 ret1
= tree_ctz (TREE_OPERAND (expr
, 0));
2768 ret2
= tree_to_uhwi (TREE_OPERAND (expr
, 1));
2773 case TRUNC_DIV_EXPR
:
2775 case FLOOR_DIV_EXPR
:
2776 case ROUND_DIV_EXPR
:
2777 case EXACT_DIV_EXPR
:
2778 if (TREE_CODE (TREE_OPERAND (expr
, 1)) == INTEGER_CST
2779 && tree_int_cst_sgn (TREE_OPERAND (expr
, 1)) == 1)
2781 int l
= tree_log2 (TREE_OPERAND (expr
, 1));
2784 ret1
= tree_ctz (TREE_OPERAND (expr
, 0));
2792 ret1
= tree_ctz (TREE_OPERAND (expr
, 0));
2793 if (ret1
&& ret1
== TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (expr
, 0))))
2795 return MIN (ret1
, prec
);
2797 return tree_ctz (TREE_OPERAND (expr
, 0));
2799 ret1
= tree_ctz (TREE_OPERAND (expr
, 1));
2802 ret2
= tree_ctz (TREE_OPERAND (expr
, 2));
2803 return MIN (ret1
, ret2
);
2805 return tree_ctz (TREE_OPERAND (expr
, 1));
2807 ret1
= get_pointer_alignment (CONST_CAST_TREE (expr
));
2808 if (ret1
> BITS_PER_UNIT
)
2810 ret1
= ctz_hwi (ret1
/ BITS_PER_UNIT
);
2811 return MIN (ret1
, prec
);
2819 /* Return 1 if EXPR is the real constant zero. Trailing zeroes matter for
2820 decimal float constants, so don't return 1 for them.
2821 Also return 1 for location wrappers around such a constant. */
2824 real_zerop (const_tree expr
)
2826 STRIP_ANY_LOCATION_WRAPPER (expr
);
2828 switch (TREE_CODE (expr
))
2831 return real_equal (&TREE_REAL_CST (expr
), &dconst0
)
2832 && !(DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (expr
))));
2834 return real_zerop (TREE_REALPART (expr
))
2835 && real_zerop (TREE_IMAGPART (expr
));
2838 /* Don't simply check for a duplicate because the predicate
2839 accepts both +0.0 and -0.0. */
2840 unsigned count
= vector_cst_encoded_nelts (expr
);
2841 for (unsigned int i
= 0; i
< count
; ++i
)
2842 if (!real_zerop (VECTOR_CST_ENCODED_ELT (expr
, i
)))
2851 /* Return 1 if EXPR is the real constant one in real or complex form.
2852 Trailing zeroes matter for decimal float constants, so don't return
2854 Also return 1 for location wrappers around such a constant. */
2857 real_onep (const_tree expr
)
2859 STRIP_ANY_LOCATION_WRAPPER (expr
);
2861 switch (TREE_CODE (expr
))
2864 return real_equal (&TREE_REAL_CST (expr
), &dconst1
)
2865 && !(DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (expr
))));
2867 return real_onep (TREE_REALPART (expr
))
2868 && real_zerop (TREE_IMAGPART (expr
));
2870 return (VECTOR_CST_NPATTERNS (expr
) == 1
2871 && VECTOR_CST_DUPLICATE_P (expr
)
2872 && real_onep (VECTOR_CST_ENCODED_ELT (expr
, 0)));
2878 /* Return 1 if EXPR is the real constant minus one. Trailing zeroes
2879 matter for decimal float constants, so don't return 1 for them.
2880 Also return 1 for location wrappers around such a constant. */
2883 real_minus_onep (const_tree expr
)
2885 STRIP_ANY_LOCATION_WRAPPER (expr
);
2887 switch (TREE_CODE (expr
))
2890 return real_equal (&TREE_REAL_CST (expr
), &dconstm1
)
2891 && !(DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (expr
))));
2893 return real_minus_onep (TREE_REALPART (expr
))
2894 && real_zerop (TREE_IMAGPART (expr
));
2896 return (VECTOR_CST_NPATTERNS (expr
) == 1
2897 && VECTOR_CST_DUPLICATE_P (expr
)
2898 && real_minus_onep (VECTOR_CST_ENCODED_ELT (expr
, 0)));
2904 /* Nonzero if EXP is a constant or a cast of a constant. */
2907 really_constant_p (const_tree exp
)
2909 /* This is not quite the same as STRIP_NOPS. It does more. */
2910 while (CONVERT_EXPR_P (exp
)
2911 || TREE_CODE (exp
) == NON_LVALUE_EXPR
)
2912 exp
= TREE_OPERAND (exp
, 0);
2913 return TREE_CONSTANT (exp
);
2916 /* Return true if T holds a polynomial pointer difference, storing it in
2917 *VALUE if so. A true return means that T's precision is no greater
2918 than 64 bits, which is the largest address space we support, so *VALUE
2919 never loses precision. However, the signedness of the result does
2920 not necessarily match the signedness of T: sometimes an unsigned type
2921 like sizetype is used to encode a value that is actually negative. */
2924 ptrdiff_tree_p (const_tree t
, poly_int64_pod
*value
)
2928 if (TREE_CODE (t
) == INTEGER_CST
)
2930 if (!cst_and_fits_in_hwi (t
))
2932 *value
= int_cst_value (t
);
2935 if (POLY_INT_CST_P (t
))
2937 for (unsigned int i
= 0; i
< NUM_POLY_INT_COEFFS
; ++i
)
2938 if (!cst_and_fits_in_hwi (POLY_INT_CST_COEFF (t
, i
)))
2940 for (unsigned int i
= 0; i
< NUM_POLY_INT_COEFFS
; ++i
)
2941 value
->coeffs
[i
] = int_cst_value (POLY_INT_CST_COEFF (t
, i
));
2948 tree_to_poly_int64 (const_tree t
)
2950 gcc_assert (tree_fits_poly_int64_p (t
));
2951 if (POLY_INT_CST_P (t
))
2952 return poly_int_cst_value (t
).force_shwi ();
2953 return TREE_INT_CST_LOW (t
);
2957 tree_to_poly_uint64 (const_tree t
)
2959 gcc_assert (tree_fits_poly_uint64_p (t
));
2960 if (POLY_INT_CST_P (t
))
2961 return poly_int_cst_value (t
).force_uhwi ();
2962 return TREE_INT_CST_LOW (t
);
2965 /* Return first list element whose TREE_VALUE is ELEM.
2966 Return 0 if ELEM is not in LIST. */
2969 value_member (tree elem
, tree list
)
2973 if (elem
== TREE_VALUE (list
))
2975 list
= TREE_CHAIN (list
);
2980 /* Return first list element whose TREE_PURPOSE is ELEM.
2981 Return 0 if ELEM is not in LIST. */
2984 purpose_member (const_tree elem
, tree list
)
2988 if (elem
== TREE_PURPOSE (list
))
2990 list
= TREE_CHAIN (list
);
2995 /* Return true if ELEM is in V. */
2998 vec_member (const_tree elem
, vec
<tree
, va_gc
> *v
)
3002 FOR_EACH_VEC_SAFE_ELT (v
, ix
, t
)
3008 /* Returns element number IDX (zero-origin) of chain CHAIN, or
3012 chain_index (int idx
, tree chain
)
3014 for (; chain
&& idx
> 0; --idx
)
3015 chain
= TREE_CHAIN (chain
);
3019 /* Return nonzero if ELEM is part of the chain CHAIN. */
3022 chain_member (const_tree elem
, const_tree chain
)
3028 chain
= DECL_CHAIN (chain
);
3034 /* Return the length of a chain of nodes chained through TREE_CHAIN.
3035 We expect a null pointer to mark the end of the chain.
3036 This is the Lisp primitive `length'. */
3039 list_length (const_tree t
)
3042 #ifdef ENABLE_TREE_CHECKING
3050 #ifdef ENABLE_TREE_CHECKING
3053 gcc_assert (p
!= q
);
3061 /* Returns the first FIELD_DECL in the TYPE_FIELDS of the RECORD_TYPE or
3062 UNION_TYPE TYPE, or NULL_TREE if none. */
3065 first_field (const_tree type
)
3067 tree t
= TYPE_FIELDS (type
);
3068 while (t
&& TREE_CODE (t
) != FIELD_DECL
)
3073 /* Concatenate two chains of nodes (chained through TREE_CHAIN)
3074 by modifying the last node in chain 1 to point to chain 2.
3075 This is the Lisp primitive `nconc'. */
3078 chainon (tree op1
, tree op2
)
3087 for (t1
= op1
; TREE_CHAIN (t1
); t1
= TREE_CHAIN (t1
))
3089 TREE_CHAIN (t1
) = op2
;
3091 #ifdef ENABLE_TREE_CHECKING
3094 for (t2
= op2
; t2
; t2
= TREE_CHAIN (t2
))
3095 gcc_assert (t2
!= t1
);
3102 /* Return the last node in a chain of nodes (chained through TREE_CHAIN). */
3105 tree_last (tree chain
)
3109 while ((next
= TREE_CHAIN (chain
)))
3114 /* Reverse the order of elements in the chain T,
3115 and return the new head of the chain (old last element). */
3120 tree prev
= 0, decl
, next
;
3121 for (decl
= t
; decl
; decl
= next
)
3123 /* We shouldn't be using this function to reverse BLOCK chains; we
3124 have blocks_nreverse for that. */
3125 gcc_checking_assert (TREE_CODE (decl
) != BLOCK
);
3126 next
= TREE_CHAIN (decl
);
3127 TREE_CHAIN (decl
) = prev
;
3133 /* Return a newly created TREE_LIST node whose
3134 purpose and value fields are PARM and VALUE. */
3137 build_tree_list (tree parm
, tree value MEM_STAT_DECL
)
3139 tree t
= make_node (TREE_LIST PASS_MEM_STAT
);
3140 TREE_PURPOSE (t
) = parm
;
3141 TREE_VALUE (t
) = value
;
3145 /* Build a chain of TREE_LIST nodes from a vector. */
3148 build_tree_list_vec (const vec
<tree
, va_gc
> *vec MEM_STAT_DECL
)
3150 tree ret
= NULL_TREE
;
3154 FOR_EACH_VEC_SAFE_ELT (vec
, i
, t
)
3156 *pp
= build_tree_list (NULL
, t PASS_MEM_STAT
);
3157 pp
= &TREE_CHAIN (*pp
);
3162 /* Return a newly created TREE_LIST node whose
3163 purpose and value fields are PURPOSE and VALUE
3164 and whose TREE_CHAIN is CHAIN. */
3167 tree_cons (tree purpose
, tree value
, tree chain MEM_STAT_DECL
)
3171 node
= ggc_alloc_tree_node_stat (sizeof (struct tree_list
) PASS_MEM_STAT
);
3172 memset (node
, 0, sizeof (struct tree_common
));
3174 record_node_allocation_statistics (TREE_LIST
, sizeof (struct tree_list
));
3176 TREE_SET_CODE (node
, TREE_LIST
);
3177 TREE_CHAIN (node
) = chain
;
3178 TREE_PURPOSE (node
) = purpose
;
3179 TREE_VALUE (node
) = value
;
3183 /* Return the values of the elements of a CONSTRUCTOR as a vector of
3187 ctor_to_vec (tree ctor
)
3189 vec
<tree
, va_gc
> *vec
;
3190 vec_alloc (vec
, CONSTRUCTOR_NELTS (ctor
));
3194 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (ctor
), ix
, val
)
3195 vec
->quick_push (val
);
3200 /* Return the size nominally occupied by an object of type TYPE
3201 when it resides in memory. The value is measured in units of bytes,
3202 and its data type is that normally used for type sizes
3203 (which is the first type created by make_signed_type or
3204 make_unsigned_type). */
3207 size_in_bytes_loc (location_t loc
, const_tree type
)
3211 if (type
== error_mark_node
)
3212 return integer_zero_node
;
3214 type
= TYPE_MAIN_VARIANT (type
);
3215 t
= TYPE_SIZE_UNIT (type
);
3219 lang_hooks
.types
.incomplete_type_error (loc
, NULL_TREE
, type
);
3220 return size_zero_node
;
3226 /* Return the size of TYPE (in bytes) as a wide integer
3227 or return -1 if the size can vary or is larger than an integer. */
3230 int_size_in_bytes (const_tree type
)
3234 if (type
== error_mark_node
)
3237 type
= TYPE_MAIN_VARIANT (type
);
3238 t
= TYPE_SIZE_UNIT (type
);
3240 if (t
&& tree_fits_uhwi_p (t
))
3241 return TREE_INT_CST_LOW (t
);
3246 /* Return the maximum size of TYPE (in bytes) as a wide integer
3247 or return -1 if the size can vary or is larger than an integer. */
3250 max_int_size_in_bytes (const_tree type
)
3252 HOST_WIDE_INT size
= -1;
3255 /* If this is an array type, check for a possible MAX_SIZE attached. */
3257 if (TREE_CODE (type
) == ARRAY_TYPE
)
3259 size_tree
= TYPE_ARRAY_MAX_SIZE (type
);
3261 if (size_tree
&& tree_fits_uhwi_p (size_tree
))
3262 size
= tree_to_uhwi (size_tree
);
3265 /* If we still haven't been able to get a size, see if the language
3266 can compute a maximum size. */
3270 size_tree
= lang_hooks
.types
.max_size (type
);
3272 if (size_tree
&& tree_fits_uhwi_p (size_tree
))
3273 size
= tree_to_uhwi (size_tree
);
3279 /* Return the bit position of FIELD, in bits from the start of the record.
3280 This is a tree of type bitsizetype. */
3283 bit_position (const_tree field
)
3285 return bit_from_pos (DECL_FIELD_OFFSET (field
),
3286 DECL_FIELD_BIT_OFFSET (field
));
3289 /* Return the byte position of FIELD, in bytes from the start of the record.
3290 This is a tree of type sizetype. */
3293 byte_position (const_tree field
)
3295 return byte_from_pos (DECL_FIELD_OFFSET (field
),
3296 DECL_FIELD_BIT_OFFSET (field
));
3299 /* Likewise, but return as an integer. It must be representable in
3300 that way (since it could be a signed value, we don't have the
3301 option of returning -1 like int_size_in_byte can. */
3304 int_byte_position (const_tree field
)
3306 return tree_to_shwi (byte_position (field
));
3309 /* Return the strictest alignment, in bits, that T is known to have. */
3312 expr_align (const_tree t
)
3314 unsigned int align0
, align1
;
3316 switch (TREE_CODE (t
))
3318 CASE_CONVERT
: case NON_LVALUE_EXPR
:
3319 /* If we have conversions, we know that the alignment of the
3320 object must meet each of the alignments of the types. */
3321 align0
= expr_align (TREE_OPERAND (t
, 0));
3322 align1
= TYPE_ALIGN (TREE_TYPE (t
));
3323 return MAX (align0
, align1
);
3325 case SAVE_EXPR
: case COMPOUND_EXPR
: case MODIFY_EXPR
:
3326 case INIT_EXPR
: case TARGET_EXPR
: case WITH_CLEANUP_EXPR
:
3327 case CLEANUP_POINT_EXPR
:
3328 /* These don't change the alignment of an object. */
3329 return expr_align (TREE_OPERAND (t
, 0));
3332 /* The best we can do is say that the alignment is the least aligned
3334 align0
= expr_align (TREE_OPERAND (t
, 1));
3335 align1
= expr_align (TREE_OPERAND (t
, 2));
3336 return MIN (align0
, align1
);
3338 /* FIXME: LABEL_DECL and CONST_DECL never have DECL_ALIGN set
3339 meaningfully, it's always 1. */
3340 case LABEL_DECL
: case CONST_DECL
:
3341 case VAR_DECL
: case PARM_DECL
: case RESULT_DECL
:
3343 gcc_assert (DECL_ALIGN (t
) != 0);
3344 return DECL_ALIGN (t
);
3350 /* Otherwise take the alignment from that of the type. */
3351 return TYPE_ALIGN (TREE_TYPE (t
));
3354 /* Return, as a tree node, the number of elements for TYPE (which is an
3355 ARRAY_TYPE) minus one. This counts only elements of the top array. */
3358 array_type_nelts (const_tree type
)
3360 tree index_type
, min
, max
;
3362 /* If they did it with unspecified bounds, then we should have already
3363 given an error about it before we got here. */
3364 if (! TYPE_DOMAIN (type
))
3365 return error_mark_node
;
3367 index_type
= TYPE_DOMAIN (type
);
3368 min
= TYPE_MIN_VALUE (index_type
);
3369 max
= TYPE_MAX_VALUE (index_type
);
3371 /* TYPE_MAX_VALUE may not be set if the array has unknown length. */
3373 return error_mark_node
;
3375 return (integer_zerop (min
)
3377 : fold_build2 (MINUS_EXPR
, TREE_TYPE (max
), max
, min
));
3380 /* If arg is static -- a reference to an object in static storage -- then
3381 return the object. This is not the same as the C meaning of `static'.
3382 If arg isn't static, return NULL. */
3387 switch (TREE_CODE (arg
))
3390 /* Nested functions are static, even though taking their address will
3391 involve a trampoline as we unnest the nested function and create
3392 the trampoline on the tree level. */
3396 return ((TREE_STATIC (arg
) || DECL_EXTERNAL (arg
))
3397 && ! DECL_THREAD_LOCAL_P (arg
)
3398 && ! DECL_DLLIMPORT_P (arg
)
3402 return ((TREE_STATIC (arg
) || DECL_EXTERNAL (arg
))
3406 return TREE_STATIC (arg
) ? arg
: NULL
;
3413 /* If the thing being referenced is not a field, then it is
3414 something language specific. */
3415 gcc_assert (TREE_CODE (TREE_OPERAND (arg
, 1)) == FIELD_DECL
);
3417 /* If we are referencing a bitfield, we can't evaluate an
3418 ADDR_EXPR at compile time and so it isn't a constant. */
3419 if (DECL_BIT_FIELD (TREE_OPERAND (arg
, 1)))
3422 return staticp (TREE_OPERAND (arg
, 0));
3428 return TREE_CONSTANT (TREE_OPERAND (arg
, 0)) ? arg
: NULL
;
3431 case ARRAY_RANGE_REF
:
3432 if (TREE_CODE (TYPE_SIZE (TREE_TYPE (arg
))) == INTEGER_CST
3433 && TREE_CODE (TREE_OPERAND (arg
, 1)) == INTEGER_CST
)
3434 return staticp (TREE_OPERAND (arg
, 0));
3438 case COMPOUND_LITERAL_EXPR
:
3439 return TREE_STATIC (COMPOUND_LITERAL_EXPR_DECL (arg
)) ? arg
: NULL
;
3449 /* Return whether OP is a DECL whose address is function-invariant. */
3452 decl_address_invariant_p (const_tree op
)
3454 /* The conditions below are slightly less strict than the one in
3457 switch (TREE_CODE (op
))
3466 if ((TREE_STATIC (op
) || DECL_EXTERNAL (op
))
3467 || DECL_THREAD_LOCAL_P (op
)
3468 || DECL_CONTEXT (op
) == current_function_decl
3469 || decl_function_context (op
) == current_function_decl
)
3474 if ((TREE_STATIC (op
) || DECL_EXTERNAL (op
))
3475 || decl_function_context (op
) == current_function_decl
)
3486 /* Return whether OP is a DECL whose address is interprocedural-invariant. */
3489 decl_address_ip_invariant_p (const_tree op
)
3491 /* The conditions below are slightly less strict than the one in
3494 switch (TREE_CODE (op
))
3502 if (((TREE_STATIC (op
) || DECL_EXTERNAL (op
))
3503 && !DECL_DLLIMPORT_P (op
))
3504 || DECL_THREAD_LOCAL_P (op
))
3509 if ((TREE_STATIC (op
) || DECL_EXTERNAL (op
)))
3521 /* Return true if T is function-invariant (internal function, does
3522 not handle arithmetic; that's handled in skip_simple_arithmetic and
3523 tree_invariant_p). */
3526 tree_invariant_p_1 (tree t
)
3530 if (TREE_CONSTANT (t
)
3531 || (TREE_READONLY (t
) && !TREE_SIDE_EFFECTS (t
)))
3534 switch (TREE_CODE (t
))
3540 op
= TREE_OPERAND (t
, 0);
3541 while (handled_component_p (op
))
3543 switch (TREE_CODE (op
))
3546 case ARRAY_RANGE_REF
:
3547 if (!tree_invariant_p (TREE_OPERAND (op
, 1))
3548 || TREE_OPERAND (op
, 2) != NULL_TREE
3549 || TREE_OPERAND (op
, 3) != NULL_TREE
)
3554 if (TREE_OPERAND (op
, 2) != NULL_TREE
)
3560 op
= TREE_OPERAND (op
, 0);
3563 return CONSTANT_CLASS_P (op
) || decl_address_invariant_p (op
);
3572 /* Return true if T is function-invariant. */
3575 tree_invariant_p (tree t
)
3577 tree inner
= skip_simple_arithmetic (t
);
3578 return tree_invariant_p_1 (inner
);
3581 /* Wrap a SAVE_EXPR around EXPR, if appropriate.
3582 Do this to any expression which may be used in more than one place,
3583 but must be evaluated only once.
3585 Normally, expand_expr would reevaluate the expression each time.
3586 Calling save_expr produces something that is evaluated and recorded
3587 the first time expand_expr is called on it. Subsequent calls to
3588 expand_expr just reuse the recorded value.
3590 The call to expand_expr that generates code that actually computes
3591 the value is the first call *at compile time*. Subsequent calls
3592 *at compile time* generate code to use the saved value.
3593 This produces correct result provided that *at run time* control
3594 always flows through the insns made by the first expand_expr
3595 before reaching the other places where the save_expr was evaluated.
3596 You, the caller of save_expr, must make sure this is so.
3598 Constants, and certain read-only nodes, are returned with no
3599 SAVE_EXPR because that is safe. Expressions containing placeholders
3600 are not touched; see tree.def for an explanation of what these
3604 save_expr (tree expr
)
3608 /* If the tree evaluates to a constant, then we don't want to hide that
3609 fact (i.e. this allows further folding, and direct checks for constants).
3610 However, a read-only object that has side effects cannot be bypassed.
3611 Since it is no problem to reevaluate literals, we just return the
3613 inner
= skip_simple_arithmetic (expr
);
3614 if (TREE_CODE (inner
) == ERROR_MARK
)
3617 if (tree_invariant_p_1 (inner
))
3620 /* If INNER contains a PLACEHOLDER_EXPR, we must evaluate it each time, since
3621 it means that the size or offset of some field of an object depends on
3622 the value within another field.
3624 Note that it must not be the case that EXPR contains both a PLACEHOLDER_EXPR
3625 and some variable since it would then need to be both evaluated once and
3626 evaluated more than once. Front-ends must assure this case cannot
3627 happen by surrounding any such subexpressions in their own SAVE_EXPR
3628 and forcing evaluation at the proper time. */
3629 if (contains_placeholder_p (inner
))
3632 expr
= build1_loc (EXPR_LOCATION (expr
), SAVE_EXPR
, TREE_TYPE (expr
), expr
);
3634 /* This expression might be placed ahead of a jump to ensure that the
3635 value was computed on both sides of the jump. So make sure it isn't
3636 eliminated as dead. */
3637 TREE_SIDE_EFFECTS (expr
) = 1;
3641 /* Look inside EXPR into any simple arithmetic operations. Return the
3642 outermost non-arithmetic or non-invariant node. */
3645 skip_simple_arithmetic (tree expr
)
3647 /* We don't care about whether this can be used as an lvalue in this
3649 while (TREE_CODE (expr
) == NON_LVALUE_EXPR
)
3650 expr
= TREE_OPERAND (expr
, 0);
3652 /* If we have simple operations applied to a SAVE_EXPR or to a SAVE_EXPR and
3653 a constant, it will be more efficient to not make another SAVE_EXPR since
3654 it will allow better simplification and GCSE will be able to merge the
3655 computations if they actually occur. */
3658 if (UNARY_CLASS_P (expr
))
3659 expr
= TREE_OPERAND (expr
, 0);
3660 else if (BINARY_CLASS_P (expr
))
3662 if (tree_invariant_p (TREE_OPERAND (expr
, 1)))
3663 expr
= TREE_OPERAND (expr
, 0);
3664 else if (tree_invariant_p (TREE_OPERAND (expr
, 0)))
3665 expr
= TREE_OPERAND (expr
, 1);
3676 /* Look inside EXPR into simple arithmetic operations involving constants.
3677 Return the outermost non-arithmetic or non-constant node. */
3680 skip_simple_constant_arithmetic (tree expr
)
3682 while (TREE_CODE (expr
) == NON_LVALUE_EXPR
)
3683 expr
= TREE_OPERAND (expr
, 0);
3687 if (UNARY_CLASS_P (expr
))
3688 expr
= TREE_OPERAND (expr
, 0);
3689 else if (BINARY_CLASS_P (expr
))
3691 if (TREE_CONSTANT (TREE_OPERAND (expr
, 1)))
3692 expr
= TREE_OPERAND (expr
, 0);
3693 else if (TREE_CONSTANT (TREE_OPERAND (expr
, 0)))
3694 expr
= TREE_OPERAND (expr
, 1);
3705 /* Return which tree structure is used by T. */
3707 enum tree_node_structure_enum
3708 tree_node_structure (const_tree t
)
3710 const enum tree_code code
= TREE_CODE (t
);
3711 return tree_node_structure_for_code (code
);
3714 /* Set various status flags when building a CALL_EXPR object T. */
3717 process_call_operands (tree t
)
3719 bool side_effects
= TREE_SIDE_EFFECTS (t
);
3720 bool read_only
= false;
3721 int i
= call_expr_flags (t
);
3723 /* Calls have side-effects, except those to const or pure functions. */
3724 if ((i
& ECF_LOOPING_CONST_OR_PURE
) || !(i
& (ECF_CONST
| ECF_PURE
)))
3725 side_effects
= true;
3726 /* Propagate TREE_READONLY of arguments for const functions. */
3730 if (!side_effects
|| read_only
)
3731 for (i
= 1; i
< TREE_OPERAND_LENGTH (t
); i
++)
3733 tree op
= TREE_OPERAND (t
, i
);
3734 if (op
&& TREE_SIDE_EFFECTS (op
))
3735 side_effects
= true;
3736 if (op
&& !TREE_READONLY (op
) && !CONSTANT_CLASS_P (op
))
3740 TREE_SIDE_EFFECTS (t
) = side_effects
;
3741 TREE_READONLY (t
) = read_only
;
3744 /* Return true if EXP contains a PLACEHOLDER_EXPR, i.e. if it represents a
3745 size or offset that depends on a field within a record. */
3748 contains_placeholder_p (const_tree exp
)
3750 enum tree_code code
;
3755 code
= TREE_CODE (exp
);
3756 if (code
== PLACEHOLDER_EXPR
)
3759 switch (TREE_CODE_CLASS (code
))
3762 /* Don't look at any PLACEHOLDER_EXPRs that might be in index or bit
3763 position computations since they will be converted into a
3764 WITH_RECORD_EXPR involving the reference, which will assume
3765 here will be valid. */
3766 return CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp
, 0));
3768 case tcc_exceptional
:
3769 if (code
== TREE_LIST
)
3770 return (CONTAINS_PLACEHOLDER_P (TREE_VALUE (exp
))
3771 || CONTAINS_PLACEHOLDER_P (TREE_CHAIN (exp
)));
3776 case tcc_comparison
:
3777 case tcc_expression
:
3781 /* Ignoring the first operand isn't quite right, but works best. */
3782 return CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp
, 1));
3785 return (CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp
, 0))
3786 || CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp
, 1))
3787 || CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp
, 2)));
3790 /* The save_expr function never wraps anything containing
3791 a PLACEHOLDER_EXPR. */
3798 switch (TREE_CODE_LENGTH (code
))
3801 return CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp
, 0));
3803 return (CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp
, 0))
3804 || CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp
, 1)));
3815 const_call_expr_arg_iterator iter
;
3816 FOR_EACH_CONST_CALL_EXPR_ARG (arg
, iter
, exp
)
3817 if (CONTAINS_PLACEHOLDER_P (arg
))
3831 /* Return true if any part of the structure of TYPE involves a PLACEHOLDER_EXPR
3832 directly. This includes size, bounds, qualifiers (for QUAL_UNION_TYPE) and
3836 type_contains_placeholder_1 (const_tree type
)
3838 /* If the size contains a placeholder or the parent type (component type in
3839 the case of arrays) type involves a placeholder, this type does. */
3840 if (CONTAINS_PLACEHOLDER_P (TYPE_SIZE (type
))
3841 || CONTAINS_PLACEHOLDER_P (TYPE_SIZE_UNIT (type
))
3842 || (!POINTER_TYPE_P (type
)
3844 && type_contains_placeholder_p (TREE_TYPE (type
))))
3847 /* Now do type-specific checks. Note that the last part of the check above
3848 greatly limits what we have to do below. */
3849 switch (TREE_CODE (type
))
3857 case REFERENCE_TYPE
:
3866 case FIXED_POINT_TYPE
:
3867 /* Here we just check the bounds. */
3868 return (CONTAINS_PLACEHOLDER_P (TYPE_MIN_VALUE (type
))
3869 || CONTAINS_PLACEHOLDER_P (TYPE_MAX_VALUE (type
)));
3872 /* We have already checked the component type above, so just check
3873 the domain type. Flexible array members have a null domain. */
3874 return TYPE_DOMAIN (type
) ?
3875 type_contains_placeholder_p (TYPE_DOMAIN (type
)) : false;
3879 case QUAL_UNION_TYPE
:
3883 for (field
= TYPE_FIELDS (type
); field
; field
= DECL_CHAIN (field
))
3884 if (TREE_CODE (field
) == FIELD_DECL
3885 && (CONTAINS_PLACEHOLDER_P (DECL_FIELD_OFFSET (field
))
3886 || (TREE_CODE (type
) == QUAL_UNION_TYPE
3887 && CONTAINS_PLACEHOLDER_P (DECL_QUALIFIER (field
)))
3888 || type_contains_placeholder_p (TREE_TYPE (field
))))
3899 /* Wrapper around above function used to cache its result. */
3902 type_contains_placeholder_p (tree type
)
3906 /* If the contains_placeholder_bits field has been initialized,
3907 then we know the answer. */
3908 if (TYPE_CONTAINS_PLACEHOLDER_INTERNAL (type
) > 0)
3909 return TYPE_CONTAINS_PLACEHOLDER_INTERNAL (type
) - 1;
3911 /* Indicate that we've seen this type node, and the answer is false.
3912 This is what we want to return if we run into recursion via fields. */
3913 TYPE_CONTAINS_PLACEHOLDER_INTERNAL (type
) = 1;
3915 /* Compute the real value. */
3916 result
= type_contains_placeholder_1 (type
);
3918 /* Store the real value. */
3919 TYPE_CONTAINS_PLACEHOLDER_INTERNAL (type
) = result
+ 1;
3924 /* Push tree EXP onto vector QUEUE if it is not already present. */
3927 push_without_duplicates (tree exp
, vec
<tree
> *queue
)
3932 FOR_EACH_VEC_ELT (*queue
, i
, iter
)
3933 if (simple_cst_equal (iter
, exp
) == 1)
3937 queue
->safe_push (exp
);
3940 /* Given a tree EXP, find all occurrences of references to fields
3941 in a PLACEHOLDER_EXPR and place them in vector REFS without
3942 duplicates. Also record VAR_DECLs and CONST_DECLs. Note that
3943 we assume here that EXP contains only arithmetic expressions
3944 or CALL_EXPRs with PLACEHOLDER_EXPRs occurring only in their
3948 find_placeholder_in_expr (tree exp
, vec
<tree
> *refs
)
3950 enum tree_code code
= TREE_CODE (exp
);
3954 /* We handle TREE_LIST and COMPONENT_REF separately. */
3955 if (code
== TREE_LIST
)
3957 FIND_PLACEHOLDER_IN_EXPR (TREE_CHAIN (exp
), refs
);
3958 FIND_PLACEHOLDER_IN_EXPR (TREE_VALUE (exp
), refs
);
3960 else if (code
== COMPONENT_REF
)
3962 for (inner
= TREE_OPERAND (exp
, 0);
3963 REFERENCE_CLASS_P (inner
);
3964 inner
= TREE_OPERAND (inner
, 0))
3967 if (TREE_CODE (inner
) == PLACEHOLDER_EXPR
)
3968 push_without_duplicates (exp
, refs
);
3970 FIND_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp
, 0), refs
);
3973 switch (TREE_CODE_CLASS (code
))
3978 case tcc_declaration
:
3979 /* Variables allocated to static storage can stay. */
3980 if (!TREE_STATIC (exp
))
3981 push_without_duplicates (exp
, refs
);
3984 case tcc_expression
:
3985 /* This is the pattern built in ada/make_aligning_type. */
3986 if (code
== ADDR_EXPR
3987 && TREE_CODE (TREE_OPERAND (exp
, 0)) == PLACEHOLDER_EXPR
)
3989 push_without_duplicates (exp
, refs
);
3995 case tcc_exceptional
:
3998 case tcc_comparison
:
4000 for (i
= 0; i
< TREE_CODE_LENGTH (code
); i
++)
4001 FIND_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp
, i
), refs
);
4005 for (i
= 1; i
< TREE_OPERAND_LENGTH (exp
); i
++)
4006 FIND_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp
, i
), refs
);
4014 /* Given a tree EXP, a FIELD_DECL F, and a replacement value R,
4015 return a tree with all occurrences of references to F in a
4016 PLACEHOLDER_EXPR replaced by R. Also handle VAR_DECLs and
4017 CONST_DECLs. Note that we assume here that EXP contains only
4018 arithmetic expressions or CALL_EXPRs with PLACEHOLDER_EXPRs
4019 occurring only in their argument list. */
4022 substitute_in_expr (tree exp
, tree f
, tree r
)
4024 enum tree_code code
= TREE_CODE (exp
);
4025 tree op0
, op1
, op2
, op3
;
4028 /* We handle TREE_LIST and COMPONENT_REF separately. */
4029 if (code
== TREE_LIST
)
4031 op0
= SUBSTITUTE_IN_EXPR (TREE_CHAIN (exp
), f
, r
);
4032 op1
= SUBSTITUTE_IN_EXPR (TREE_VALUE (exp
), f
, r
);
4033 if (op0
== TREE_CHAIN (exp
) && op1
== TREE_VALUE (exp
))
4036 return tree_cons (TREE_PURPOSE (exp
), op1
, op0
);
4038 else if (code
== COMPONENT_REF
)
4042 /* If this expression is getting a value from a PLACEHOLDER_EXPR
4043 and it is the right field, replace it with R. */
4044 for (inner
= TREE_OPERAND (exp
, 0);
4045 REFERENCE_CLASS_P (inner
);
4046 inner
= TREE_OPERAND (inner
, 0))
4050 op1
= TREE_OPERAND (exp
, 1);
4052 if (TREE_CODE (inner
) == PLACEHOLDER_EXPR
&& op1
== f
)
4055 /* If this expression hasn't been completed let, leave it alone. */
4056 if (TREE_CODE (inner
) == PLACEHOLDER_EXPR
&& !TREE_TYPE (inner
))
4059 op0
= SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp
, 0), f
, r
);
4060 if (op0
== TREE_OPERAND (exp
, 0))
4064 = fold_build3 (COMPONENT_REF
, TREE_TYPE (exp
), op0
, op1
, NULL_TREE
);
4067 switch (TREE_CODE_CLASS (code
))
4072 case tcc_declaration
:
4078 case tcc_expression
:
4084 case tcc_exceptional
:
4087 case tcc_comparison
:
4089 switch (TREE_CODE_LENGTH (code
))
4095 op0
= SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp
, 0), f
, r
);
4096 if (op0
== TREE_OPERAND (exp
, 0))
4099 new_tree
= fold_build1 (code
, TREE_TYPE (exp
), op0
);
4103 op0
= SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp
, 0), f
, r
);
4104 op1
= SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp
, 1), f
, r
);
4106 if (op0
== TREE_OPERAND (exp
, 0) && op1
== TREE_OPERAND (exp
, 1))
4109 new_tree
= fold_build2 (code
, TREE_TYPE (exp
), op0
, op1
);
4113 op0
= SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp
, 0), f
, r
);
4114 op1
= SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp
, 1), f
, r
);
4115 op2
= SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp
, 2), f
, r
);
4117 if (op0
== TREE_OPERAND (exp
, 0) && op1
== TREE_OPERAND (exp
, 1)
4118 && op2
== TREE_OPERAND (exp
, 2))
4121 new_tree
= fold_build3 (code
, TREE_TYPE (exp
), op0
, op1
, op2
);
4125 op0
= SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp
, 0), f
, r
);
4126 op1
= SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp
, 1), f
, r
);
4127 op2
= SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp
, 2), f
, r
);
4128 op3
= SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp
, 3), f
, r
);
4130 if (op0
== TREE_OPERAND (exp
, 0) && op1
== TREE_OPERAND (exp
, 1)
4131 && op2
== TREE_OPERAND (exp
, 2)
4132 && op3
== TREE_OPERAND (exp
, 3))
4136 = fold (build4 (code
, TREE_TYPE (exp
), op0
, op1
, op2
, op3
));
4148 new_tree
= NULL_TREE
;
4150 /* If we are trying to replace F with a constant or with another
4151 instance of one of the arguments of the call, inline back
4152 functions which do nothing else than computing a value from
4153 the arguments they are passed. This makes it possible to
4154 fold partially or entirely the replacement expression. */
4155 if (code
== CALL_EXPR
)
4157 bool maybe_inline
= false;
4158 if (CONSTANT_CLASS_P (r
))
4159 maybe_inline
= true;
4161 for (i
= 3; i
< TREE_OPERAND_LENGTH (exp
); i
++)
4162 if (operand_equal_p (TREE_OPERAND (exp
, i
), r
, 0))
4164 maybe_inline
= true;
4169 tree t
= maybe_inline_call_in_expr (exp
);
4171 return SUBSTITUTE_IN_EXPR (t
, f
, r
);
4175 for (i
= 1; i
< TREE_OPERAND_LENGTH (exp
); i
++)
4177 tree op
= TREE_OPERAND (exp
, i
);
4178 tree new_op
= SUBSTITUTE_IN_EXPR (op
, f
, r
);
4182 new_tree
= copy_node (exp
);
4183 TREE_OPERAND (new_tree
, i
) = new_op
;
4189 new_tree
= fold (new_tree
);
4190 if (TREE_CODE (new_tree
) == CALL_EXPR
)
4191 process_call_operands (new_tree
);
4202 TREE_READONLY (new_tree
) |= TREE_READONLY (exp
);
4204 if (code
== INDIRECT_REF
|| code
== ARRAY_REF
|| code
== ARRAY_RANGE_REF
)
4205 TREE_THIS_NOTRAP (new_tree
) |= TREE_THIS_NOTRAP (exp
);
4210 /* Similar, but look for a PLACEHOLDER_EXPR in EXP and find a replacement
4211 for it within OBJ, a tree that is an object or a chain of references. */
4214 substitute_placeholder_in_expr (tree exp
, tree obj
)
4216 enum tree_code code
= TREE_CODE (exp
);
4217 tree op0
, op1
, op2
, op3
;
4220 /* If this is a PLACEHOLDER_EXPR, see if we find a corresponding type
4221 in the chain of OBJ. */
4222 if (code
== PLACEHOLDER_EXPR
)
4224 tree need_type
= TYPE_MAIN_VARIANT (TREE_TYPE (exp
));
4227 for (elt
= obj
; elt
!= 0;
4228 elt
= ((TREE_CODE (elt
) == COMPOUND_EXPR
4229 || TREE_CODE (elt
) == COND_EXPR
)
4230 ? TREE_OPERAND (elt
, 1)
4231 : (REFERENCE_CLASS_P (elt
)
4232 || UNARY_CLASS_P (elt
)
4233 || BINARY_CLASS_P (elt
)
4234 || VL_EXP_CLASS_P (elt
)
4235 || EXPRESSION_CLASS_P (elt
))
4236 ? TREE_OPERAND (elt
, 0) : 0))
4237 if (TYPE_MAIN_VARIANT (TREE_TYPE (elt
)) == need_type
)
4240 for (elt
= obj
; elt
!= 0;
4241 elt
= ((TREE_CODE (elt
) == COMPOUND_EXPR
4242 || TREE_CODE (elt
) == COND_EXPR
)
4243 ? TREE_OPERAND (elt
, 1)
4244 : (REFERENCE_CLASS_P (elt
)
4245 || UNARY_CLASS_P (elt
)
4246 || BINARY_CLASS_P (elt
)
4247 || VL_EXP_CLASS_P (elt
)
4248 || EXPRESSION_CLASS_P (elt
))
4249 ? TREE_OPERAND (elt
, 0) : 0))
4250 if (POINTER_TYPE_P (TREE_TYPE (elt
))
4251 && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (elt
)))
4253 return fold_build1 (INDIRECT_REF
, need_type
, elt
);
4255 /* If we didn't find it, return the original PLACEHOLDER_EXPR. If it
4256 survives until RTL generation, there will be an error. */
4260 /* TREE_LIST is special because we need to look at TREE_VALUE
4261 and TREE_CHAIN, not TREE_OPERANDS. */
4262 else if (code
== TREE_LIST
)
4264 op0
= SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_CHAIN (exp
), obj
);
4265 op1
= SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_VALUE (exp
), obj
);
4266 if (op0
== TREE_CHAIN (exp
) && op1
== TREE_VALUE (exp
))
4269 return tree_cons (TREE_PURPOSE (exp
), op1
, op0
);
4272 switch (TREE_CODE_CLASS (code
))
4275 case tcc_declaration
:
4278 case tcc_exceptional
:
4281 case tcc_comparison
:
4282 case tcc_expression
:
4285 switch (TREE_CODE_LENGTH (code
))
4291 op0
= SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp
, 0), obj
);
4292 if (op0
== TREE_OPERAND (exp
, 0))
4295 new_tree
= fold_build1 (code
, TREE_TYPE (exp
), op0
);
4299 op0
= SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp
, 0), obj
);
4300 op1
= SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp
, 1), obj
);
4302 if (op0
== TREE_OPERAND (exp
, 0) && op1
== TREE_OPERAND (exp
, 1))
4305 new_tree
= fold_build2 (code
, TREE_TYPE (exp
), op0
, op1
);
4309 op0
= SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp
, 0), obj
);
4310 op1
= SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp
, 1), obj
);
4311 op2
= SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp
, 2), obj
);
4313 if (op0
== TREE_OPERAND (exp
, 0) && op1
== TREE_OPERAND (exp
, 1)
4314 && op2
== TREE_OPERAND (exp
, 2))
4317 new_tree
= fold_build3 (code
, TREE_TYPE (exp
), op0
, op1
, op2
);
4321 op0
= SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp
, 0), obj
);
4322 op1
= SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp
, 1), obj
);
4323 op2
= SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp
, 2), obj
);
4324 op3
= SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp
, 3), obj
);
4326 if (op0
== TREE_OPERAND (exp
, 0) && op1
== TREE_OPERAND (exp
, 1)
4327 && op2
== TREE_OPERAND (exp
, 2)
4328 && op3
== TREE_OPERAND (exp
, 3))
4332 = fold (build4 (code
, TREE_TYPE (exp
), op0
, op1
, op2
, op3
));
4344 new_tree
= NULL_TREE
;
4346 for (i
= 1; i
< TREE_OPERAND_LENGTH (exp
); i
++)
4348 tree op
= TREE_OPERAND (exp
, i
);
4349 tree new_op
= SUBSTITUTE_PLACEHOLDER_IN_EXPR (op
, obj
);
4353 new_tree
= copy_node (exp
);
4354 TREE_OPERAND (new_tree
, i
) = new_op
;
4360 new_tree
= fold (new_tree
);
4361 if (TREE_CODE (new_tree
) == CALL_EXPR
)
4362 process_call_operands (new_tree
);
4373 TREE_READONLY (new_tree
) |= TREE_READONLY (exp
);
4375 if (code
== INDIRECT_REF
|| code
== ARRAY_REF
|| code
== ARRAY_RANGE_REF
)
4376 TREE_THIS_NOTRAP (new_tree
) |= TREE_THIS_NOTRAP (exp
);
4382 /* Subroutine of stabilize_reference; this is called for subtrees of
4383 references. Any expression with side-effects must be put in a SAVE_EXPR
4384 to ensure that it is only evaluated once.
4386 We don't put SAVE_EXPR nodes around everything, because assigning very
4387 simple expressions to temporaries causes us to miss good opportunities
4388 for optimizations. Among other things, the opportunity to fold in the
4389 addition of a constant into an addressing mode often gets lost, e.g.
4390 "y[i+1] += x;". In general, we take the approach that we should not make
4391 an assignment unless we are forced into it - i.e., that any non-side effect
4392 operator should be allowed, and that cse should take care of coalescing
4393 multiple utterances of the same expression should that prove fruitful. */
4396 stabilize_reference_1 (tree e
)
4399 enum tree_code code
= TREE_CODE (e
);
4401 /* We cannot ignore const expressions because it might be a reference
4402 to a const array but whose index contains side-effects. But we can
4403 ignore things that are actual constant or that already have been
4404 handled by this function. */
4406 if (tree_invariant_p (e
))
4409 switch (TREE_CODE_CLASS (code
))
4411 case tcc_exceptional
:
4412 /* Always wrap STATEMENT_LIST into SAVE_EXPR, even if it doesn't
4413 have side-effects. */
4414 if (code
== STATEMENT_LIST
)
4415 return save_expr (e
);
4418 case tcc_declaration
:
4419 case tcc_comparison
:
4421 case tcc_expression
:
4424 /* If the expression has side-effects, then encase it in a SAVE_EXPR
4425 so that it will only be evaluated once. */
4426 /* The reference (r) and comparison (<) classes could be handled as
4427 below, but it is generally faster to only evaluate them once. */
4428 if (TREE_SIDE_EFFECTS (e
))
4429 return save_expr (e
);
4433 /* Constants need no processing. In fact, we should never reach
4438 /* Division is slow and tends to be compiled with jumps,
4439 especially the division by powers of 2 that is often
4440 found inside of an array reference. So do it just once. */
4441 if (code
== TRUNC_DIV_EXPR
|| code
== TRUNC_MOD_EXPR
4442 || code
== FLOOR_DIV_EXPR
|| code
== FLOOR_MOD_EXPR
4443 || code
== CEIL_DIV_EXPR
|| code
== CEIL_MOD_EXPR
4444 || code
== ROUND_DIV_EXPR
|| code
== ROUND_MOD_EXPR
)
4445 return save_expr (e
);
4446 /* Recursively stabilize each operand. */
4447 result
= build_nt (code
, stabilize_reference_1 (TREE_OPERAND (e
, 0)),
4448 stabilize_reference_1 (TREE_OPERAND (e
, 1)));
4452 /* Recursively stabilize each operand. */
4453 result
= build_nt (code
, stabilize_reference_1 (TREE_OPERAND (e
, 0)));
4460 TREE_TYPE (result
) = TREE_TYPE (e
);
4461 TREE_READONLY (result
) = TREE_READONLY (e
);
4462 TREE_SIDE_EFFECTS (result
) = TREE_SIDE_EFFECTS (e
);
4463 TREE_THIS_VOLATILE (result
) = TREE_THIS_VOLATILE (e
);
4468 /* Stabilize a reference so that we can use it any number of times
4469 without causing its operands to be evaluated more than once.
4470 Returns the stabilized reference. This works by means of save_expr,
4471 so see the caveats in the comments about save_expr.
4473 Also allows conversion expressions whose operands are references.
4474 Any other kind of expression is returned unchanged. */
4477 stabilize_reference (tree ref
)
4480 enum tree_code code
= TREE_CODE (ref
);
4487 /* No action is needed in this case. */
4492 case FIX_TRUNC_EXPR
:
4493 result
= build_nt (code
, stabilize_reference (TREE_OPERAND (ref
, 0)));
4497 result
= build_nt (INDIRECT_REF
,
4498 stabilize_reference_1 (TREE_OPERAND (ref
, 0)));
4502 result
= build_nt (COMPONENT_REF
,
4503 stabilize_reference (TREE_OPERAND (ref
, 0)),
4504 TREE_OPERAND (ref
, 1), NULL_TREE
);
4508 result
= build_nt (BIT_FIELD_REF
,
4509 stabilize_reference (TREE_OPERAND (ref
, 0)),
4510 TREE_OPERAND (ref
, 1), TREE_OPERAND (ref
, 2));
4511 REF_REVERSE_STORAGE_ORDER (result
) = REF_REVERSE_STORAGE_ORDER (ref
);
4515 result
= build_nt (ARRAY_REF
,
4516 stabilize_reference (TREE_OPERAND (ref
, 0)),
4517 stabilize_reference_1 (TREE_OPERAND (ref
, 1)),
4518 TREE_OPERAND (ref
, 2), TREE_OPERAND (ref
, 3));
4521 case ARRAY_RANGE_REF
:
4522 result
= build_nt (ARRAY_RANGE_REF
,
4523 stabilize_reference (TREE_OPERAND (ref
, 0)),
4524 stabilize_reference_1 (TREE_OPERAND (ref
, 1)),
4525 TREE_OPERAND (ref
, 2), TREE_OPERAND (ref
, 3));
4529 /* We cannot wrap the first expression in a SAVE_EXPR, as then
4530 it wouldn't be ignored. This matters when dealing with
4532 return stabilize_reference_1 (ref
);
4534 /* If arg isn't a kind of lvalue we recognize, make no change.
4535 Caller should recognize the error for an invalid lvalue. */
4540 return error_mark_node
;
4543 TREE_TYPE (result
) = TREE_TYPE (ref
);
4544 TREE_READONLY (result
) = TREE_READONLY (ref
);
4545 TREE_SIDE_EFFECTS (result
) = TREE_SIDE_EFFECTS (ref
);
4546 TREE_THIS_VOLATILE (result
) = TREE_THIS_VOLATILE (ref
);
4551 /* Low-level constructors for expressions. */
4553 /* A helper function for build1 and constant folders. Set TREE_CONSTANT,
4554 and TREE_SIDE_EFFECTS for an ADDR_EXPR. */
4557 recompute_tree_invariant_for_addr_expr (tree t
)
4560 bool tc
= true, se
= false;
4562 gcc_assert (TREE_CODE (t
) == ADDR_EXPR
);
4564 /* We started out assuming this address is both invariant and constant, but
4565 does not have side effects. Now go down any handled components and see if
4566 any of them involve offsets that are either non-constant or non-invariant.
4567 Also check for side-effects.
4569 ??? Note that this code makes no attempt to deal with the case where
4570 taking the address of something causes a copy due to misalignment. */
4572 #define UPDATE_FLAGS(NODE) \
4573 do { tree _node = (NODE); \
4574 if (_node && !TREE_CONSTANT (_node)) tc = false; \
4575 if (_node && TREE_SIDE_EFFECTS (_node)) se = true; } while (0)
4577 for (node
= TREE_OPERAND (t
, 0); handled_component_p (node
);
4578 node
= TREE_OPERAND (node
, 0))
4580 /* If the first operand doesn't have an ARRAY_TYPE, this is a bogus
4581 array reference (probably made temporarily by the G++ front end),
4582 so ignore all the operands. */
4583 if ((TREE_CODE (node
) == ARRAY_REF
4584 || TREE_CODE (node
) == ARRAY_RANGE_REF
)
4585 && TREE_CODE (TREE_TYPE (TREE_OPERAND (node
, 0))) == ARRAY_TYPE
)
4587 UPDATE_FLAGS (TREE_OPERAND (node
, 1));
4588 if (TREE_OPERAND (node
, 2))
4589 UPDATE_FLAGS (TREE_OPERAND (node
, 2));
4590 if (TREE_OPERAND (node
, 3))
4591 UPDATE_FLAGS (TREE_OPERAND (node
, 3));
4593 /* Likewise, just because this is a COMPONENT_REF doesn't mean we have a
4594 FIELD_DECL, apparently. The G++ front end can put something else
4595 there, at least temporarily. */
4596 else if (TREE_CODE (node
) == COMPONENT_REF
4597 && TREE_CODE (TREE_OPERAND (node
, 1)) == FIELD_DECL
)
4599 if (TREE_OPERAND (node
, 2))
4600 UPDATE_FLAGS (TREE_OPERAND (node
, 2));
4604 node
= lang_hooks
.expr_to_decl (node
, &tc
, &se
);
4606 /* Now see what's inside. If it's an INDIRECT_REF, copy our properties from
4607 the address, since &(*a)->b is a form of addition. If it's a constant, the
4608 address is constant too. If it's a decl, its address is constant if the
4609 decl is static. Everything else is not constant and, furthermore,
4610 taking the address of a volatile variable is not volatile. */
4611 if (TREE_CODE (node
) == INDIRECT_REF
4612 || TREE_CODE (node
) == MEM_REF
)
4613 UPDATE_FLAGS (TREE_OPERAND (node
, 0));
4614 else if (CONSTANT_CLASS_P (node
))
4616 else if (DECL_P (node
))
4617 tc
&= (staticp (node
) != NULL_TREE
);
4621 se
|= TREE_SIDE_EFFECTS (node
);
4625 TREE_CONSTANT (t
) = tc
;
4626 TREE_SIDE_EFFECTS (t
) = se
;
4630 /* Build an expression of code CODE, data type TYPE, and operands as
4631 specified. Expressions and reference nodes can be created this way.
4632 Constants, decls, types and misc nodes cannot be.
4634 We define 5 non-variadic functions, from 0 to 4 arguments. This is
4635 enough for all extant tree codes. */
4638 build0 (enum tree_code code
, tree tt MEM_STAT_DECL
)
4642 gcc_assert (TREE_CODE_LENGTH (code
) == 0);
4644 t
= make_node (code PASS_MEM_STAT
);
4651 build1 (enum tree_code code
, tree type
, tree node MEM_STAT_DECL
)
4653 int length
= sizeof (struct tree_exp
);
4656 record_node_allocation_statistics (code
, length
);
4658 gcc_assert (TREE_CODE_LENGTH (code
) == 1);
4660 t
= ggc_alloc_tree_node_stat (length PASS_MEM_STAT
);
4662 memset (t
, 0, sizeof (struct tree_common
));
4664 TREE_SET_CODE (t
, code
);
4666 TREE_TYPE (t
) = type
;
4667 SET_EXPR_LOCATION (t
, UNKNOWN_LOCATION
);
4668 TREE_OPERAND (t
, 0) = node
;
4669 if (node
&& !TYPE_P (node
))
4671 TREE_SIDE_EFFECTS (t
) = TREE_SIDE_EFFECTS (node
);
4672 TREE_READONLY (t
) = TREE_READONLY (node
);
4675 if (TREE_CODE_CLASS (code
) == tcc_statement
)
4677 if (code
!= DEBUG_BEGIN_STMT
)
4678 TREE_SIDE_EFFECTS (t
) = 1;
4683 /* All of these have side-effects, no matter what their
4685 TREE_SIDE_EFFECTS (t
) = 1;
4686 TREE_READONLY (t
) = 0;
4690 /* Whether a dereference is readonly has nothing to do with whether
4691 its operand is readonly. */
4692 TREE_READONLY (t
) = 0;
4697 recompute_tree_invariant_for_addr_expr (t
);
4701 if ((TREE_CODE_CLASS (code
) == tcc_unary
|| code
== VIEW_CONVERT_EXPR
)
4702 && node
&& !TYPE_P (node
)
4703 && TREE_CONSTANT (node
))
4704 TREE_CONSTANT (t
) = 1;
4705 if (TREE_CODE_CLASS (code
) == tcc_reference
4706 && node
&& TREE_THIS_VOLATILE (node
))
4707 TREE_THIS_VOLATILE (t
) = 1;
4714 #define PROCESS_ARG(N) \
4716 TREE_OPERAND (t, N) = arg##N; \
4717 if (arg##N &&!TYPE_P (arg##N)) \
4719 if (TREE_SIDE_EFFECTS (arg##N)) \
4721 if (!TREE_READONLY (arg##N) \
4722 && !CONSTANT_CLASS_P (arg##N)) \
4723 (void) (read_only = 0); \
4724 if (!TREE_CONSTANT (arg##N)) \
4725 (void) (constant = 0); \
4730 build2 (enum tree_code code
, tree tt
, tree arg0
, tree arg1 MEM_STAT_DECL
)
4732 bool constant
, read_only
, side_effects
, div_by_zero
;
4735 gcc_assert (TREE_CODE_LENGTH (code
) == 2);
4737 if ((code
== MINUS_EXPR
|| code
== PLUS_EXPR
|| code
== MULT_EXPR
)
4738 && arg0
&& arg1
&& tt
&& POINTER_TYPE_P (tt
)
4739 /* When sizetype precision doesn't match that of pointers
4740 we need to be able to build explicit extensions or truncations
4741 of the offset argument. */
4742 && TYPE_PRECISION (sizetype
) == TYPE_PRECISION (tt
))
4743 gcc_assert (TREE_CODE (arg0
) == INTEGER_CST
4744 && TREE_CODE (arg1
) == INTEGER_CST
);
4746 if (code
== POINTER_PLUS_EXPR
&& arg0
&& arg1
&& tt
)
4747 gcc_assert (POINTER_TYPE_P (tt
) && POINTER_TYPE_P (TREE_TYPE (arg0
))
4748 && ptrofftype_p (TREE_TYPE (arg1
)));
4750 t
= make_node (code PASS_MEM_STAT
);
4753 /* Below, we automatically set TREE_SIDE_EFFECTS and TREE_READONLY for the
4754 result based on those same flags for the arguments. But if the
4755 arguments aren't really even `tree' expressions, we shouldn't be trying
4758 /* Expressions without side effects may be constant if their
4759 arguments are as well. */
4760 constant
= (TREE_CODE_CLASS (code
) == tcc_comparison
4761 || TREE_CODE_CLASS (code
) == tcc_binary
);
4763 side_effects
= TREE_SIDE_EFFECTS (t
);
4767 case TRUNC_DIV_EXPR
:
4769 case FLOOR_DIV_EXPR
:
4770 case ROUND_DIV_EXPR
:
4771 case EXACT_DIV_EXPR
:
4773 case FLOOR_MOD_EXPR
:
4774 case ROUND_MOD_EXPR
:
4775 case TRUNC_MOD_EXPR
:
4776 div_by_zero
= integer_zerop (arg1
);
4779 div_by_zero
= false;
4785 TREE_SIDE_EFFECTS (t
) = side_effects
;
4786 if (code
== MEM_REF
)
4788 if (arg0
&& TREE_CODE (arg0
) == ADDR_EXPR
)
4790 tree o
= TREE_OPERAND (arg0
, 0);
4791 TREE_READONLY (t
) = TREE_READONLY (o
);
4792 TREE_THIS_VOLATILE (t
) = TREE_THIS_VOLATILE (o
);
4797 TREE_READONLY (t
) = read_only
;
4798 /* Don't mark X / 0 as constant. */
4799 TREE_CONSTANT (t
) = constant
&& !div_by_zero
;
4800 TREE_THIS_VOLATILE (t
)
4801 = (TREE_CODE_CLASS (code
) == tcc_reference
4802 && arg0
&& TREE_THIS_VOLATILE (arg0
));
4810 build3 (enum tree_code code
, tree tt
, tree arg0
, tree arg1
,
4811 tree arg2 MEM_STAT_DECL
)
4813 bool constant
, read_only
, side_effects
;
4816 gcc_assert (TREE_CODE_LENGTH (code
) == 3);
4817 gcc_assert (TREE_CODE_CLASS (code
) != tcc_vl_exp
);
4819 t
= make_node (code PASS_MEM_STAT
);
4824 /* As a special exception, if COND_EXPR has NULL branches, we
4825 assume that it is a gimple statement and always consider
4826 it to have side effects. */
4827 if (code
== COND_EXPR
4828 && tt
== void_type_node
4829 && arg1
== NULL_TREE
4830 && arg2
== NULL_TREE
)
4831 side_effects
= true;
4833 side_effects
= TREE_SIDE_EFFECTS (t
);
4839 if (code
== COND_EXPR
)
4840 TREE_READONLY (t
) = read_only
;
4842 TREE_SIDE_EFFECTS (t
) = side_effects
;
4843 TREE_THIS_VOLATILE (t
)
4844 = (TREE_CODE_CLASS (code
) == tcc_reference
4845 && arg0
&& TREE_THIS_VOLATILE (arg0
));
4851 build4 (enum tree_code code
, tree tt
, tree arg0
, tree arg1
,
4852 tree arg2
, tree arg3 MEM_STAT_DECL
)
4854 bool constant
, read_only
, side_effects
;
4857 gcc_assert (TREE_CODE_LENGTH (code
) == 4);
4859 t
= make_node (code PASS_MEM_STAT
);
4862 side_effects
= TREE_SIDE_EFFECTS (t
);
4869 TREE_SIDE_EFFECTS (t
) = side_effects
;
4870 TREE_THIS_VOLATILE (t
)
4871 = (TREE_CODE_CLASS (code
) == tcc_reference
4872 && arg0
&& TREE_THIS_VOLATILE (arg0
));
4878 build5 (enum tree_code code
, tree tt
, tree arg0
, tree arg1
,
4879 tree arg2
, tree arg3
, tree arg4 MEM_STAT_DECL
)
4881 bool constant
, read_only
, side_effects
;
4884 gcc_assert (TREE_CODE_LENGTH (code
) == 5);
4886 t
= make_node (code PASS_MEM_STAT
);
4889 side_effects
= TREE_SIDE_EFFECTS (t
);
4897 TREE_SIDE_EFFECTS (t
) = side_effects
;
4898 if (code
== TARGET_MEM_REF
)
4900 if (arg0
&& TREE_CODE (arg0
) == ADDR_EXPR
)
4902 tree o
= TREE_OPERAND (arg0
, 0);
4903 TREE_READONLY (t
) = TREE_READONLY (o
);
4904 TREE_THIS_VOLATILE (t
) = TREE_THIS_VOLATILE (o
);
4908 TREE_THIS_VOLATILE (t
)
4909 = (TREE_CODE_CLASS (code
) == tcc_reference
4910 && arg0
&& TREE_THIS_VOLATILE (arg0
));
4915 /* Build a simple MEM_REF tree with the sematics of a plain INDIRECT_REF
4916 on the pointer PTR. */
4919 build_simple_mem_ref_loc (location_t loc
, tree ptr
)
4921 poly_int64 offset
= 0;
4922 tree ptype
= TREE_TYPE (ptr
);
4924 /* For convenience allow addresses that collapse to a simple base
4926 if (TREE_CODE (ptr
) == ADDR_EXPR
4927 && (handled_component_p (TREE_OPERAND (ptr
, 0))
4928 || TREE_CODE (TREE_OPERAND (ptr
, 0)) == MEM_REF
))
4930 ptr
= get_addr_base_and_unit_offset (TREE_OPERAND (ptr
, 0), &offset
);
4932 if (TREE_CODE (ptr
) == MEM_REF
)
4934 offset
+= mem_ref_offset (ptr
).force_shwi ();
4935 ptr
= TREE_OPERAND (ptr
, 0);
4938 ptr
= build_fold_addr_expr (ptr
);
4939 gcc_assert (is_gimple_reg (ptr
) || is_gimple_min_invariant (ptr
));
4941 tem
= build2 (MEM_REF
, TREE_TYPE (ptype
),
4942 ptr
, build_int_cst (ptype
, offset
));
4943 SET_EXPR_LOCATION (tem
, loc
);
4947 /* Return the constant offset of a MEM_REF or TARGET_MEM_REF tree T. */
4950 mem_ref_offset (const_tree t
)
4952 return poly_offset_int::from (wi::to_poly_wide (TREE_OPERAND (t
, 1)),
4956 /* Return an invariant ADDR_EXPR of type TYPE taking the address of BASE
4957 offsetted by OFFSET units. */
4960 build_invariant_address (tree type
, tree base
, poly_int64 offset
)
4962 tree ref
= fold_build2 (MEM_REF
, TREE_TYPE (type
),
4963 build_fold_addr_expr (base
),
4964 build_int_cst (ptr_type_node
, offset
));
4965 tree addr
= build1 (ADDR_EXPR
, type
, ref
);
4966 recompute_tree_invariant_for_addr_expr (addr
);
4970 /* Similar except don't specify the TREE_TYPE
4971 and leave the TREE_SIDE_EFFECTS as 0.
4972 It is permissible for arguments to be null,
4973 or even garbage if their values do not matter. */
4976 build_nt (enum tree_code code
, ...)
4983 gcc_assert (TREE_CODE_CLASS (code
) != tcc_vl_exp
);
4987 t
= make_node (code
);
4988 length
= TREE_CODE_LENGTH (code
);
4990 for (i
= 0; i
< length
; i
++)
4991 TREE_OPERAND (t
, i
) = va_arg (p
, tree
);
4997 /* Similar to build_nt, but for creating a CALL_EXPR object with a
5001 build_nt_call_vec (tree fn
, vec
<tree
, va_gc
> *args
)
5006 ret
= build_vl_exp (CALL_EXPR
, vec_safe_length (args
) + 3);
5007 CALL_EXPR_FN (ret
) = fn
;
5008 CALL_EXPR_STATIC_CHAIN (ret
) = NULL_TREE
;
5009 FOR_EACH_VEC_SAFE_ELT (args
, ix
, t
)
5010 CALL_EXPR_ARG (ret
, ix
) = t
;
5014 /* Create a DECL_... node of code CODE, name NAME (if non-null)
5016 We do NOT enter this node in any sort of symbol table.
5018 LOC is the location of the decl.
5020 layout_decl is used to set up the decl's storage layout.
5021 Other slots are initialized to 0 or null pointers. */
5024 build_decl (location_t loc
, enum tree_code code
, tree name
,
5025 tree type MEM_STAT_DECL
)
5029 t
= make_node (code PASS_MEM_STAT
);
5030 DECL_SOURCE_LOCATION (t
) = loc
;
5032 /* if (type == error_mark_node)
5033 type = integer_type_node; */
5034 /* That is not done, deliberately, so that having error_mark_node
5035 as the type can suppress useless errors in the use of this variable. */
5037 DECL_NAME (t
) = name
;
5038 TREE_TYPE (t
) = type
;
5040 if (code
== VAR_DECL
|| code
== PARM_DECL
|| code
== RESULT_DECL
)
5046 /* Builds and returns function declaration with NAME and TYPE. */
5049 build_fn_decl (const char *name
, tree type
)
5051 tree id
= get_identifier (name
);
5052 tree decl
= build_decl (input_location
, FUNCTION_DECL
, id
, type
);
5054 DECL_EXTERNAL (decl
) = 1;
5055 TREE_PUBLIC (decl
) = 1;
5056 DECL_ARTIFICIAL (decl
) = 1;
5057 TREE_NOTHROW (decl
) = 1;
5062 vec
<tree
, va_gc
> *all_translation_units
;
5064 /* Builds a new translation-unit decl with name NAME, queues it in the
5065 global list of translation-unit decls and returns it. */
5068 build_translation_unit_decl (tree name
)
5070 tree tu
= build_decl (UNKNOWN_LOCATION
, TRANSLATION_UNIT_DECL
,
5072 TRANSLATION_UNIT_LANGUAGE (tu
) = lang_hooks
.name
;
5073 vec_safe_push (all_translation_units
, tu
);
5078 /* BLOCK nodes are used to represent the structure of binding contours
5079 and declarations, once those contours have been exited and their contents
5080 compiled. This information is used for outputting debugging info. */
5083 build_block (tree vars
, tree subblocks
, tree supercontext
, tree chain
)
5085 tree block
= make_node (BLOCK
);
5087 BLOCK_VARS (block
) = vars
;
5088 BLOCK_SUBBLOCKS (block
) = subblocks
;
5089 BLOCK_SUPERCONTEXT (block
) = supercontext
;
5090 BLOCK_CHAIN (block
) = chain
;
5095 /* Like SET_EXPR_LOCATION, but make sure the tree can have a location.
5097 LOC is the location to use in tree T. */
5100 protected_set_expr_location (tree t
, location_t loc
)
5102 if (CAN_HAVE_LOCATION_P (t
))
5103 SET_EXPR_LOCATION (t
, loc
);
5106 /* Data used when collecting DECLs and TYPEs for language data removal. */
5108 struct free_lang_data_d
5110 free_lang_data_d () : decls (100), types (100) {}
5112 /* Worklist to avoid excessive recursion. */
5113 auto_vec
<tree
> worklist
;
5115 /* Set of traversed objects. Used to avoid duplicate visits. */
5116 hash_set
<tree
> pset
;
5118 /* Array of symbols to process with free_lang_data_in_decl. */
5119 auto_vec
<tree
> decls
;
5121 /* Array of types to process with free_lang_data_in_type. */
5122 auto_vec
<tree
> types
;
5126 /* Add type or decl T to one of the list of tree nodes that need their
5127 language data removed. The lists are held inside FLD. */
5130 add_tree_to_fld_list (tree t
, struct free_lang_data_d
*fld
)
5133 fld
->decls
.safe_push (t
);
5134 else if (TYPE_P (t
))
5135 fld
->types
.safe_push (t
);
5140 /* Push tree node T into FLD->WORKLIST. */
5143 fld_worklist_push (tree t
, struct free_lang_data_d
*fld
)
5145 if (t
&& !is_lang_specific (t
) && !fld
->pset
.contains (t
))
5146 fld
->worklist
.safe_push ((t
));
5151 /* Return simplified TYPE_NAME of TYPE. */
5154 fld_simplified_type_name (tree type
)
5156 if (!TYPE_NAME (type
) || TREE_CODE (TYPE_NAME (type
)) != TYPE_DECL
)
5157 return TYPE_NAME (type
);
5158 /* Drop TYPE_DECLs in TYPE_NAME in favor of the identifier in the
5159 TYPE_DECL if the type doesn't have linkage.
5160 this must match fld_ */
5161 if (type
!= TYPE_MAIN_VARIANT (type
)
5162 || (!DECL_ASSEMBLER_NAME_SET_P (TYPE_NAME (type
))
5163 && (TREE_CODE (type
) != RECORD_TYPE
5164 || !TYPE_BINFO (type
)
5165 || !BINFO_VTABLE (TYPE_BINFO (type
)))))
5166 return DECL_NAME (TYPE_NAME (type
));
5167 return TYPE_NAME (type
);
5170 /* Do same comparsion as check_qualified_type skipping lang part of type
5171 and be more permissive about type names: we only care that names are
5172 same (for diagnostics) and that ODR names are the same.
5173 If INNER_TYPE is non-NULL, be sure that TREE_TYPE match it. */
5176 fld_type_variant_equal_p (tree t
, tree v
, tree inner_type
)
5178 if (TYPE_QUALS (t
) != TYPE_QUALS (v
)
5179 /* We want to match incomplete variants with complete types.
5180 In this case we need to ignore alignment. */
5181 || ((!RECORD_OR_UNION_TYPE_P (t
) || COMPLETE_TYPE_P (v
))
5182 && (TYPE_ALIGN (t
) != TYPE_ALIGN (v
)
5183 || TYPE_USER_ALIGN (t
) != TYPE_USER_ALIGN (v
)))
5184 || fld_simplified_type_name (t
) != fld_simplified_type_name (v
)
5185 || !attribute_list_equal (TYPE_ATTRIBUTES (t
),
5186 TYPE_ATTRIBUTES (v
))
5187 || (inner_type
&& TREE_TYPE (v
) != inner_type
))
5193 /* Find variant of FIRST that match T and create new one if necessary.
5194 Set TREE_TYPE to INNER_TYPE if non-NULL. */
5197 fld_type_variant (tree first
, tree t
, struct free_lang_data_d
*fld
,
5198 tree inner_type
= NULL
)
5200 if (first
== TYPE_MAIN_VARIANT (t
))
5202 for (tree v
= first
; v
; v
= TYPE_NEXT_VARIANT (v
))
5203 if (fld_type_variant_equal_p (t
, v
, inner_type
))
5205 tree v
= build_variant_type_copy (first
);
5206 TYPE_READONLY (v
) = TYPE_READONLY (t
);
5207 TYPE_VOLATILE (v
) = TYPE_VOLATILE (t
);
5208 TYPE_ATOMIC (v
) = TYPE_ATOMIC (t
);
5209 TYPE_RESTRICT (v
) = TYPE_RESTRICT (t
);
5210 TYPE_ADDR_SPACE (v
) = TYPE_ADDR_SPACE (t
);
5211 TYPE_NAME (v
) = TYPE_NAME (t
);
5212 TYPE_ATTRIBUTES (v
) = TYPE_ATTRIBUTES (t
);
5213 TYPE_CANONICAL (v
) = TYPE_CANONICAL (t
);
5214 /* Variants of incomplete types should have alignment
5215 set to BITS_PER_UNIT. Do not copy the actual alignment. */
5216 if (!RECORD_OR_UNION_TYPE_P (v
) || COMPLETE_TYPE_P (v
))
5218 SET_TYPE_ALIGN (v
, TYPE_ALIGN (t
));
5219 TYPE_USER_ALIGN (v
) = TYPE_USER_ALIGN (t
);
5222 TREE_TYPE (v
) = inner_type
;
5223 gcc_checking_assert (fld_type_variant_equal_p (t
,v
, inner_type
));
5224 if (!fld
->pset
.add (v
))
5225 add_tree_to_fld_list (v
, fld
);
5229 /* Map complete types to incomplete types. */
5231 static hash_map
<tree
, tree
> *fld_incomplete_types
;
5233 /* Map types to simplified types. */
5235 static hash_map
<tree
, tree
> *fld_simplified_types
;
5237 /* Produce variant of T whose TREE_TYPE is T2. If it is main variant,
5238 use MAP to prevent duplicates. */
5241 fld_process_array_type (tree t
, tree t2
, hash_map
<tree
, tree
> *map
,
5242 struct free_lang_data_d
*fld
)
5244 if (TREE_TYPE (t
) == t2
)
5247 if (TYPE_MAIN_VARIANT (t
) != t
)
5249 return fld_type_variant
5250 (fld_process_array_type (TYPE_MAIN_VARIANT (t
),
5251 TYPE_MAIN_VARIANT (t2
), map
, fld
),
5257 = map
->get_or_insert (t
, &existed
);
5260 array
= build_array_type_1 (t2
, TYPE_DOMAIN (t
),
5261 TYPE_TYPELESS_STORAGE (t
), false);
5262 TYPE_CANONICAL (array
) = TYPE_CANONICAL (t
);
5263 if (!fld
->pset
.add (array
))
5264 add_tree_to_fld_list (array
, fld
);
5269 /* Return CTX after removal of contexts that are not relevant */
5272 fld_decl_context (tree ctx
)
5274 /* Variably modified types are needed for tree_is_indexable to decide
5275 whether the type needs to go to local or global section.
5276 This code is semi-broken but for now it is easiest to keep contexts
5278 if (ctx
&& TYPE_P (ctx
)
5279 && !variably_modified_type_p (ctx
, NULL_TREE
))
5281 while (ctx
&& TYPE_P (ctx
))
5282 ctx
= TYPE_CONTEXT (ctx
);
5287 /* For T being aggregate type try to turn it into a incomplete variant.
5288 Return T if no simplification is possible. */
5291 fld_incomplete_type_of (tree t
, struct free_lang_data_d
*fld
)
5295 if (POINTER_TYPE_P (t
))
5297 tree t2
= fld_incomplete_type_of (TREE_TYPE (t
), fld
);
5298 if (t2
!= TREE_TYPE (t
))
5301 if (TREE_CODE (t
) == POINTER_TYPE
)
5302 first
= build_pointer_type_for_mode (t2
, TYPE_MODE (t
),
5303 TYPE_REF_CAN_ALIAS_ALL (t
));
5305 first
= build_reference_type_for_mode (t2
, TYPE_MODE (t
),
5306 TYPE_REF_CAN_ALIAS_ALL (t
));
5307 gcc_assert (TYPE_CANONICAL (t2
) != t2
5308 && TYPE_CANONICAL (t2
) == TYPE_CANONICAL (TREE_TYPE (t
)));
5309 if (!fld
->pset
.add (first
))
5310 add_tree_to_fld_list (first
, fld
);
5311 return fld_type_variant (first
, t
, fld
);
5315 if (TREE_CODE (t
) == ARRAY_TYPE
)
5316 return fld_process_array_type (t
,
5317 fld_incomplete_type_of (TREE_TYPE (t
), fld
),
5318 fld_incomplete_types
, fld
);
5319 if ((!RECORD_OR_UNION_TYPE_P (t
) && TREE_CODE (t
) != ENUMERAL_TYPE
)
5320 || !COMPLETE_TYPE_P (t
))
5322 if (TYPE_MAIN_VARIANT (t
) == t
)
5326 = fld_incomplete_types
->get_or_insert (t
, &existed
);
5330 copy
= build_distinct_type_copy (t
);
5332 /* It is possible that type was not seen by free_lang_data yet. */
5333 if (!fld
->pset
.add (copy
))
5334 add_tree_to_fld_list (copy
, fld
);
5335 TYPE_SIZE (copy
) = NULL
;
5336 TYPE_USER_ALIGN (copy
) = 0;
5337 TYPE_SIZE_UNIT (copy
) = NULL
;
5338 TYPE_CANONICAL (copy
) = TYPE_CANONICAL (t
);
5339 TREE_ADDRESSABLE (copy
) = 0;
5340 if (AGGREGATE_TYPE_P (t
))
5342 SET_TYPE_MODE (copy
, VOIDmode
);
5343 SET_TYPE_ALIGN (copy
, BITS_PER_UNIT
);
5344 TYPE_TYPELESS_STORAGE (copy
) = 0;
5345 TYPE_FIELDS (copy
) = NULL
;
5346 TYPE_BINFO (copy
) = NULL
;
5349 TYPE_VALUES (copy
) = NULL
;
5351 /* Build copy of TYPE_DECL in TYPE_NAME if necessary.
5352 This is needed for ODR violation warnings to come out right (we
5353 want duplicate TYPE_DECLs whenever the type is duplicated because
5354 of ODR violation. Because lang data in the TYPE_DECL may not
5355 have been freed yet, rebuild it from scratch and copy relevant
5357 TYPE_NAME (copy
) = fld_simplified_type_name (copy
);
5358 tree name
= TYPE_NAME (copy
);
5360 if (name
&& TREE_CODE (name
) == TYPE_DECL
)
5362 gcc_checking_assert (TREE_TYPE (name
) == t
);
5363 tree name2
= build_decl (DECL_SOURCE_LOCATION (name
), TYPE_DECL
,
5364 DECL_NAME (name
), copy
);
5365 if (DECL_ASSEMBLER_NAME_SET_P (name
))
5366 SET_DECL_ASSEMBLER_NAME (name2
, DECL_ASSEMBLER_NAME (name
));
5367 SET_DECL_ALIGN (name2
, 0);
5368 DECL_CONTEXT (name2
) = fld_decl_context
5369 (DECL_CONTEXT (name
));
5370 TYPE_NAME (copy
) = name2
;
5375 return (fld_type_variant
5376 (fld_incomplete_type_of (TYPE_MAIN_VARIANT (t
), fld
), t
, fld
));
5379 /* Simplify type T for scenarios where we do not need complete pointer
5383 fld_simplified_type (tree t
, struct free_lang_data_d
*fld
)
5387 if (POINTER_TYPE_P (t
))
5388 return fld_incomplete_type_of (t
, fld
);
5389 /* FIXME: This triggers verification error, see PR88140. */
5390 if (TREE_CODE (t
) == ARRAY_TYPE
&& 0)
5391 return fld_process_array_type (t
, fld_simplified_type (TREE_TYPE (t
), fld
),
5392 fld_simplified_types
, fld
);
5396 /* Reset the expression *EXPR_P, a size or position.
5398 ??? We could reset all non-constant sizes or positions. But it's cheap
5399 enough to not do so and refrain from adding workarounds to dwarf2out.c.
5401 We need to reset self-referential sizes or positions because they cannot
5402 be gimplified and thus can contain a CALL_EXPR after the gimplification
5403 is finished, which will run afoul of LTO streaming. And they need to be
5404 reset to something essentially dummy but not constant, so as to preserve
5405 the properties of the object they are attached to. */
5408 free_lang_data_in_one_sizepos (tree
*expr_p
)
5410 tree expr
= *expr_p
;
5411 if (CONTAINS_PLACEHOLDER_P (expr
))
5412 *expr_p
= build0 (PLACEHOLDER_EXPR
, TREE_TYPE (expr
));
5416 /* Reset all the fields in a binfo node BINFO. We only keep
5417 BINFO_VTABLE, which is used by gimple_fold_obj_type_ref. */
5420 free_lang_data_in_binfo (tree binfo
)
5425 gcc_assert (TREE_CODE (binfo
) == TREE_BINFO
);
5427 BINFO_VIRTUALS (binfo
) = NULL_TREE
;
5428 BINFO_BASE_ACCESSES (binfo
) = NULL
;
5429 BINFO_INHERITANCE_CHAIN (binfo
) = NULL_TREE
;
5430 BINFO_SUBVTT_INDEX (binfo
) = NULL_TREE
;
5431 BINFO_VPTR_FIELD (binfo
) = NULL_TREE
;
5433 FOR_EACH_VEC_ELT (*BINFO_BASE_BINFOS (binfo
), i
, t
)
5434 free_lang_data_in_binfo (t
);
5438 /* Reset all language specific information still present in TYPE. */
5441 free_lang_data_in_type (tree type
, struct free_lang_data_d
*fld
)
5443 gcc_assert (TYPE_P (type
));
5445 /* Give the FE a chance to remove its own data first. */
5446 lang_hooks
.free_lang_data (type
);
5448 TREE_LANG_FLAG_0 (type
) = 0;
5449 TREE_LANG_FLAG_1 (type
) = 0;
5450 TREE_LANG_FLAG_2 (type
) = 0;
5451 TREE_LANG_FLAG_3 (type
) = 0;
5452 TREE_LANG_FLAG_4 (type
) = 0;
5453 TREE_LANG_FLAG_5 (type
) = 0;
5454 TREE_LANG_FLAG_6 (type
) = 0;
5456 TYPE_NEEDS_CONSTRUCTING (type
) = 0;
5458 /* Purge non-marked variants from the variants chain, so that they
5459 don't reappear in the IL after free_lang_data. */
5460 while (TYPE_NEXT_VARIANT (type
)
5461 && !fld
->pset
.contains (TYPE_NEXT_VARIANT (type
)))
5463 tree t
= TYPE_NEXT_VARIANT (type
);
5464 TYPE_NEXT_VARIANT (type
) = TYPE_NEXT_VARIANT (t
);
5465 /* Turn the removed types into distinct types. */
5466 TYPE_MAIN_VARIANT (t
) = t
;
5467 TYPE_NEXT_VARIANT (t
) = NULL_TREE
;
5470 if (TREE_CODE (type
) == FUNCTION_TYPE
)
5472 TREE_TYPE (type
) = fld_simplified_type (TREE_TYPE (type
), fld
);
5473 /* Remove the const and volatile qualifiers from arguments. The
5474 C++ front end removes them, but the C front end does not,
5475 leading to false ODR violation errors when merging two
5476 instances of the same function signature compiled by
5477 different front ends. */
5478 for (tree p
= TYPE_ARG_TYPES (type
); p
; p
= TREE_CHAIN (p
))
5480 TREE_VALUE (p
) = fld_simplified_type (TREE_VALUE (p
), fld
);
5481 tree arg_type
= TREE_VALUE (p
);
5483 if (TYPE_READONLY (arg_type
) || TYPE_VOLATILE (arg_type
))
5485 int quals
= TYPE_QUALS (arg_type
)
5487 & ~TYPE_QUAL_VOLATILE
;
5488 TREE_VALUE (p
) = build_qualified_type (arg_type
, quals
);
5489 if (!fld
->pset
.add (TREE_VALUE (p
)))
5490 free_lang_data_in_type (TREE_VALUE (p
), fld
);
5492 /* C++ FE uses TREE_PURPOSE to store initial values. */
5493 TREE_PURPOSE (p
) = NULL
;
5496 else if (TREE_CODE (type
) == METHOD_TYPE
)
5498 TREE_TYPE (type
) = fld_simplified_type (TREE_TYPE (type
), fld
);
5499 for (tree p
= TYPE_ARG_TYPES (type
); p
; p
= TREE_CHAIN (p
))
5501 /* C++ FE uses TREE_PURPOSE to store initial values. */
5502 TREE_VALUE (p
) = fld_simplified_type (TREE_VALUE (p
), fld
);
5503 TREE_PURPOSE (p
) = NULL
;
5506 else if (RECORD_OR_UNION_TYPE_P (type
))
5508 /* Remove members that are not FIELD_DECLs from the field list
5509 of an aggregate. These occur in C++. */
5510 for (tree
*prev
= &TYPE_FIELDS (type
), member
; (member
= *prev
);)
5511 if (TREE_CODE (member
) == FIELD_DECL
)
5512 prev
= &DECL_CHAIN (member
);
5514 *prev
= DECL_CHAIN (member
);
5516 TYPE_VFIELD (type
) = NULL_TREE
;
5518 if (TYPE_BINFO (type
))
5520 free_lang_data_in_binfo (TYPE_BINFO (type
));
5521 /* We need to preserve link to bases and virtual table for all
5522 polymorphic types to make devirtualization machinery working. */
5523 if (!BINFO_VTABLE (TYPE_BINFO (type
))
5524 || !flag_devirtualize
)
5525 TYPE_BINFO (type
) = NULL
;
5528 else if (INTEGRAL_TYPE_P (type
)
5529 || SCALAR_FLOAT_TYPE_P (type
)
5530 || FIXED_POINT_TYPE_P (type
))
5532 if (TREE_CODE (type
) == ENUMERAL_TYPE
)
5534 /* Type values are used only for C++ ODR checking. Drop them
5535 for all type variants and non-ODR types.
5536 For ODR types the data is freed in free_odr_warning_data. */
5537 if (TYPE_MAIN_VARIANT (type
) != type
5538 || !type_with_linkage_p (type
))
5539 TYPE_VALUES (type
) = NULL
;
5541 /* Simplify representation by recording only values rather
5542 than const decls. */
5543 for (tree e
= TYPE_VALUES (type
); e
; e
= TREE_CHAIN (e
))
5544 if (TREE_CODE (TREE_VALUE (e
)) == CONST_DECL
)
5545 TREE_VALUE (e
) = DECL_INITIAL (TREE_VALUE (e
));
5547 free_lang_data_in_one_sizepos (&TYPE_MIN_VALUE (type
));
5548 free_lang_data_in_one_sizepos (&TYPE_MAX_VALUE (type
));
5551 TYPE_LANG_SLOT_1 (type
) = NULL_TREE
;
5553 free_lang_data_in_one_sizepos (&TYPE_SIZE (type
));
5554 free_lang_data_in_one_sizepos (&TYPE_SIZE_UNIT (type
));
5556 if (TYPE_CONTEXT (type
)
5557 && TREE_CODE (TYPE_CONTEXT (type
)) == BLOCK
)
5559 tree ctx
= TYPE_CONTEXT (type
);
5562 ctx
= BLOCK_SUPERCONTEXT (ctx
);
5564 while (ctx
&& TREE_CODE (ctx
) == BLOCK
);
5565 TYPE_CONTEXT (type
) = ctx
;
5568 TYPE_STUB_DECL (type
) = NULL
;
5569 TYPE_NAME (type
) = fld_simplified_type_name (type
);
5573 /* Return true if DECL may need an assembler name to be set. */
5576 need_assembler_name_p (tree decl
)
5578 /* We use DECL_ASSEMBLER_NAME to hold mangled type names for One Definition
5579 Rule merging. This makes type_odr_p to return true on those types during
5580 LTO and by comparing the mangled name, we can say what types are intended
5581 to be equivalent across compilation unit.
5583 We do not store names of type_in_anonymous_namespace_p.
5585 Record, union and enumeration type have linkage that allows use
5586 to check type_in_anonymous_namespace_p. We do not mangle compound types
5587 that always can be compared structurally.
5589 Similarly for builtin types, we compare properties of their main variant.
5590 A special case are integer types where mangling do make differences
5591 between char/signed char/unsigned char etc. Storing name for these makes
5592 e.g. -fno-signed-char/-fsigned-char mismatches to be handled well.
5593 See cp/mangle.c:write_builtin_type for details. */
5595 if (TREE_CODE (decl
) == TYPE_DECL
)
5597 if (DECL_NAME (decl
)
5598 && decl
== TYPE_NAME (TREE_TYPE (decl
))
5599 && TYPE_MAIN_VARIANT (TREE_TYPE (decl
)) == TREE_TYPE (decl
)
5600 && !TYPE_ARTIFICIAL (TREE_TYPE (decl
))
5601 && ((TREE_CODE (TREE_TYPE (decl
)) != RECORD_TYPE
5602 && TREE_CODE (TREE_TYPE (decl
)) != UNION_TYPE
)
5603 || TYPE_CXX_ODR_P (TREE_TYPE (decl
)))
5604 && (type_with_linkage_p (TREE_TYPE (decl
))
5605 || TREE_CODE (TREE_TYPE (decl
)) == INTEGER_TYPE
)
5606 && !variably_modified_type_p (TREE_TYPE (decl
), NULL_TREE
))
5607 return !DECL_ASSEMBLER_NAME_SET_P (decl
);
5610 /* Only FUNCTION_DECLs and VAR_DECLs are considered. */
5611 if (!VAR_OR_FUNCTION_DECL_P (decl
))
5614 /* If DECL already has its assembler name set, it does not need a
5616 if (!HAS_DECL_ASSEMBLER_NAME_P (decl
)
5617 || DECL_ASSEMBLER_NAME_SET_P (decl
))
5620 /* Abstract decls do not need an assembler name. */
5621 if (DECL_ABSTRACT_P (decl
))
5624 /* For VAR_DECLs, only static, public and external symbols need an
5627 && !TREE_STATIC (decl
)
5628 && !TREE_PUBLIC (decl
)
5629 && !DECL_EXTERNAL (decl
))
5632 if (TREE_CODE (decl
) == FUNCTION_DECL
)
5634 /* Do not set assembler name on builtins. Allow RTL expansion to
5635 decide whether to expand inline or via a regular call. */
5636 if (fndecl_built_in_p (decl
)
5637 && DECL_BUILT_IN_CLASS (decl
) != BUILT_IN_FRONTEND
)
5640 /* Functions represented in the callgraph need an assembler name. */
5641 if (cgraph_node::get (decl
) != NULL
)
5644 /* Unused and not public functions don't need an assembler name. */
5645 if (!TREE_USED (decl
) && !TREE_PUBLIC (decl
))
5653 /* Reset all language specific information still present in symbol
5657 free_lang_data_in_decl (tree decl
, struct free_lang_data_d
*fld
)
5659 gcc_assert (DECL_P (decl
));
5661 /* Give the FE a chance to remove its own data first. */
5662 lang_hooks
.free_lang_data (decl
);
5664 TREE_LANG_FLAG_0 (decl
) = 0;
5665 TREE_LANG_FLAG_1 (decl
) = 0;
5666 TREE_LANG_FLAG_2 (decl
) = 0;
5667 TREE_LANG_FLAG_3 (decl
) = 0;
5668 TREE_LANG_FLAG_4 (decl
) = 0;
5669 TREE_LANG_FLAG_5 (decl
) = 0;
5670 TREE_LANG_FLAG_6 (decl
) = 0;
5672 free_lang_data_in_one_sizepos (&DECL_SIZE (decl
));
5673 free_lang_data_in_one_sizepos (&DECL_SIZE_UNIT (decl
));
5674 if (TREE_CODE (decl
) == FIELD_DECL
)
5676 DECL_FCONTEXT (decl
) = NULL
;
5677 free_lang_data_in_one_sizepos (&DECL_FIELD_OFFSET (decl
));
5678 if (TREE_CODE (DECL_CONTEXT (decl
)) == QUAL_UNION_TYPE
)
5679 DECL_QUALIFIER (decl
) = NULL_TREE
;
5682 if (TREE_CODE (decl
) == FUNCTION_DECL
)
5684 struct cgraph_node
*node
;
5685 /* Frontends do not set TREE_ADDRESSABLE on public variables even though
5686 the address may be taken in other unit, so this flag has no practical
5689 It would make more sense if frontends set TREE_ADDRESSABLE to 0 only
5690 for public objects that indeed cannot be adressed, but it is not
5691 the case. Set the flag to true so we do not get merge failures for
5692 i.e. virtual tables between units that take address of it and
5693 units that don't. */
5694 if (TREE_PUBLIC (decl
))
5695 TREE_ADDRESSABLE (decl
) = true;
5696 TREE_TYPE (decl
) = fld_simplified_type (TREE_TYPE (decl
), fld
);
5697 if (!(node
= cgraph_node::get (decl
))
5698 || (!node
->definition
&& !node
->clones
))
5701 node
->release_body ();
5704 release_function_body (decl
);
5705 DECL_ARGUMENTS (decl
) = NULL
;
5706 DECL_RESULT (decl
) = NULL
;
5707 DECL_INITIAL (decl
) = error_mark_node
;
5710 if (gimple_has_body_p (decl
) || (node
&& node
->thunk
.thunk_p
))
5714 /* If DECL has a gimple body, then the context for its
5715 arguments must be DECL. Otherwise, it doesn't really
5716 matter, as we will not be emitting any code for DECL. In
5717 general, there may be other instances of DECL created by
5718 the front end and since PARM_DECLs are generally shared,
5719 their DECL_CONTEXT changes as the replicas of DECL are
5720 created. The only time where DECL_CONTEXT is important
5721 is for the FUNCTION_DECLs that have a gimple body (since
5722 the PARM_DECL will be used in the function's body). */
5723 for (t
= DECL_ARGUMENTS (decl
); t
; t
= TREE_CHAIN (t
))
5724 DECL_CONTEXT (t
) = decl
;
5725 if (!DECL_FUNCTION_SPECIFIC_TARGET (decl
))
5726 DECL_FUNCTION_SPECIFIC_TARGET (decl
)
5727 = target_option_default_node
;
5728 if (!DECL_FUNCTION_SPECIFIC_OPTIMIZATION (decl
))
5729 DECL_FUNCTION_SPECIFIC_OPTIMIZATION (decl
)
5730 = optimization_default_node
;
5733 /* DECL_SAVED_TREE holds the GENERIC representation for DECL.
5734 At this point, it is not needed anymore. */
5735 DECL_SAVED_TREE (decl
) = NULL_TREE
;
5737 /* Clear the abstract origin if it refers to a method.
5738 Otherwise dwarf2out.c will ICE as we splice functions out of
5739 TYPE_FIELDS and thus the origin will not be output
5741 if (DECL_ABSTRACT_ORIGIN (decl
)
5742 && DECL_CONTEXT (DECL_ABSTRACT_ORIGIN (decl
))
5743 && RECORD_OR_UNION_TYPE_P
5744 (DECL_CONTEXT (DECL_ABSTRACT_ORIGIN (decl
))))
5745 DECL_ABSTRACT_ORIGIN (decl
) = NULL_TREE
;
5747 DECL_VINDEX (decl
) = NULL_TREE
;
5749 else if (VAR_P (decl
))
5751 /* See comment above why we set the flag for functoins. */
5752 if (TREE_PUBLIC (decl
))
5753 TREE_ADDRESSABLE (decl
) = true;
5754 if ((DECL_EXTERNAL (decl
)
5755 && (!TREE_STATIC (decl
) || !TREE_READONLY (decl
)))
5756 || (decl_function_context (decl
) && !TREE_STATIC (decl
)))
5757 DECL_INITIAL (decl
) = NULL_TREE
;
5759 else if (TREE_CODE (decl
) == TYPE_DECL
)
5761 DECL_VISIBILITY (decl
) = VISIBILITY_DEFAULT
;
5762 DECL_VISIBILITY_SPECIFIED (decl
) = 0;
5763 TREE_PUBLIC (decl
) = 0;
5764 TREE_PRIVATE (decl
) = 0;
5765 DECL_ARTIFICIAL (decl
) = 0;
5766 TYPE_DECL_SUPPRESS_DEBUG (decl
) = 0;
5767 DECL_INITIAL (decl
) = NULL_TREE
;
5768 DECL_ORIGINAL_TYPE (decl
) = NULL_TREE
;
5769 DECL_MODE (decl
) = VOIDmode
;
5770 SET_DECL_ALIGN (decl
, 0);
5771 /* TREE_TYPE is cleared at WPA time in free_odr_warning_data. */
5773 else if (TREE_CODE (decl
) == FIELD_DECL
)
5775 TREE_TYPE (decl
) = fld_simplified_type (TREE_TYPE (decl
), fld
);
5776 DECL_INITIAL (decl
) = NULL_TREE
;
5778 else if (TREE_CODE (decl
) == TRANSLATION_UNIT_DECL
5779 && DECL_INITIAL (decl
)
5780 && TREE_CODE (DECL_INITIAL (decl
)) == BLOCK
)
5782 /* Strip builtins from the translation-unit BLOCK. We still have targets
5783 without builtin_decl_explicit support and also builtins are shared
5784 nodes and thus we can't use TREE_CHAIN in multiple lists. */
5785 tree
*nextp
= &BLOCK_VARS (DECL_INITIAL (decl
));
5789 if (fndecl_built_in_p (var
))
5790 *nextp
= TREE_CHAIN (var
);
5792 nextp
= &TREE_CHAIN (var
);
5795 /* We need to keep field decls associated with their trees. Otherwise tree
5796 merging may merge some fileds and keep others disjoint wich in turn will
5797 not do well with TREE_CHAIN pointers linking them.
5799 Also do not drop containing types for virtual methods and tables because
5800 these are needed by devirtualization.
5801 C++ destructors are special because C++ frontends sometimes produces
5802 virtual destructor as an alias of non-virtual destructor. In
5803 devirutalization code we always walk through aliases and we need
5804 context to be preserved too. See PR89335 */
5805 if (TREE_CODE (decl
) != FIELD_DECL
5806 && ((TREE_CODE (decl
) != VAR_DECL
&& TREE_CODE (decl
) != FUNCTION_DECL
)
5807 || (!DECL_VIRTUAL_P (decl
)
5808 && (TREE_CODE (decl
) != FUNCTION_DECL
5809 || !DECL_CXX_DESTRUCTOR_P (decl
)))))
5810 DECL_CONTEXT (decl
) = fld_decl_context (DECL_CONTEXT (decl
));
5814 /* Operand callback helper for free_lang_data_in_node. *TP is the
5815 subtree operand being considered. */
5818 find_decls_types_r (tree
*tp
, int *ws
, void *data
)
5821 struct free_lang_data_d
*fld
= (struct free_lang_data_d
*) data
;
5823 if (TREE_CODE (t
) == TREE_LIST
)
5826 /* Language specific nodes will be removed, so there is no need
5827 to gather anything under them. */
5828 if (is_lang_specific (t
))
5836 /* Note that walk_tree does not traverse every possible field in
5837 decls, so we have to do our own traversals here. */
5838 add_tree_to_fld_list (t
, fld
);
5840 fld_worklist_push (DECL_NAME (t
), fld
);
5841 fld_worklist_push (DECL_CONTEXT (t
), fld
);
5842 fld_worklist_push (DECL_SIZE (t
), fld
);
5843 fld_worklist_push (DECL_SIZE_UNIT (t
), fld
);
5845 /* We are going to remove everything under DECL_INITIAL for
5846 TYPE_DECLs. No point walking them. */
5847 if (TREE_CODE (t
) != TYPE_DECL
)
5848 fld_worklist_push (DECL_INITIAL (t
), fld
);
5850 fld_worklist_push (DECL_ATTRIBUTES (t
), fld
);
5851 fld_worklist_push (DECL_ABSTRACT_ORIGIN (t
), fld
);
5853 if (TREE_CODE (t
) == FUNCTION_DECL
)
5855 fld_worklist_push (DECL_ARGUMENTS (t
), fld
);
5856 fld_worklist_push (DECL_RESULT (t
), fld
);
5858 else if (TREE_CODE (t
) == FIELD_DECL
)
5860 fld_worklist_push (DECL_FIELD_OFFSET (t
), fld
);
5861 fld_worklist_push (DECL_BIT_FIELD_TYPE (t
), fld
);
5862 fld_worklist_push (DECL_FIELD_BIT_OFFSET (t
), fld
);
5863 fld_worklist_push (DECL_FCONTEXT (t
), fld
);
5866 if ((VAR_P (t
) || TREE_CODE (t
) == PARM_DECL
)
5867 && DECL_HAS_VALUE_EXPR_P (t
))
5868 fld_worklist_push (DECL_VALUE_EXPR (t
), fld
);
5870 if (TREE_CODE (t
) != FIELD_DECL
5871 && TREE_CODE (t
) != TYPE_DECL
)
5872 fld_worklist_push (TREE_CHAIN (t
), fld
);
5875 else if (TYPE_P (t
))
5877 /* Note that walk_tree does not traverse every possible field in
5878 types, so we have to do our own traversals here. */
5879 add_tree_to_fld_list (t
, fld
);
5881 if (!RECORD_OR_UNION_TYPE_P (t
))
5882 fld_worklist_push (TYPE_CACHED_VALUES (t
), fld
);
5883 fld_worklist_push (TYPE_SIZE (t
), fld
);
5884 fld_worklist_push (TYPE_SIZE_UNIT (t
), fld
);
5885 fld_worklist_push (TYPE_ATTRIBUTES (t
), fld
);
5886 fld_worklist_push (TYPE_POINTER_TO (t
), fld
);
5887 fld_worklist_push (TYPE_REFERENCE_TO (t
), fld
);
5888 fld_worklist_push (TYPE_NAME (t
), fld
);
5889 /* While we do not stream TYPE_POINTER_TO and TYPE_REFERENCE_TO
5890 lists, we may look types up in these lists and use them while
5891 optimizing the function body. Thus we need to free lang data
5893 if (TREE_CODE (t
) == POINTER_TYPE
)
5894 fld_worklist_push (TYPE_NEXT_PTR_TO (t
), fld
);
5895 if (TREE_CODE (t
) == REFERENCE_TYPE
)
5896 fld_worklist_push (TYPE_NEXT_REF_TO (t
), fld
);
5897 if (!POINTER_TYPE_P (t
))
5898 fld_worklist_push (TYPE_MIN_VALUE_RAW (t
), fld
);
5899 /* TYPE_MAX_VALUE_RAW is TYPE_BINFO for record types. */
5900 if (!RECORD_OR_UNION_TYPE_P (t
))
5901 fld_worklist_push (TYPE_MAX_VALUE_RAW (t
), fld
);
5902 fld_worklist_push (TYPE_MAIN_VARIANT (t
), fld
);
5903 /* Do not walk TYPE_NEXT_VARIANT. We do not stream it and thus
5904 do not and want not to reach unused variants this way. */
5905 if (TYPE_CONTEXT (t
))
5907 tree ctx
= TYPE_CONTEXT (t
);
5908 /* We adjust BLOCK TYPE_CONTEXTs to the innermost non-BLOCK one.
5909 So push that instead. */
5910 while (ctx
&& TREE_CODE (ctx
) == BLOCK
)
5911 ctx
= BLOCK_SUPERCONTEXT (ctx
);
5912 fld_worklist_push (ctx
, fld
);
5914 fld_worklist_push (TYPE_CANONICAL (t
), fld
);
5916 if (RECORD_OR_UNION_TYPE_P (t
) && TYPE_BINFO (t
))
5920 FOR_EACH_VEC_ELT (*BINFO_BASE_BINFOS (TYPE_BINFO (t
)), i
, tem
)
5921 fld_worklist_push (TREE_TYPE (tem
), fld
);
5922 fld_worklist_push (BINFO_TYPE (TYPE_BINFO (t
)), fld
);
5923 fld_worklist_push (BINFO_VTABLE (TYPE_BINFO (t
)), fld
);
5925 if (RECORD_OR_UNION_TYPE_P (t
))
5928 /* Push all TYPE_FIELDS - there can be interleaving interesting
5929 and non-interesting things. */
5930 tem
= TYPE_FIELDS (t
);
5933 if (TREE_CODE (tem
) == FIELD_DECL
)
5934 fld_worklist_push (tem
, fld
);
5935 tem
= TREE_CHAIN (tem
);
5938 if (FUNC_OR_METHOD_TYPE_P (t
))
5939 fld_worklist_push (TYPE_METHOD_BASETYPE (t
), fld
);
5941 fld_worklist_push (TYPE_STUB_DECL (t
), fld
);
5944 else if (TREE_CODE (t
) == BLOCK
)
5946 for (tree
*tem
= &BLOCK_VARS (t
); *tem
; )
5948 if (TREE_CODE (*tem
) != VAR_DECL
5949 || !auto_var_in_fn_p (*tem
, DECL_CONTEXT (*tem
)))
5951 gcc_assert (TREE_CODE (*tem
) != RESULT_DECL
5952 && TREE_CODE (*tem
) != PARM_DECL
);
5953 *tem
= TREE_CHAIN (*tem
);
5957 fld_worklist_push (*tem
, fld
);
5958 tem
= &TREE_CHAIN (*tem
);
5961 for (tree tem
= BLOCK_SUBBLOCKS (t
); tem
; tem
= BLOCK_CHAIN (tem
))
5962 fld_worklist_push (tem
, fld
);
5963 fld_worklist_push (BLOCK_ABSTRACT_ORIGIN (t
), fld
);
5966 if (TREE_CODE (t
) != IDENTIFIER_NODE
5967 && CODE_CONTAINS_STRUCT (TREE_CODE (t
), TS_TYPED
))
5968 fld_worklist_push (TREE_TYPE (t
), fld
);
5974 /* Find decls and types in T. */
5977 find_decls_types (tree t
, struct free_lang_data_d
*fld
)
5981 if (!fld
->pset
.contains (t
))
5982 walk_tree (&t
, find_decls_types_r
, fld
, &fld
->pset
);
5983 if (fld
->worklist
.is_empty ())
5985 t
= fld
->worklist
.pop ();
5989 /* Translate all the types in LIST with the corresponding runtime
5993 get_eh_types_for_runtime (tree list
)
5997 if (list
== NULL_TREE
)
6000 head
= build_tree_list (0, lookup_type_for_runtime (TREE_VALUE (list
)));
6002 list
= TREE_CHAIN (list
);
6005 tree n
= build_tree_list (0, lookup_type_for_runtime (TREE_VALUE (list
)));
6006 TREE_CHAIN (prev
) = n
;
6007 prev
= TREE_CHAIN (prev
);
6008 list
= TREE_CHAIN (list
);
6015 /* Find decls and types referenced in EH region R and store them in
6016 FLD->DECLS and FLD->TYPES. */
6019 find_decls_types_in_eh_region (eh_region r
, struct free_lang_data_d
*fld
)
6030 /* The types referenced in each catch must first be changed to the
6031 EH types used at runtime. This removes references to FE types
6033 for (c
= r
->u
.eh_try
.first_catch
; c
; c
= c
->next_catch
)
6035 c
->type_list
= get_eh_types_for_runtime (c
->type_list
);
6036 walk_tree (&c
->type_list
, find_decls_types_r
, fld
, &fld
->pset
);
6041 case ERT_ALLOWED_EXCEPTIONS
:
6042 r
->u
.allowed
.type_list
6043 = get_eh_types_for_runtime (r
->u
.allowed
.type_list
);
6044 walk_tree (&r
->u
.allowed
.type_list
, find_decls_types_r
, fld
, &fld
->pset
);
6047 case ERT_MUST_NOT_THROW
:
6048 walk_tree (&r
->u
.must_not_throw
.failure_decl
,
6049 find_decls_types_r
, fld
, &fld
->pset
);
6055 /* Find decls and types referenced in cgraph node N and store them in
6056 FLD->DECLS and FLD->TYPES. Unlike pass_referenced_vars, this will
6057 look for *every* kind of DECL and TYPE node reachable from N,
6058 including those embedded inside types and decls (i.e,, TYPE_DECLs,
6059 NAMESPACE_DECLs, etc). */
6062 find_decls_types_in_node (struct cgraph_node
*n
, struct free_lang_data_d
*fld
)
6065 struct function
*fn
;
6069 find_decls_types (n
->decl
, fld
);
6071 if (!gimple_has_body_p (n
->decl
))
6074 gcc_assert (current_function_decl
== NULL_TREE
&& cfun
== NULL
);
6076 fn
= DECL_STRUCT_FUNCTION (n
->decl
);
6078 /* Traverse locals. */
6079 FOR_EACH_LOCAL_DECL (fn
, ix
, t
)
6080 find_decls_types (t
, fld
);
6082 /* Traverse EH regions in FN. */
6085 FOR_ALL_EH_REGION_FN (r
, fn
)
6086 find_decls_types_in_eh_region (r
, fld
);
6089 /* Traverse every statement in FN. */
6090 FOR_EACH_BB_FN (bb
, fn
)
6093 gimple_stmt_iterator si
;
6096 for (psi
= gsi_start_phis (bb
); !gsi_end_p (psi
); gsi_next (&psi
))
6098 gphi
*phi
= psi
.phi ();
6100 for (i
= 0; i
< gimple_phi_num_args (phi
); i
++)
6102 tree
*arg_p
= gimple_phi_arg_def_ptr (phi
, i
);
6103 find_decls_types (*arg_p
, fld
);
6107 for (si
= gsi_start_bb (bb
); !gsi_end_p (si
); gsi_next (&si
))
6109 gimple
*stmt
= gsi_stmt (si
);
6111 if (is_gimple_call (stmt
))
6112 find_decls_types (gimple_call_fntype (stmt
), fld
);
6114 for (i
= 0; i
< gimple_num_ops (stmt
); i
++)
6116 tree arg
= gimple_op (stmt
, i
);
6117 find_decls_types (arg
, fld
);
6124 /* Find decls and types referenced in varpool node N and store them in
6125 FLD->DECLS and FLD->TYPES. Unlike pass_referenced_vars, this will
6126 look for *every* kind of DECL and TYPE node reachable from N,
6127 including those embedded inside types and decls (i.e,, TYPE_DECLs,
6128 NAMESPACE_DECLs, etc). */
6131 find_decls_types_in_var (varpool_node
*v
, struct free_lang_data_d
*fld
)
6133 find_decls_types (v
->decl
, fld
);
6136 /* If T needs an assembler name, have one created for it. */
6139 assign_assembler_name_if_needed (tree t
)
6141 if (need_assembler_name_p (t
))
6143 /* When setting DECL_ASSEMBLER_NAME, the C++ mangler may emit
6144 diagnostics that use input_location to show locus
6145 information. The problem here is that, at this point,
6146 input_location is generally anchored to the end of the file
6147 (since the parser is long gone), so we don't have a good
6148 position to pin it to.
6150 To alleviate this problem, this uses the location of T's
6151 declaration. Examples of this are
6152 testsuite/g++.dg/template/cond2.C and
6153 testsuite/g++.dg/template/pr35240.C. */
6154 location_t saved_location
= input_location
;
6155 input_location
= DECL_SOURCE_LOCATION (t
);
6157 decl_assembler_name (t
);
6159 input_location
= saved_location
;
6164 /* Free language specific information for every operand and expression
6165 in every node of the call graph. This process operates in three stages:
6167 1- Every callgraph node and varpool node is traversed looking for
6168 decls and types embedded in them. This is a more exhaustive
6169 search than that done by find_referenced_vars, because it will
6170 also collect individual fields, decls embedded in types, etc.
6172 2- All the decls found are sent to free_lang_data_in_decl.
6174 3- All the types found are sent to free_lang_data_in_type.
6176 The ordering between decls and types is important because
6177 free_lang_data_in_decl sets assembler names, which includes
6178 mangling. So types cannot be freed up until assembler names have
6182 free_lang_data_in_cgraph (struct free_lang_data_d
*fld
)
6184 struct cgraph_node
*n
;
6190 /* Find decls and types in the body of every function in the callgraph. */
6191 FOR_EACH_FUNCTION (n
)
6192 find_decls_types_in_node (n
, fld
);
6194 FOR_EACH_VEC_SAFE_ELT (alias_pairs
, i
, p
)
6195 find_decls_types (p
->decl
, fld
);
6197 /* Find decls and types in every varpool symbol. */
6198 FOR_EACH_VARIABLE (v
)
6199 find_decls_types_in_var (v
, fld
);
6201 /* Set the assembler name on every decl found. We need to do this
6202 now because free_lang_data_in_decl will invalidate data needed
6203 for mangling. This breaks mangling on interdependent decls. */
6204 FOR_EACH_VEC_ELT (fld
->decls
, i
, t
)
6205 assign_assembler_name_if_needed (t
);
6207 /* Traverse every decl found freeing its language data. */
6208 FOR_EACH_VEC_ELT (fld
->decls
, i
, t
)
6209 free_lang_data_in_decl (t
, fld
);
6211 /* Traverse every type found freeing its language data. */
6212 FOR_EACH_VEC_ELT (fld
->types
, i
, t
)
6213 free_lang_data_in_type (t
, fld
);
6217 /* Free resources that are used by FE but are not needed once they are done. */
6220 free_lang_data (void)
6223 struct free_lang_data_d fld
;
6225 /* If we are the LTO frontend we have freed lang-specific data already. */
6227 || (!flag_generate_lto
&& !flag_generate_offload
))
6229 /* Rebuild type inheritance graph even when not doing LTO to get
6230 consistent profile data. */
6231 rebuild_type_inheritance_graph ();
6235 fld_incomplete_types
= new hash_map
<tree
, tree
>;
6236 fld_simplified_types
= new hash_map
<tree
, tree
>;
6238 /* Provide a dummy TRANSLATION_UNIT_DECL if the FE failed to provide one. */
6239 if (vec_safe_is_empty (all_translation_units
))
6240 build_translation_unit_decl (NULL_TREE
);
6242 /* Allocate and assign alias sets to the standard integer types
6243 while the slots are still in the way the frontends generated them. */
6244 for (i
= 0; i
< itk_none
; ++i
)
6245 if (integer_types
[i
])
6246 TYPE_ALIAS_SET (integer_types
[i
]) = get_alias_set (integer_types
[i
]);
6248 /* Traverse the IL resetting language specific information for
6249 operands, expressions, etc. */
6250 free_lang_data_in_cgraph (&fld
);
6252 /* Create gimple variants for common types. */
6253 for (unsigned i
= 0;
6254 i
< sizeof (builtin_structptr_types
) / sizeof (builtin_structptr_type
);
6256 builtin_structptr_types
[i
].node
= builtin_structptr_types
[i
].base
;
6258 /* Reset some langhooks. Do not reset types_compatible_p, it may
6259 still be used indirectly via the get_alias_set langhook. */
6260 lang_hooks
.dwarf_name
= lhd_dwarf_name
;
6261 lang_hooks
.decl_printable_name
= gimple_decl_printable_name
;
6262 lang_hooks
.gimplify_expr
= lhd_gimplify_expr
;
6263 lang_hooks
.overwrite_decl_assembler_name
= lhd_overwrite_decl_assembler_name
;
6264 lang_hooks
.print_xnode
= lhd_print_tree_nothing
;
6265 lang_hooks
.print_decl
= lhd_print_tree_nothing
;
6266 lang_hooks
.print_type
= lhd_print_tree_nothing
;
6267 lang_hooks
.print_identifier
= lhd_print_tree_nothing
;
6269 lang_hooks
.tree_inlining
.var_mod_type_p
= hook_bool_tree_tree_false
;
6276 FOR_EACH_VEC_ELT (fld
.types
, i
, t
)
6280 /* We do not want the default decl_assembler_name implementation,
6281 rather if we have fixed everything we want a wrapper around it
6282 asserting that all non-local symbols already got their assembler
6283 name and only produce assembler names for local symbols. Or rather
6284 make sure we never call decl_assembler_name on local symbols and
6285 devise a separate, middle-end private scheme for it. */
6287 /* Reset diagnostic machinery. */
6288 tree_diagnostics_defaults (global_dc
);
6290 rebuild_type_inheritance_graph ();
6292 delete fld_incomplete_types
;
6293 delete fld_simplified_types
;
6301 const pass_data pass_data_ipa_free_lang_data
=
6303 SIMPLE_IPA_PASS
, /* type */
6304 "*free_lang_data", /* name */
6305 OPTGROUP_NONE
, /* optinfo_flags */
6306 TV_IPA_FREE_LANG_DATA
, /* tv_id */
6307 0, /* properties_required */
6308 0, /* properties_provided */
6309 0, /* properties_destroyed */
6310 0, /* todo_flags_start */
6311 0, /* todo_flags_finish */
6314 class pass_ipa_free_lang_data
: public simple_ipa_opt_pass
6317 pass_ipa_free_lang_data (gcc::context
*ctxt
)
6318 : simple_ipa_opt_pass (pass_data_ipa_free_lang_data
, ctxt
)
6321 /* opt_pass methods: */
6322 virtual unsigned int execute (function
*) { return free_lang_data (); }
6324 }; // class pass_ipa_free_lang_data
6328 simple_ipa_opt_pass
*
6329 make_pass_ipa_free_lang_data (gcc::context
*ctxt
)
6331 return new pass_ipa_free_lang_data (ctxt
);
6334 /* Set the type qualifiers for TYPE to TYPE_QUALS, which is a bitmask
6335 of the various TYPE_QUAL values. */
6338 set_type_quals (tree type
, int type_quals
)
6340 TYPE_READONLY (type
) = (type_quals
& TYPE_QUAL_CONST
) != 0;
6341 TYPE_VOLATILE (type
) = (type_quals
& TYPE_QUAL_VOLATILE
) != 0;
6342 TYPE_RESTRICT (type
) = (type_quals
& TYPE_QUAL_RESTRICT
) != 0;
6343 TYPE_ATOMIC (type
) = (type_quals
& TYPE_QUAL_ATOMIC
) != 0;
6344 TYPE_ADDR_SPACE (type
) = DECODE_QUAL_ADDR_SPACE (type_quals
);
6347 /* Returns true iff CAND and BASE have equivalent language-specific
6351 check_lang_type (const_tree cand
, const_tree base
)
6353 if (lang_hooks
.types
.type_hash_eq
== NULL
)
6355 /* type_hash_eq currently only applies to these types. */
6356 if (TREE_CODE (cand
) != FUNCTION_TYPE
6357 && TREE_CODE (cand
) != METHOD_TYPE
)
6359 return lang_hooks
.types
.type_hash_eq (cand
, base
);
6362 /* This function checks to see if TYPE matches the size one of the built-in
6363 atomic types, and returns that core atomic type. */
6366 find_atomic_core_type (const_tree type
)
6368 tree base_atomic_type
;
6370 /* Only handle complete types. */
6371 if (!tree_fits_uhwi_p (TYPE_SIZE (type
)))
6374 switch (tree_to_uhwi (TYPE_SIZE (type
)))
6377 base_atomic_type
= atomicQI_type_node
;
6381 base_atomic_type
= atomicHI_type_node
;
6385 base_atomic_type
= atomicSI_type_node
;
6389 base_atomic_type
= atomicDI_type_node
;
6393 base_atomic_type
= atomicTI_type_node
;
6397 base_atomic_type
= NULL_TREE
;
6400 return base_atomic_type
;
6403 /* Returns true iff unqualified CAND and BASE are equivalent. */
6406 check_base_type (const_tree cand
, const_tree base
)
6408 if (TYPE_NAME (cand
) != TYPE_NAME (base
)
6409 /* Apparently this is needed for Objective-C. */
6410 || TYPE_CONTEXT (cand
) != TYPE_CONTEXT (base
)
6411 || !attribute_list_equal (TYPE_ATTRIBUTES (cand
),
6412 TYPE_ATTRIBUTES (base
)))
6414 /* Check alignment. */
6415 if (TYPE_ALIGN (cand
) == TYPE_ALIGN (base
))
6417 /* Atomic types increase minimal alignment. We must to do so as well
6418 or we get duplicated canonical types. See PR88686. */
6419 if ((TYPE_QUALS (cand
) & TYPE_QUAL_ATOMIC
))
6421 /* See if this object can map to a basic atomic type. */
6422 tree atomic_type
= find_atomic_core_type (cand
);
6423 if (atomic_type
&& TYPE_ALIGN (atomic_type
) == TYPE_ALIGN (cand
))
6429 /* Returns true iff CAND is equivalent to BASE with TYPE_QUALS. */
6432 check_qualified_type (const_tree cand
, const_tree base
, int type_quals
)
6434 return (TYPE_QUALS (cand
) == type_quals
6435 && check_base_type (cand
, base
)
6436 && check_lang_type (cand
, base
));
6439 /* Returns true iff CAND is equivalent to BASE with ALIGN. */
6442 check_aligned_type (const_tree cand
, const_tree base
, unsigned int align
)
6444 return (TYPE_QUALS (cand
) == TYPE_QUALS (base
)
6445 && TYPE_NAME (cand
) == TYPE_NAME (base
)
6446 /* Apparently this is needed for Objective-C. */
6447 && TYPE_CONTEXT (cand
) == TYPE_CONTEXT (base
)
6448 /* Check alignment. */
6449 && TYPE_ALIGN (cand
) == align
6450 && attribute_list_equal (TYPE_ATTRIBUTES (cand
),
6451 TYPE_ATTRIBUTES (base
))
6452 && check_lang_type (cand
, base
));
6455 /* Return a version of the TYPE, qualified as indicated by the
6456 TYPE_QUALS, if one exists. If no qualified version exists yet,
6457 return NULL_TREE. */
6460 get_qualified_type (tree type
, int type_quals
)
6462 if (TYPE_QUALS (type
) == type_quals
)
6465 tree mv
= TYPE_MAIN_VARIANT (type
);
6466 if (check_qualified_type (mv
, type
, type_quals
))
6469 /* Search the chain of variants to see if there is already one there just
6470 like the one we need to have. If so, use that existing one. We must
6471 preserve the TYPE_NAME, since there is code that depends on this. */
6472 for (tree
*tp
= &TYPE_NEXT_VARIANT (mv
); *tp
; tp
= &TYPE_NEXT_VARIANT (*tp
))
6473 if (check_qualified_type (*tp
, type
, type_quals
))
6475 /* Put the found variant at the head of the variant list so
6476 frequently searched variants get found faster. The C++ FE
6477 benefits greatly from this. */
6479 *tp
= TYPE_NEXT_VARIANT (t
);
6480 TYPE_NEXT_VARIANT (t
) = TYPE_NEXT_VARIANT (mv
);
6481 TYPE_NEXT_VARIANT (mv
) = t
;
6488 /* Like get_qualified_type, but creates the type if it does not
6489 exist. This function never returns NULL_TREE. */
6492 build_qualified_type (tree type
, int type_quals MEM_STAT_DECL
)
6496 /* See if we already have the appropriate qualified variant. */
6497 t
= get_qualified_type (type
, type_quals
);
6499 /* If not, build it. */
6502 t
= build_variant_type_copy (type PASS_MEM_STAT
);
6503 set_type_quals (t
, type_quals
);
6505 if (((type_quals
& TYPE_QUAL_ATOMIC
) == TYPE_QUAL_ATOMIC
))
6507 /* See if this object can map to a basic atomic type. */
6508 tree atomic_type
= find_atomic_core_type (type
);
6511 /* Ensure the alignment of this type is compatible with
6512 the required alignment of the atomic type. */
6513 if (TYPE_ALIGN (atomic_type
) > TYPE_ALIGN (t
))
6514 SET_TYPE_ALIGN (t
, TYPE_ALIGN (atomic_type
));
6518 if (TYPE_STRUCTURAL_EQUALITY_P (type
))
6519 /* Propagate structural equality. */
6520 SET_TYPE_STRUCTURAL_EQUALITY (t
);
6521 else if (TYPE_CANONICAL (type
) != type
)
6522 /* Build the underlying canonical type, since it is different
6525 tree c
= build_qualified_type (TYPE_CANONICAL (type
), type_quals
);
6526 TYPE_CANONICAL (t
) = TYPE_CANONICAL (c
);
6529 /* T is its own canonical type. */
6530 TYPE_CANONICAL (t
) = t
;
6537 /* Create a variant of type T with alignment ALIGN. */
6540 build_aligned_type (tree type
, unsigned int align
)
6544 if (TYPE_PACKED (type
)
6545 || TYPE_ALIGN (type
) == align
)
6548 for (t
= TYPE_MAIN_VARIANT (type
); t
; t
= TYPE_NEXT_VARIANT (t
))
6549 if (check_aligned_type (t
, type
, align
))
6552 t
= build_variant_type_copy (type
);
6553 SET_TYPE_ALIGN (t
, align
);
6554 TYPE_USER_ALIGN (t
) = 1;
6559 /* Create a new distinct copy of TYPE. The new type is made its own
6560 MAIN_VARIANT. If TYPE requires structural equality checks, the
6561 resulting type requires structural equality checks; otherwise, its
6562 TYPE_CANONICAL points to itself. */
6565 build_distinct_type_copy (tree type MEM_STAT_DECL
)
6567 tree t
= copy_node (type PASS_MEM_STAT
);
6569 TYPE_POINTER_TO (t
) = 0;
6570 TYPE_REFERENCE_TO (t
) = 0;
6572 /* Set the canonical type either to a new equivalence class, or
6573 propagate the need for structural equality checks. */
6574 if (TYPE_STRUCTURAL_EQUALITY_P (type
))
6575 SET_TYPE_STRUCTURAL_EQUALITY (t
);
6577 TYPE_CANONICAL (t
) = t
;
6579 /* Make it its own variant. */
6580 TYPE_MAIN_VARIANT (t
) = t
;
6581 TYPE_NEXT_VARIANT (t
) = 0;
6583 /* Note that it is now possible for TYPE_MIN_VALUE to be a value
6584 whose TREE_TYPE is not t. This can also happen in the Ada
6585 frontend when using subtypes. */
6590 /* Create a new variant of TYPE, equivalent but distinct. This is so
6591 the caller can modify it. TYPE_CANONICAL for the return type will
6592 be equivalent to TYPE_CANONICAL of TYPE, indicating that the types
6593 are considered equal by the language itself (or that both types
6594 require structural equality checks). */
6597 build_variant_type_copy (tree type MEM_STAT_DECL
)
6599 tree t
, m
= TYPE_MAIN_VARIANT (type
);
6601 t
= build_distinct_type_copy (type PASS_MEM_STAT
);
6603 /* Since we're building a variant, assume that it is a non-semantic
6604 variant. This also propagates TYPE_STRUCTURAL_EQUALITY_P. */
6605 TYPE_CANONICAL (t
) = TYPE_CANONICAL (type
);
6606 /* Type variants have no alias set defined. */
6607 TYPE_ALIAS_SET (t
) = -1;
6609 /* Add the new type to the chain of variants of TYPE. */
6610 TYPE_NEXT_VARIANT (t
) = TYPE_NEXT_VARIANT (m
);
6611 TYPE_NEXT_VARIANT (m
) = t
;
6612 TYPE_MAIN_VARIANT (t
) = m
;
6617 /* Return true if the from tree in both tree maps are equal. */
6620 tree_map_base_eq (const void *va
, const void *vb
)
6622 const struct tree_map_base
*const a
= (const struct tree_map_base
*) va
,
6623 *const b
= (const struct tree_map_base
*) vb
;
6624 return (a
->from
== b
->from
);
6627 /* Hash a from tree in a tree_base_map. */
6630 tree_map_base_hash (const void *item
)
6632 return htab_hash_pointer (((const struct tree_map_base
*)item
)->from
);
6635 /* Return true if this tree map structure is marked for garbage collection
6636 purposes. We simply return true if the from tree is marked, so that this
6637 structure goes away when the from tree goes away. */
6640 tree_map_base_marked_p (const void *p
)
6642 return ggc_marked_p (((const struct tree_map_base
*) p
)->from
);
6645 /* Hash a from tree in a tree_map. */
6648 tree_map_hash (const void *item
)
6650 return (((const struct tree_map
*) item
)->hash
);
6653 /* Hash a from tree in a tree_decl_map. */
6656 tree_decl_map_hash (const void *item
)
6658 return DECL_UID (((const struct tree_decl_map
*) item
)->base
.from
);
6661 /* Return the initialization priority for DECL. */
6664 decl_init_priority_lookup (tree decl
)
6666 symtab_node
*snode
= symtab_node::get (decl
);
6669 return DEFAULT_INIT_PRIORITY
;
6671 snode
->get_init_priority ();
6674 /* Return the finalization priority for DECL. */
6677 decl_fini_priority_lookup (tree decl
)
6679 cgraph_node
*node
= cgraph_node::get (decl
);
6682 return DEFAULT_INIT_PRIORITY
;
6684 node
->get_fini_priority ();
6687 /* Set the initialization priority for DECL to PRIORITY. */
6690 decl_init_priority_insert (tree decl
, priority_type priority
)
6692 struct symtab_node
*snode
;
6694 if (priority
== DEFAULT_INIT_PRIORITY
)
6696 snode
= symtab_node::get (decl
);
6700 else if (VAR_P (decl
))
6701 snode
= varpool_node::get_create (decl
);
6703 snode
= cgraph_node::get_create (decl
);
6704 snode
->set_init_priority (priority
);
6707 /* Set the finalization priority for DECL to PRIORITY. */
6710 decl_fini_priority_insert (tree decl
, priority_type priority
)
6712 struct cgraph_node
*node
;
6714 if (priority
== DEFAULT_INIT_PRIORITY
)
6716 node
= cgraph_node::get (decl
);
6721 node
= cgraph_node::get_create (decl
);
6722 node
->set_fini_priority (priority
);
6725 /* Print out the statistics for the DECL_DEBUG_EXPR hash table. */
6728 print_debug_expr_statistics (void)
6730 fprintf (stderr
, "DECL_DEBUG_EXPR hash: size %ld, %ld elements, %f collisions\n",
6731 (long) debug_expr_for_decl
->size (),
6732 (long) debug_expr_for_decl
->elements (),
6733 debug_expr_for_decl
->collisions ());
6736 /* Print out the statistics for the DECL_VALUE_EXPR hash table. */
6739 print_value_expr_statistics (void)
6741 fprintf (stderr
, "DECL_VALUE_EXPR hash: size %ld, %ld elements, %f collisions\n",
6742 (long) value_expr_for_decl
->size (),
6743 (long) value_expr_for_decl
->elements (),
6744 value_expr_for_decl
->collisions ());
6747 /* Lookup a debug expression for FROM, and return it if we find one. */
6750 decl_debug_expr_lookup (tree from
)
6752 struct tree_decl_map
*h
, in
;
6753 in
.base
.from
= from
;
6755 h
= debug_expr_for_decl
->find_with_hash (&in
, DECL_UID (from
));
6761 /* Insert a mapping FROM->TO in the debug expression hashtable. */
6764 decl_debug_expr_insert (tree from
, tree to
)
6766 struct tree_decl_map
*h
;
6768 h
= ggc_alloc
<tree_decl_map
> ();
6769 h
->base
.from
= from
;
6771 *debug_expr_for_decl
->find_slot_with_hash (h
, DECL_UID (from
), INSERT
) = h
;
6774 /* Lookup a value expression for FROM, and return it if we find one. */
6777 decl_value_expr_lookup (tree from
)
6779 struct tree_decl_map
*h
, in
;
6780 in
.base
.from
= from
;
6782 h
= value_expr_for_decl
->find_with_hash (&in
, DECL_UID (from
));
6788 /* Insert a mapping FROM->TO in the value expression hashtable. */
6791 decl_value_expr_insert (tree from
, tree to
)
6793 struct tree_decl_map
*h
;
6795 h
= ggc_alloc
<tree_decl_map
> ();
6796 h
->base
.from
= from
;
6798 *value_expr_for_decl
->find_slot_with_hash (h
, DECL_UID (from
), INSERT
) = h
;
6801 /* Lookup a vector of debug arguments for FROM, and return it if we
6805 decl_debug_args_lookup (tree from
)
6807 struct tree_vec_map
*h
, in
;
6809 if (!DECL_HAS_DEBUG_ARGS_P (from
))
6811 gcc_checking_assert (debug_args_for_decl
!= NULL
);
6812 in
.base
.from
= from
;
6813 h
= debug_args_for_decl
->find_with_hash (&in
, DECL_UID (from
));
6819 /* Insert a mapping FROM->empty vector of debug arguments in the value
6820 expression hashtable. */
6823 decl_debug_args_insert (tree from
)
6825 struct tree_vec_map
*h
;
6828 if (DECL_HAS_DEBUG_ARGS_P (from
))
6829 return decl_debug_args_lookup (from
);
6830 if (debug_args_for_decl
== NULL
)
6831 debug_args_for_decl
= hash_table
<tree_vec_map_cache_hasher
>::create_ggc (64);
6832 h
= ggc_alloc
<tree_vec_map
> ();
6833 h
->base
.from
= from
;
6835 loc
= debug_args_for_decl
->find_slot_with_hash (h
, DECL_UID (from
), INSERT
);
6837 DECL_HAS_DEBUG_ARGS_P (from
) = 1;
6841 /* Hashing of types so that we don't make duplicates.
6842 The entry point is `type_hash_canon'. */
6844 /* Generate the default hash code for TYPE. This is designed for
6845 speed, rather than maximum entropy. */
6848 type_hash_canon_hash (tree type
)
6850 inchash::hash hstate
;
6852 hstate
.add_int (TREE_CODE (type
));
6854 if (TREE_TYPE (type
))
6855 hstate
.add_object (TYPE_HASH (TREE_TYPE (type
)));
6857 for (tree t
= TYPE_ATTRIBUTES (type
); t
; t
= TREE_CHAIN (t
))
6858 /* Just the identifier is adequate to distinguish. */
6859 hstate
.add_object (IDENTIFIER_HASH_VALUE (get_attribute_name (t
)));
6861 switch (TREE_CODE (type
))
6864 hstate
.add_object (TYPE_HASH (TYPE_METHOD_BASETYPE (type
)));
6867 for (tree t
= TYPE_ARG_TYPES (type
); t
; t
= TREE_CHAIN (t
))
6868 if (TREE_VALUE (t
) != error_mark_node
)
6869 hstate
.add_object (TYPE_HASH (TREE_VALUE (t
)));
6873 hstate
.add_object (TYPE_HASH (TYPE_OFFSET_BASETYPE (type
)));
6878 if (TYPE_DOMAIN (type
))
6879 hstate
.add_object (TYPE_HASH (TYPE_DOMAIN (type
)));
6880 if (!AGGREGATE_TYPE_P (TREE_TYPE (type
)))
6882 unsigned typeless
= TYPE_TYPELESS_STORAGE (type
);
6883 hstate
.add_object (typeless
);
6890 tree t
= TYPE_MAX_VALUE (type
);
6892 t
= TYPE_MIN_VALUE (type
);
6893 for (int i
= 0; i
< TREE_INT_CST_NUNITS (t
); i
++)
6894 hstate
.add_object (TREE_INT_CST_ELT (t
, i
));
6899 case FIXED_POINT_TYPE
:
6901 unsigned prec
= TYPE_PRECISION (type
);
6902 hstate
.add_object (prec
);
6907 hstate
.add_poly_int (TYPE_VECTOR_SUBPARTS (type
));
6914 return hstate
.end ();
6917 /* These are the Hashtable callback functions. */
6919 /* Returns true iff the types are equivalent. */
6922 type_cache_hasher::equal (type_hash
*a
, type_hash
*b
)
6924 /* First test the things that are the same for all types. */
6925 if (a
->hash
!= b
->hash
6926 || TREE_CODE (a
->type
) != TREE_CODE (b
->type
)
6927 || TREE_TYPE (a
->type
) != TREE_TYPE (b
->type
)
6928 || !attribute_list_equal (TYPE_ATTRIBUTES (a
->type
),
6929 TYPE_ATTRIBUTES (b
->type
))
6930 || (TREE_CODE (a
->type
) != COMPLEX_TYPE
6931 && TYPE_NAME (a
->type
) != TYPE_NAME (b
->type
)))
6934 /* Be careful about comparing arrays before and after the element type
6935 has been completed; don't compare TYPE_ALIGN unless both types are
6937 if (COMPLETE_TYPE_P (a
->type
) && COMPLETE_TYPE_P (b
->type
)
6938 && (TYPE_ALIGN (a
->type
) != TYPE_ALIGN (b
->type
)
6939 || TYPE_MODE (a
->type
) != TYPE_MODE (b
->type
)))
6942 switch (TREE_CODE (a
->type
))
6947 case REFERENCE_TYPE
:
6952 return known_eq (TYPE_VECTOR_SUBPARTS (a
->type
),
6953 TYPE_VECTOR_SUBPARTS (b
->type
));
6956 if (TYPE_VALUES (a
->type
) != TYPE_VALUES (b
->type
)
6957 && !(TYPE_VALUES (a
->type
)
6958 && TREE_CODE (TYPE_VALUES (a
->type
)) == TREE_LIST
6959 && TYPE_VALUES (b
->type
)
6960 && TREE_CODE (TYPE_VALUES (b
->type
)) == TREE_LIST
6961 && type_list_equal (TYPE_VALUES (a
->type
),
6962 TYPE_VALUES (b
->type
))))
6970 if (TYPE_PRECISION (a
->type
) != TYPE_PRECISION (b
->type
))
6972 return ((TYPE_MAX_VALUE (a
->type
) == TYPE_MAX_VALUE (b
->type
)
6973 || tree_int_cst_equal (TYPE_MAX_VALUE (a
->type
),
6974 TYPE_MAX_VALUE (b
->type
)))
6975 && (TYPE_MIN_VALUE (a
->type
) == TYPE_MIN_VALUE (b
->type
)
6976 || tree_int_cst_equal (TYPE_MIN_VALUE (a
->type
),
6977 TYPE_MIN_VALUE (b
->type
))));
6979 case FIXED_POINT_TYPE
:
6980 return TYPE_SATURATING (a
->type
) == TYPE_SATURATING (b
->type
);
6983 return TYPE_OFFSET_BASETYPE (a
->type
) == TYPE_OFFSET_BASETYPE (b
->type
);
6986 if (TYPE_METHOD_BASETYPE (a
->type
) == TYPE_METHOD_BASETYPE (b
->type
)
6987 && (TYPE_ARG_TYPES (a
->type
) == TYPE_ARG_TYPES (b
->type
)
6988 || (TYPE_ARG_TYPES (a
->type
)
6989 && TREE_CODE (TYPE_ARG_TYPES (a
->type
)) == TREE_LIST
6990 && TYPE_ARG_TYPES (b
->type
)
6991 && TREE_CODE (TYPE_ARG_TYPES (b
->type
)) == TREE_LIST
6992 && type_list_equal (TYPE_ARG_TYPES (a
->type
),
6993 TYPE_ARG_TYPES (b
->type
)))))
6997 /* Don't compare TYPE_TYPELESS_STORAGE flag on aggregates,
6998 where the flag should be inherited from the element type
6999 and can change after ARRAY_TYPEs are created; on non-aggregates
7000 compare it and hash it, scalars will never have that flag set
7001 and we need to differentiate between arrays created by different
7002 front-ends or middle-end created arrays. */
7003 return (TYPE_DOMAIN (a
->type
) == TYPE_DOMAIN (b
->type
)
7004 && (AGGREGATE_TYPE_P (TREE_TYPE (a
->type
))
7005 || (TYPE_TYPELESS_STORAGE (a
->type
)
7006 == TYPE_TYPELESS_STORAGE (b
->type
))));
7010 case QUAL_UNION_TYPE
:
7011 return (TYPE_FIELDS (a
->type
) == TYPE_FIELDS (b
->type
)
7012 || (TYPE_FIELDS (a
->type
)
7013 && TREE_CODE (TYPE_FIELDS (a
->type
)) == TREE_LIST
7014 && TYPE_FIELDS (b
->type
)
7015 && TREE_CODE (TYPE_FIELDS (b
->type
)) == TREE_LIST
7016 && type_list_equal (TYPE_FIELDS (a
->type
),
7017 TYPE_FIELDS (b
->type
))));
7020 if (TYPE_ARG_TYPES (a
->type
) == TYPE_ARG_TYPES (b
->type
)
7021 || (TYPE_ARG_TYPES (a
->type
)
7022 && TREE_CODE (TYPE_ARG_TYPES (a
->type
)) == TREE_LIST
7023 && TYPE_ARG_TYPES (b
->type
)
7024 && TREE_CODE (TYPE_ARG_TYPES (b
->type
)) == TREE_LIST
7025 && type_list_equal (TYPE_ARG_TYPES (a
->type
),
7026 TYPE_ARG_TYPES (b
->type
))))
7034 if (lang_hooks
.types
.type_hash_eq
!= NULL
)
7035 return lang_hooks
.types
.type_hash_eq (a
->type
, b
->type
);
7040 /* Given TYPE, and HASHCODE its hash code, return the canonical
7041 object for an identical type if one already exists.
7042 Otherwise, return TYPE, and record it as the canonical object.
7044 To use this function, first create a type of the sort you want.
7045 Then compute its hash code from the fields of the type that
7046 make it different from other similar types.
7047 Then call this function and use the value. */
7050 type_hash_canon (unsigned int hashcode
, tree type
)
7055 /* The hash table only contains main variants, so ensure that's what we're
7057 gcc_assert (TYPE_MAIN_VARIANT (type
) == type
);
7059 /* The TYPE_ALIGN field of a type is set by layout_type(), so we
7060 must call that routine before comparing TYPE_ALIGNs. */
7066 loc
= type_hash_table
->find_slot_with_hash (&in
, hashcode
, INSERT
);
7069 tree t1
= ((type_hash
*) *loc
)->type
;
7070 gcc_assert (TYPE_MAIN_VARIANT (t1
) == t1
7072 if (TYPE_UID (type
) + 1 == next_type_uid
)
7074 /* Free also min/max values and the cache for integer
7075 types. This can't be done in free_node, as LTO frees
7076 those on its own. */
7077 if (TREE_CODE (type
) == INTEGER_TYPE
)
7079 if (TYPE_MIN_VALUE (type
)
7080 && TREE_TYPE (TYPE_MIN_VALUE (type
)) == type
)
7082 /* Zero is always in TYPE_CACHED_VALUES. */
7083 if (! TYPE_UNSIGNED (type
))
7084 int_cst_hash_table
->remove_elt (TYPE_MIN_VALUE (type
));
7085 ggc_free (TYPE_MIN_VALUE (type
));
7087 if (TYPE_MAX_VALUE (type
)
7088 && TREE_TYPE (TYPE_MAX_VALUE (type
)) == type
)
7090 int_cst_hash_table
->remove_elt (TYPE_MAX_VALUE (type
));
7091 ggc_free (TYPE_MAX_VALUE (type
));
7093 if (TYPE_CACHED_VALUES_P (type
))
7094 ggc_free (TYPE_CACHED_VALUES (type
));
7101 struct type_hash
*h
;
7103 h
= ggc_alloc
<type_hash
> ();
7113 print_type_hash_statistics (void)
7115 fprintf (stderr
, "Type hash: size %ld, %ld elements, %f collisions\n",
7116 (long) type_hash_table
->size (),
7117 (long) type_hash_table
->elements (),
7118 type_hash_table
->collisions ());
7121 /* Given two lists of types
7122 (chains of TREE_LIST nodes with types in the TREE_VALUE slots)
7123 return 1 if the lists contain the same types in the same order.
7124 Also, the TREE_PURPOSEs must match. */
7127 type_list_equal (const_tree l1
, const_tree l2
)
7131 for (t1
= l1
, t2
= l2
; t1
&& t2
; t1
= TREE_CHAIN (t1
), t2
= TREE_CHAIN (t2
))
7132 if (TREE_VALUE (t1
) != TREE_VALUE (t2
)
7133 || (TREE_PURPOSE (t1
) != TREE_PURPOSE (t2
)
7134 && ! (1 == simple_cst_equal (TREE_PURPOSE (t1
), TREE_PURPOSE (t2
))
7135 && (TREE_TYPE (TREE_PURPOSE (t1
))
7136 == TREE_TYPE (TREE_PURPOSE (t2
))))))
7142 /* Returns the number of arguments to the FUNCTION_TYPE or METHOD_TYPE
7143 given by TYPE. If the argument list accepts variable arguments,
7144 then this function counts only the ordinary arguments. */
7147 type_num_arguments (const_tree fntype
)
7151 for (tree t
= TYPE_ARG_TYPES (fntype
); t
; t
= TREE_CHAIN (t
))
7152 /* If the function does not take a variable number of arguments,
7153 the last element in the list will have type `void'. */
7154 if (VOID_TYPE_P (TREE_VALUE (t
)))
7162 /* Return the type of the function TYPE's argument ARGNO if known.
7163 For vararg function's where ARGNO refers to one of the variadic
7164 arguments return null. Otherwise, return a void_type_node for
7165 out-of-bounds ARGNO. */
7168 type_argument_type (const_tree fntype
, unsigned argno
)
7170 /* Treat zero the same as an out-of-bounds argument number. */
7172 return void_type_node
;
7174 function_args_iterator iter
;
7178 FOREACH_FUNCTION_ARGS (fntype
, argtype
, iter
)
7180 /* A vararg function's argument list ends in a null. Otherwise,
7181 an ordinary function's argument list ends with void. Return
7182 null if ARGNO refers to a vararg argument, void_type_node if
7183 it's out of bounds, and the formal argument type otherwise. */
7187 if (i
== argno
|| VOID_TYPE_P (argtype
))
7196 /* Nonzero if integer constants T1 and T2
7197 represent the same constant value. */
7200 tree_int_cst_equal (const_tree t1
, const_tree t2
)
7205 if (t1
== 0 || t2
== 0)
7208 STRIP_ANY_LOCATION_WRAPPER (t1
);
7209 STRIP_ANY_LOCATION_WRAPPER (t2
);
7211 if (TREE_CODE (t1
) == INTEGER_CST
7212 && TREE_CODE (t2
) == INTEGER_CST
7213 && wi::to_widest (t1
) == wi::to_widest (t2
))
7219 /* Return true if T is an INTEGER_CST whose numerical value (extended
7220 according to TYPE_UNSIGNED) fits in a signed HOST_WIDE_INT. */
7223 tree_fits_shwi_p (const_tree t
)
7225 return (t
!= NULL_TREE
7226 && TREE_CODE (t
) == INTEGER_CST
7227 && wi::fits_shwi_p (wi::to_widest (t
)));
7230 /* Return true if T is an INTEGER_CST or POLY_INT_CST whose numerical
7231 value (extended according to TYPE_UNSIGNED) fits in a poly_int64. */
7234 tree_fits_poly_int64_p (const_tree t
)
7238 if (POLY_INT_CST_P (t
))
7240 for (unsigned int i
= 0; i
< NUM_POLY_INT_COEFFS
; i
++)
7241 if (!wi::fits_shwi_p (wi::to_wide (POLY_INT_CST_COEFF (t
, i
))))
7245 return (TREE_CODE (t
) == INTEGER_CST
7246 && wi::fits_shwi_p (wi::to_widest (t
)));
7249 /* Return true if T is an INTEGER_CST whose numerical value (extended
7250 according to TYPE_UNSIGNED) fits in an unsigned HOST_WIDE_INT. */
7253 tree_fits_uhwi_p (const_tree t
)
7255 return (t
!= NULL_TREE
7256 && TREE_CODE (t
) == INTEGER_CST
7257 && wi::fits_uhwi_p (wi::to_widest (t
)));
7260 /* Return true if T is an INTEGER_CST or POLY_INT_CST whose numerical
7261 value (extended according to TYPE_UNSIGNED) fits in a poly_uint64. */
7264 tree_fits_poly_uint64_p (const_tree t
)
7268 if (POLY_INT_CST_P (t
))
7270 for (unsigned int i
= 0; i
< NUM_POLY_INT_COEFFS
; i
++)
7271 if (!wi::fits_uhwi_p (wi::to_widest (POLY_INT_CST_COEFF (t
, i
))))
7275 return (TREE_CODE (t
) == INTEGER_CST
7276 && wi::fits_uhwi_p (wi::to_widest (t
)));
7279 /* T is an INTEGER_CST whose numerical value (extended according to
7280 TYPE_UNSIGNED) fits in a signed HOST_WIDE_INT. Return that
7284 tree_to_shwi (const_tree t
)
7286 gcc_assert (tree_fits_shwi_p (t
));
7287 return TREE_INT_CST_LOW (t
);
7290 /* T is an INTEGER_CST whose numerical value (extended according to
7291 TYPE_UNSIGNED) fits in an unsigned HOST_WIDE_INT. Return that
7294 unsigned HOST_WIDE_INT
7295 tree_to_uhwi (const_tree t
)
7297 gcc_assert (tree_fits_uhwi_p (t
));
7298 return TREE_INT_CST_LOW (t
);
7301 /* Return the most significant (sign) bit of T. */
7304 tree_int_cst_sign_bit (const_tree t
)
7306 unsigned bitno
= TYPE_PRECISION (TREE_TYPE (t
)) - 1;
7308 return wi::extract_uhwi (wi::to_wide (t
), bitno
, 1);
7311 /* Return an indication of the sign of the integer constant T.
7312 The return value is -1 if T < 0, 0 if T == 0, and 1 if T > 0.
7313 Note that -1 will never be returned if T's type is unsigned. */
7316 tree_int_cst_sgn (const_tree t
)
7318 if (wi::to_wide (t
) == 0)
7320 else if (TYPE_UNSIGNED (TREE_TYPE (t
)))
7322 else if (wi::neg_p (wi::to_wide (t
)))
7328 /* Return the minimum number of bits needed to represent VALUE in a
7329 signed or unsigned type, UNSIGNEDP says which. */
7332 tree_int_cst_min_precision (tree value
, signop sgn
)
7334 /* If the value is negative, compute its negative minus 1. The latter
7335 adjustment is because the absolute value of the largest negative value
7336 is one larger than the largest positive value. This is equivalent to
7337 a bit-wise negation, so use that operation instead. */
7339 if (tree_int_cst_sgn (value
) < 0)
7340 value
= fold_build1 (BIT_NOT_EXPR
, TREE_TYPE (value
), value
);
7342 /* Return the number of bits needed, taking into account the fact
7343 that we need one more bit for a signed than unsigned type.
7344 If value is 0 or -1, the minimum precision is 1 no matter
7345 whether unsignedp is true or false. */
7347 if (integer_zerop (value
))
7350 return tree_floor_log2 (value
) + 1 + (sgn
== SIGNED
? 1 : 0) ;
7353 /* Return truthvalue of whether T1 is the same tree structure as T2.
7354 Return 1 if they are the same.
7355 Return 0 if they are understandably different.
7356 Return -1 if either contains tree structure not understood by
7360 simple_cst_equal (const_tree t1
, const_tree t2
)
7362 enum tree_code code1
, code2
;
7368 if (t1
== 0 || t2
== 0)
7371 /* For location wrappers to be the same, they must be at the same
7372 source location (and wrap the same thing). */
7373 if (location_wrapper_p (t1
) && location_wrapper_p (t2
))
7375 if (EXPR_LOCATION (t1
) != EXPR_LOCATION (t2
))
7377 return simple_cst_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
7380 code1
= TREE_CODE (t1
);
7381 code2
= TREE_CODE (t2
);
7383 if (CONVERT_EXPR_CODE_P (code1
) || code1
== NON_LVALUE_EXPR
)
7385 if (CONVERT_EXPR_CODE_P (code2
)
7386 || code2
== NON_LVALUE_EXPR
)
7387 return simple_cst_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
7389 return simple_cst_equal (TREE_OPERAND (t1
, 0), t2
);
7392 else if (CONVERT_EXPR_CODE_P (code2
)
7393 || code2
== NON_LVALUE_EXPR
)
7394 return simple_cst_equal (t1
, TREE_OPERAND (t2
, 0));
7402 return wi::to_widest (t1
) == wi::to_widest (t2
);
7405 return real_identical (&TREE_REAL_CST (t1
), &TREE_REAL_CST (t2
));
7408 return FIXED_VALUES_IDENTICAL (TREE_FIXED_CST (t1
), TREE_FIXED_CST (t2
));
7411 return (TREE_STRING_LENGTH (t1
) == TREE_STRING_LENGTH (t2
)
7412 && ! memcmp (TREE_STRING_POINTER (t1
), TREE_STRING_POINTER (t2
),
7413 TREE_STRING_LENGTH (t1
)));
7417 unsigned HOST_WIDE_INT idx
;
7418 vec
<constructor_elt
, va_gc
> *v1
= CONSTRUCTOR_ELTS (t1
);
7419 vec
<constructor_elt
, va_gc
> *v2
= CONSTRUCTOR_ELTS (t2
);
7421 if (vec_safe_length (v1
) != vec_safe_length (v2
))
7424 for (idx
= 0; idx
< vec_safe_length (v1
); ++idx
)
7425 /* ??? Should we handle also fields here? */
7426 if (!simple_cst_equal ((*v1
)[idx
].value
, (*v2
)[idx
].value
))
7432 return simple_cst_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
7435 cmp
= simple_cst_equal (CALL_EXPR_FN (t1
), CALL_EXPR_FN (t2
));
7438 if (call_expr_nargs (t1
) != call_expr_nargs (t2
))
7441 const_tree arg1
, arg2
;
7442 const_call_expr_arg_iterator iter1
, iter2
;
7443 for (arg1
= first_const_call_expr_arg (t1
, &iter1
),
7444 arg2
= first_const_call_expr_arg (t2
, &iter2
);
7446 arg1
= next_const_call_expr_arg (&iter1
),
7447 arg2
= next_const_call_expr_arg (&iter2
))
7449 cmp
= simple_cst_equal (arg1
, arg2
);
7453 return arg1
== arg2
;
7457 /* Special case: if either target is an unallocated VAR_DECL,
7458 it means that it's going to be unified with whatever the
7459 TARGET_EXPR is really supposed to initialize, so treat it
7460 as being equivalent to anything. */
7461 if ((TREE_CODE (TREE_OPERAND (t1
, 0)) == VAR_DECL
7462 && DECL_NAME (TREE_OPERAND (t1
, 0)) == NULL_TREE
7463 && !DECL_RTL_SET_P (TREE_OPERAND (t1
, 0)))
7464 || (TREE_CODE (TREE_OPERAND (t2
, 0)) == VAR_DECL
7465 && DECL_NAME (TREE_OPERAND (t2
, 0)) == NULL_TREE
7466 && !DECL_RTL_SET_P (TREE_OPERAND (t2
, 0))))
7469 cmp
= simple_cst_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
7474 return simple_cst_equal (TREE_OPERAND (t1
, 1), TREE_OPERAND (t2
, 1));
7476 case WITH_CLEANUP_EXPR
:
7477 cmp
= simple_cst_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
7481 return simple_cst_equal (TREE_OPERAND (t1
, 1), TREE_OPERAND (t1
, 1));
7484 if (TREE_OPERAND (t1
, 1) == TREE_OPERAND (t2
, 1))
7485 return simple_cst_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
7496 if (POLY_INT_CST_P (t1
))
7497 /* A false return means maybe_ne rather than known_ne. */
7498 return known_eq (poly_widest_int::from (poly_int_cst_value (t1
),
7499 TYPE_SIGN (TREE_TYPE (t1
))),
7500 poly_widest_int::from (poly_int_cst_value (t2
),
7501 TYPE_SIGN (TREE_TYPE (t2
))));
7505 /* This general rule works for most tree codes. All exceptions should be
7506 handled above. If this is a language-specific tree code, we can't
7507 trust what might be in the operand, so say we don't know
7509 if ((int) code1
>= (int) LAST_AND_UNUSED_TREE_CODE
)
7512 switch (TREE_CODE_CLASS (code1
))
7516 case tcc_comparison
:
7517 case tcc_expression
:
7521 for (i
= 0; i
< TREE_CODE_LENGTH (code1
); i
++)
7523 cmp
= simple_cst_equal (TREE_OPERAND (t1
, i
), TREE_OPERAND (t2
, i
));
7535 /* Compare the value of T, an INTEGER_CST, with U, an unsigned integer value.
7536 Return -1, 0, or 1 if the value of T is less than, equal to, or greater
7537 than U, respectively. */
7540 compare_tree_int (const_tree t
, unsigned HOST_WIDE_INT u
)
7542 if (tree_int_cst_sgn (t
) < 0)
7544 else if (!tree_fits_uhwi_p (t
))
7546 else if (TREE_INT_CST_LOW (t
) == u
)
7548 else if (TREE_INT_CST_LOW (t
) < u
)
7554 /* Return true if SIZE represents a constant size that is in bounds of
7555 what the middle-end and the backend accepts (covering not more than
7556 half of the address-space).
7557 When PERR is non-null, set *PERR on failure to the description of
7558 why SIZE is not valid. */
7561 valid_constant_size_p (const_tree size
, cst_size_error
*perr
/* = NULL */)
7563 if (POLY_INT_CST_P (size
))
7565 if (TREE_OVERFLOW (size
))
7567 for (unsigned int i
= 0; i
< NUM_POLY_INT_COEFFS
; ++i
)
7568 if (!valid_constant_size_p (POLY_INT_CST_COEFF (size
, i
)))
7573 cst_size_error error
;
7577 if (TREE_CODE (size
) != INTEGER_CST
)
7579 *perr
= cst_size_not_constant
;
7583 if (TREE_OVERFLOW_P (size
))
7585 *perr
= cst_size_overflow
;
7589 if (tree_int_cst_sgn (size
) < 0)
7591 *perr
= cst_size_negative
;
7594 if (!tree_fits_uhwi_p (size
)
7595 || (wi::to_widest (TYPE_MAX_VALUE (sizetype
))
7596 < wi::to_widest (size
) * 2))
7598 *perr
= cst_size_too_big
;
7605 /* Return the precision of the type, or for a complex or vector type the
7606 precision of the type of its elements. */
7609 element_precision (const_tree type
)
7612 type
= TREE_TYPE (type
);
7613 enum tree_code code
= TREE_CODE (type
);
7614 if (code
== COMPLEX_TYPE
|| code
== VECTOR_TYPE
)
7615 type
= TREE_TYPE (type
);
7617 return TYPE_PRECISION (type
);
7620 /* Return true if CODE represents an associative tree code. Otherwise
7623 associative_tree_code (enum tree_code code
)
7642 /* Return true if CODE represents a commutative tree code. Otherwise
7645 commutative_tree_code (enum tree_code code
)
7651 case MULT_HIGHPART_EXPR
:
7659 case UNORDERED_EXPR
:
7663 case TRUTH_AND_EXPR
:
7664 case TRUTH_XOR_EXPR
:
7666 case WIDEN_MULT_EXPR
:
7667 case VEC_WIDEN_MULT_HI_EXPR
:
7668 case VEC_WIDEN_MULT_LO_EXPR
:
7669 case VEC_WIDEN_MULT_EVEN_EXPR
:
7670 case VEC_WIDEN_MULT_ODD_EXPR
:
7679 /* Return true if CODE represents a ternary tree code for which the
7680 first two operands are commutative. Otherwise return false. */
7682 commutative_ternary_tree_code (enum tree_code code
)
7686 case WIDEN_MULT_PLUS_EXPR
:
7687 case WIDEN_MULT_MINUS_EXPR
:
7697 /* Returns true if CODE can overflow. */
7700 operation_can_overflow (enum tree_code code
)
7708 /* Can overflow in various ways. */
7710 case TRUNC_DIV_EXPR
:
7711 case EXACT_DIV_EXPR
:
7712 case FLOOR_DIV_EXPR
:
7714 /* For INT_MIN / -1. */
7721 /* These operators cannot overflow. */
7726 /* Returns true if CODE operating on operands of type TYPE doesn't overflow, or
7727 ftrapv doesn't generate trapping insns for CODE. */
7730 operation_no_trapping_overflow (tree type
, enum tree_code code
)
7732 gcc_checking_assert (ANY_INTEGRAL_TYPE_P (type
));
7734 /* We don't generate instructions that trap on overflow for complex or vector
7736 if (!INTEGRAL_TYPE_P (type
))
7739 if (!TYPE_OVERFLOW_TRAPS (type
))
7749 /* These operators can overflow, and -ftrapv generates trapping code for
7752 case TRUNC_DIV_EXPR
:
7753 case EXACT_DIV_EXPR
:
7754 case FLOOR_DIV_EXPR
:
7757 /* These operators can overflow, but -ftrapv does not generate trapping
7761 /* These operators cannot overflow. */
7769 /* Generate a hash value for an expression. This can be used iteratively
7770 by passing a previous result as the HSTATE argument.
7772 This function is intended to produce the same hash for expressions which
7773 would compare equal using operand_equal_p. */
7775 add_expr (const_tree t
, inchash::hash
&hstate
, unsigned int flags
)
7778 enum tree_code code
;
7779 enum tree_code_class tclass
;
7781 if (t
== NULL_TREE
|| t
== error_mark_node
)
7783 hstate
.merge_hash (0);
7787 STRIP_ANY_LOCATION_WRAPPER (t
);
7789 if (!(flags
& OEP_ADDRESS_OF
))
7792 code
= TREE_CODE (t
);
7796 /* Alas, constants aren't shared, so we can't rely on pointer
7799 hstate
.merge_hash (0);
7802 gcc_checking_assert (!(flags
& OEP_ADDRESS_OF
));
7803 for (i
= 0; i
< TREE_INT_CST_EXT_NUNITS (t
); i
++)
7804 hstate
.add_hwi (TREE_INT_CST_ELT (t
, i
));
7809 if (!HONOR_SIGNED_ZEROS (t
) && real_zerop (t
))
7812 val2
= real_hash (TREE_REAL_CST_PTR (t
));
7813 hstate
.merge_hash (val2
);
7818 unsigned int val2
= fixed_hash (TREE_FIXED_CST_PTR (t
));
7819 hstate
.merge_hash (val2
);
7823 hstate
.add ((const void *) TREE_STRING_POINTER (t
),
7824 TREE_STRING_LENGTH (t
));
7827 inchash::add_expr (TREE_REALPART (t
), hstate
, flags
);
7828 inchash::add_expr (TREE_IMAGPART (t
), hstate
, flags
);
7832 hstate
.add_int (VECTOR_CST_NPATTERNS (t
));
7833 hstate
.add_int (VECTOR_CST_NELTS_PER_PATTERN (t
));
7834 unsigned int count
= vector_cst_encoded_nelts (t
);
7835 for (unsigned int i
= 0; i
< count
; ++i
)
7836 inchash::add_expr (VECTOR_CST_ENCODED_ELT (t
, i
), hstate
, flags
);
7840 /* We can just compare by pointer. */
7841 hstate
.add_hwi (SSA_NAME_VERSION (t
));
7843 case PLACEHOLDER_EXPR
:
7844 /* The node itself doesn't matter. */
7851 /* A list of expressions, for a CALL_EXPR or as the elements of a
7853 for (; t
; t
= TREE_CHAIN (t
))
7854 inchash::add_expr (TREE_VALUE (t
), hstate
, flags
);
7858 unsigned HOST_WIDE_INT idx
;
7860 flags
&= ~OEP_ADDRESS_OF
;
7861 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t
), idx
, field
, value
)
7863 inchash::add_expr (field
, hstate
, flags
);
7864 inchash::add_expr (value
, hstate
, flags
);
7868 case STATEMENT_LIST
:
7870 tree_stmt_iterator i
;
7871 for (i
= tsi_start (CONST_CAST_TREE (t
));
7872 !tsi_end_p (i
); tsi_next (&i
))
7873 inchash::add_expr (tsi_stmt (i
), hstate
, flags
);
7877 for (i
= 0; i
< TREE_VEC_LENGTH (t
); ++i
)
7878 inchash::add_expr (TREE_VEC_ELT (t
, i
), hstate
, flags
);
7880 case IDENTIFIER_NODE
:
7881 hstate
.add_object (IDENTIFIER_HASH_VALUE (t
));
7884 /* When referring to a built-in FUNCTION_DECL, use the __builtin__ form.
7885 Otherwise nodes that compare equal according to operand_equal_p might
7886 get different hash codes. However, don't do this for machine specific
7887 or front end builtins, since the function code is overloaded in those
7889 if (DECL_BUILT_IN_CLASS (t
) == BUILT_IN_NORMAL
7890 && builtin_decl_explicit_p (DECL_FUNCTION_CODE (t
)))
7892 t
= builtin_decl_explicit (DECL_FUNCTION_CODE (t
));
7893 code
= TREE_CODE (t
);
7897 if (POLY_INT_CST_P (t
))
7899 for (unsigned int i
= 0; i
< NUM_POLY_INT_COEFFS
; ++i
)
7900 hstate
.add_wide_int (wi::to_wide (POLY_INT_CST_COEFF (t
, i
)));
7903 tclass
= TREE_CODE_CLASS (code
);
7905 if (tclass
== tcc_declaration
)
7907 /* DECL's have a unique ID */
7908 hstate
.add_hwi (DECL_UID (t
));
7910 else if (tclass
== tcc_comparison
&& !commutative_tree_code (code
))
7912 /* For comparisons that can be swapped, use the lower
7914 enum tree_code ccode
= swap_tree_comparison (code
);
7917 hstate
.add_object (ccode
);
7918 inchash::add_expr (TREE_OPERAND (t
, ccode
!= code
), hstate
, flags
);
7919 inchash::add_expr (TREE_OPERAND (t
, ccode
== code
), hstate
, flags
);
7921 else if (CONVERT_EXPR_CODE_P (code
))
7923 /* NOP_EXPR and CONVERT_EXPR are considered equal by
7925 enum tree_code ccode
= NOP_EXPR
;
7926 hstate
.add_object (ccode
);
7928 /* Don't hash the type, that can lead to having nodes which
7929 compare equal according to operand_equal_p, but which
7930 have different hash codes. Make sure to include signedness
7931 in the hash computation. */
7932 hstate
.add_int (TYPE_UNSIGNED (TREE_TYPE (t
)));
7933 inchash::add_expr (TREE_OPERAND (t
, 0), hstate
, flags
);
7935 /* For OEP_ADDRESS_OF, hash MEM_EXPR[&decl, 0] the same as decl. */
7936 else if (code
== MEM_REF
7937 && (flags
& OEP_ADDRESS_OF
) != 0
7938 && TREE_CODE (TREE_OPERAND (t
, 0)) == ADDR_EXPR
7939 && DECL_P (TREE_OPERAND (TREE_OPERAND (t
, 0), 0))
7940 && integer_zerop (TREE_OPERAND (t
, 1)))
7941 inchash::add_expr (TREE_OPERAND (TREE_OPERAND (t
, 0), 0),
7943 /* Don't ICE on FE specific trees, or their arguments etc.
7944 during operand_equal_p hash verification. */
7945 else if (!IS_EXPR_CODE_CLASS (tclass
))
7946 gcc_assert (flags
& OEP_HASH_CHECK
);
7949 unsigned int sflags
= flags
;
7951 hstate
.add_object (code
);
7956 gcc_checking_assert (!(flags
& OEP_ADDRESS_OF
));
7957 flags
|= OEP_ADDRESS_OF
;
7963 case TARGET_MEM_REF
:
7964 flags
&= ~OEP_ADDRESS_OF
;
7969 case ARRAY_RANGE_REF
:
7972 sflags
&= ~OEP_ADDRESS_OF
;
7976 flags
&= ~OEP_ADDRESS_OF
;
7979 case WIDEN_MULT_PLUS_EXPR
:
7980 case WIDEN_MULT_MINUS_EXPR
:
7982 /* The multiplication operands are commutative. */
7983 inchash::hash one
, two
;
7984 inchash::add_expr (TREE_OPERAND (t
, 0), one
, flags
);
7985 inchash::add_expr (TREE_OPERAND (t
, 1), two
, flags
);
7986 hstate
.add_commutative (one
, two
);
7987 inchash::add_expr (TREE_OPERAND (t
, 2), two
, flags
);
7992 if (CALL_EXPR_FN (t
) == NULL_TREE
)
7993 hstate
.add_int (CALL_EXPR_IFN (t
));
7997 /* For TARGET_EXPR, just hash on the TARGET_EXPR_SLOT.
7998 Usually different TARGET_EXPRs just should use
7999 different temporaries in their slots. */
8000 inchash::add_expr (TARGET_EXPR_SLOT (t
), hstate
, flags
);
8007 /* Don't hash the type, that can lead to having nodes which
8008 compare equal according to operand_equal_p, but which
8009 have different hash codes. */
8010 if (code
== NON_LVALUE_EXPR
)
8012 /* Make sure to include signness in the hash computation. */
8013 hstate
.add_int (TYPE_UNSIGNED (TREE_TYPE (t
)));
8014 inchash::add_expr (TREE_OPERAND (t
, 0), hstate
, flags
);
8017 else if (commutative_tree_code (code
))
8019 /* It's a commutative expression. We want to hash it the same
8020 however it appears. We do this by first hashing both operands
8021 and then rehashing based on the order of their independent
8023 inchash::hash one
, two
;
8024 inchash::add_expr (TREE_OPERAND (t
, 0), one
, flags
);
8025 inchash::add_expr (TREE_OPERAND (t
, 1), two
, flags
);
8026 hstate
.add_commutative (one
, two
);
8029 for (i
= TREE_OPERAND_LENGTH (t
) - 1; i
>= 0; --i
)
8030 inchash::add_expr (TREE_OPERAND (t
, i
), hstate
,
8031 i
== 0 ? flags
: sflags
);
8039 /* Constructors for pointer, array and function types.
8040 (RECORD_TYPE, UNION_TYPE and ENUMERAL_TYPE nodes are
8041 constructed by language-dependent code, not here.) */
8043 /* Construct, lay out and return the type of pointers to TO_TYPE with
8044 mode MODE. If CAN_ALIAS_ALL is TRUE, indicate this type can
8045 reference all of memory. If such a type has already been
8046 constructed, reuse it. */
8049 build_pointer_type_for_mode (tree to_type
, machine_mode mode
,
8053 bool could_alias
= can_alias_all
;
8055 if (to_type
== error_mark_node
)
8056 return error_mark_node
;
8058 /* If the pointed-to type has the may_alias attribute set, force
8059 a TYPE_REF_CAN_ALIAS_ALL pointer to be generated. */
8060 if (lookup_attribute ("may_alias", TYPE_ATTRIBUTES (to_type
)))
8061 can_alias_all
= true;
8063 /* In some cases, languages will have things that aren't a POINTER_TYPE
8064 (such as a RECORD_TYPE for fat pointers in Ada) as TYPE_POINTER_TO.
8065 In that case, return that type without regard to the rest of our
8068 ??? This is a kludge, but consistent with the way this function has
8069 always operated and there doesn't seem to be a good way to avoid this
8071 if (TYPE_POINTER_TO (to_type
) != 0
8072 && TREE_CODE (TYPE_POINTER_TO (to_type
)) != POINTER_TYPE
)
8073 return TYPE_POINTER_TO (to_type
);
8075 /* First, if we already have a type for pointers to TO_TYPE and it's
8076 the proper mode, use it. */
8077 for (t
= TYPE_POINTER_TO (to_type
); t
; t
= TYPE_NEXT_PTR_TO (t
))
8078 if (TYPE_MODE (t
) == mode
&& TYPE_REF_CAN_ALIAS_ALL (t
) == can_alias_all
)
8081 t
= make_node (POINTER_TYPE
);
8083 TREE_TYPE (t
) = to_type
;
8084 SET_TYPE_MODE (t
, mode
);
8085 TYPE_REF_CAN_ALIAS_ALL (t
) = can_alias_all
;
8086 TYPE_NEXT_PTR_TO (t
) = TYPE_POINTER_TO (to_type
);
8087 TYPE_POINTER_TO (to_type
) = t
;
8089 /* During LTO we do not set TYPE_CANONICAL of pointers and references. */
8090 if (TYPE_STRUCTURAL_EQUALITY_P (to_type
) || in_lto_p
)
8091 SET_TYPE_STRUCTURAL_EQUALITY (t
);
8092 else if (TYPE_CANONICAL (to_type
) != to_type
|| could_alias
)
8094 = build_pointer_type_for_mode (TYPE_CANONICAL (to_type
),
8097 /* Lay out the type. This function has many callers that are concerned
8098 with expression-construction, and this simplifies them all. */
8104 /* By default build pointers in ptr_mode. */
8107 build_pointer_type (tree to_type
)
8109 addr_space_t as
= to_type
== error_mark_node
? ADDR_SPACE_GENERIC
8110 : TYPE_ADDR_SPACE (to_type
);
8111 machine_mode pointer_mode
= targetm
.addr_space
.pointer_mode (as
);
8112 return build_pointer_type_for_mode (to_type
, pointer_mode
, false);
8115 /* Same as build_pointer_type_for_mode, but for REFERENCE_TYPE. */
8118 build_reference_type_for_mode (tree to_type
, machine_mode mode
,
8122 bool could_alias
= can_alias_all
;
8124 if (to_type
== error_mark_node
)
8125 return error_mark_node
;
8127 /* If the pointed-to type has the may_alias attribute set, force
8128 a TYPE_REF_CAN_ALIAS_ALL pointer to be generated. */
8129 if (lookup_attribute ("may_alias", TYPE_ATTRIBUTES (to_type
)))
8130 can_alias_all
= true;
8132 /* In some cases, languages will have things that aren't a REFERENCE_TYPE
8133 (such as a RECORD_TYPE for fat pointers in Ada) as TYPE_REFERENCE_TO.
8134 In that case, return that type without regard to the rest of our
8137 ??? This is a kludge, but consistent with the way this function has
8138 always operated and there doesn't seem to be a good way to avoid this
8140 if (TYPE_REFERENCE_TO (to_type
) != 0
8141 && TREE_CODE (TYPE_REFERENCE_TO (to_type
)) != REFERENCE_TYPE
)
8142 return TYPE_REFERENCE_TO (to_type
);
8144 /* First, if we already have a type for pointers to TO_TYPE and it's
8145 the proper mode, use it. */
8146 for (t
= TYPE_REFERENCE_TO (to_type
); t
; t
= TYPE_NEXT_REF_TO (t
))
8147 if (TYPE_MODE (t
) == mode
&& TYPE_REF_CAN_ALIAS_ALL (t
) == can_alias_all
)
8150 t
= make_node (REFERENCE_TYPE
);
8152 TREE_TYPE (t
) = to_type
;
8153 SET_TYPE_MODE (t
, mode
);
8154 TYPE_REF_CAN_ALIAS_ALL (t
) = can_alias_all
;
8155 TYPE_NEXT_REF_TO (t
) = TYPE_REFERENCE_TO (to_type
);
8156 TYPE_REFERENCE_TO (to_type
) = t
;
8158 /* During LTO we do not set TYPE_CANONICAL of pointers and references. */
8159 if (TYPE_STRUCTURAL_EQUALITY_P (to_type
) || in_lto_p
)
8160 SET_TYPE_STRUCTURAL_EQUALITY (t
);
8161 else if (TYPE_CANONICAL (to_type
) != to_type
|| could_alias
)
8163 = build_reference_type_for_mode (TYPE_CANONICAL (to_type
),
8172 /* Build the node for the type of references-to-TO_TYPE by default
8176 build_reference_type (tree to_type
)
8178 addr_space_t as
= to_type
== error_mark_node
? ADDR_SPACE_GENERIC
8179 : TYPE_ADDR_SPACE (to_type
);
8180 machine_mode pointer_mode
= targetm
.addr_space
.pointer_mode (as
);
8181 return build_reference_type_for_mode (to_type
, pointer_mode
, false);
8184 #define MAX_INT_CACHED_PREC \
8185 (HOST_BITS_PER_WIDE_INT > 64 ? HOST_BITS_PER_WIDE_INT : 64)
8186 static GTY(()) tree nonstandard_integer_type_cache
[2 * MAX_INT_CACHED_PREC
+ 2];
8188 /* Builds a signed or unsigned integer type of precision PRECISION.
8189 Used for C bitfields whose precision does not match that of
8190 built-in target types. */
8192 build_nonstandard_integer_type (unsigned HOST_WIDE_INT precision
,
8198 unsignedp
= MAX_INT_CACHED_PREC
+ 1;
8200 if (precision
<= MAX_INT_CACHED_PREC
)
8202 itype
= nonstandard_integer_type_cache
[precision
+ unsignedp
];
8207 itype
= make_node (INTEGER_TYPE
);
8208 TYPE_PRECISION (itype
) = precision
;
8211 fixup_unsigned_type (itype
);
8213 fixup_signed_type (itype
);
8215 inchash::hash hstate
;
8216 inchash::add_expr (TYPE_MAX_VALUE (itype
), hstate
);
8217 ret
= type_hash_canon (hstate
.end (), itype
);
8218 if (precision
<= MAX_INT_CACHED_PREC
)
8219 nonstandard_integer_type_cache
[precision
+ unsignedp
] = ret
;
8224 #define MAX_BOOL_CACHED_PREC \
8225 (HOST_BITS_PER_WIDE_INT > 64 ? HOST_BITS_PER_WIDE_INT : 64)
8226 static GTY(()) tree nonstandard_boolean_type_cache
[MAX_BOOL_CACHED_PREC
+ 1];
8228 /* Builds a boolean type of precision PRECISION.
8229 Used for boolean vectors to choose proper vector element size. */
8231 build_nonstandard_boolean_type (unsigned HOST_WIDE_INT precision
)
8235 if (precision
<= MAX_BOOL_CACHED_PREC
)
8237 type
= nonstandard_boolean_type_cache
[precision
];
8242 type
= make_node (BOOLEAN_TYPE
);
8243 TYPE_PRECISION (type
) = precision
;
8244 fixup_signed_type (type
);
8246 if (precision
<= MAX_INT_CACHED_PREC
)
8247 nonstandard_boolean_type_cache
[precision
] = type
;
8252 /* Create a range of some discrete type TYPE (an INTEGER_TYPE, ENUMERAL_TYPE
8253 or BOOLEAN_TYPE) with low bound LOWVAL and high bound HIGHVAL. If SHARED
8254 is true, reuse such a type that has already been constructed. */
8257 build_range_type_1 (tree type
, tree lowval
, tree highval
, bool shared
)
8259 tree itype
= make_node (INTEGER_TYPE
);
8261 TREE_TYPE (itype
) = type
;
8263 TYPE_MIN_VALUE (itype
) = fold_convert (type
, lowval
);
8264 TYPE_MAX_VALUE (itype
) = highval
? fold_convert (type
, highval
) : NULL
;
8266 TYPE_PRECISION (itype
) = TYPE_PRECISION (type
);
8267 SET_TYPE_MODE (itype
, TYPE_MODE (type
));
8268 TYPE_SIZE (itype
) = TYPE_SIZE (type
);
8269 TYPE_SIZE_UNIT (itype
) = TYPE_SIZE_UNIT (type
);
8270 SET_TYPE_ALIGN (itype
, TYPE_ALIGN (type
));
8271 TYPE_USER_ALIGN (itype
) = TYPE_USER_ALIGN (type
);
8272 SET_TYPE_WARN_IF_NOT_ALIGN (itype
, TYPE_WARN_IF_NOT_ALIGN (type
));
8277 if ((TYPE_MIN_VALUE (itype
)
8278 && TREE_CODE (TYPE_MIN_VALUE (itype
)) != INTEGER_CST
)
8279 || (TYPE_MAX_VALUE (itype
)
8280 && TREE_CODE (TYPE_MAX_VALUE (itype
)) != INTEGER_CST
))
8282 /* Since we cannot reliably merge this type, we need to compare it using
8283 structural equality checks. */
8284 SET_TYPE_STRUCTURAL_EQUALITY (itype
);
8288 hashval_t hash
= type_hash_canon_hash (itype
);
8289 itype
= type_hash_canon (hash
, itype
);
8294 /* Wrapper around build_range_type_1 with SHARED set to true. */
8297 build_range_type (tree type
, tree lowval
, tree highval
)
8299 return build_range_type_1 (type
, lowval
, highval
, true);
8302 /* Wrapper around build_range_type_1 with SHARED set to false. */
8305 build_nonshared_range_type (tree type
, tree lowval
, tree highval
)
8307 return build_range_type_1 (type
, lowval
, highval
, false);
8310 /* Create a type of integers to be the TYPE_DOMAIN of an ARRAY_TYPE.
8311 MAXVAL should be the maximum value in the domain
8312 (one less than the length of the array).
8314 The maximum value that MAXVAL can have is INT_MAX for a HOST_WIDE_INT.
8315 We don't enforce this limit, that is up to caller (e.g. language front end).
8316 The limit exists because the result is a signed type and we don't handle
8317 sizes that use more than one HOST_WIDE_INT. */
8320 build_index_type (tree maxval
)
8322 return build_range_type (sizetype
, size_zero_node
, maxval
);
8325 /* Return true if the debug information for TYPE, a subtype, should be emitted
8326 as a subrange type. If so, set LOWVAL to the low bound and HIGHVAL to the
8327 high bound, respectively. Sometimes doing so unnecessarily obfuscates the
8328 debug info and doesn't reflect the source code. */
8331 subrange_type_for_debug_p (const_tree type
, tree
*lowval
, tree
*highval
)
8333 tree base_type
= TREE_TYPE (type
), low
, high
;
8335 /* Subrange types have a base type which is an integral type. */
8336 if (!INTEGRAL_TYPE_P (base_type
))
8339 /* Get the real bounds of the subtype. */
8340 if (lang_hooks
.types
.get_subrange_bounds
)
8341 lang_hooks
.types
.get_subrange_bounds (type
, &low
, &high
);
8344 low
= TYPE_MIN_VALUE (type
);
8345 high
= TYPE_MAX_VALUE (type
);
8348 /* If the type and its base type have the same representation and the same
8349 name, then the type is not a subrange but a copy of the base type. */
8350 if ((TREE_CODE (base_type
) == INTEGER_TYPE
8351 || TREE_CODE (base_type
) == BOOLEAN_TYPE
)
8352 && int_size_in_bytes (type
) == int_size_in_bytes (base_type
)
8353 && tree_int_cst_equal (low
, TYPE_MIN_VALUE (base_type
))
8354 && tree_int_cst_equal (high
, TYPE_MAX_VALUE (base_type
))
8355 && TYPE_IDENTIFIER (type
) == TYPE_IDENTIFIER (base_type
))
8365 /* Construct, lay out and return the type of arrays of elements with ELT_TYPE
8366 and number of elements specified by the range of values of INDEX_TYPE.
8367 If TYPELESS_STORAGE is true, TYPE_TYPELESS_STORAGE flag is set on the type.
8368 If SHARED is true, reuse such a type that has already been constructed. */
8371 build_array_type_1 (tree elt_type
, tree index_type
, bool typeless_storage
,
8376 if (TREE_CODE (elt_type
) == FUNCTION_TYPE
)
8378 error ("arrays of functions are not meaningful");
8379 elt_type
= integer_type_node
;
8382 t
= make_node (ARRAY_TYPE
);
8383 TREE_TYPE (t
) = elt_type
;
8384 TYPE_DOMAIN (t
) = index_type
;
8385 TYPE_ADDR_SPACE (t
) = TYPE_ADDR_SPACE (elt_type
);
8386 TYPE_TYPELESS_STORAGE (t
) = typeless_storage
;
8389 /* If the element type is incomplete at this point we get marked for
8390 structural equality. Do not record these types in the canonical
8392 if (TYPE_STRUCTURAL_EQUALITY_P (t
))
8397 hashval_t hash
= type_hash_canon_hash (t
);
8398 t
= type_hash_canon (hash
, t
);
8401 if (TYPE_CANONICAL (t
) == t
)
8403 if (TYPE_STRUCTURAL_EQUALITY_P (elt_type
)
8404 || (index_type
&& TYPE_STRUCTURAL_EQUALITY_P (index_type
))
8406 SET_TYPE_STRUCTURAL_EQUALITY (t
);
8407 else if (TYPE_CANONICAL (elt_type
) != elt_type
8408 || (index_type
&& TYPE_CANONICAL (index_type
) != index_type
))
8410 = build_array_type_1 (TYPE_CANONICAL (elt_type
),
8412 ? TYPE_CANONICAL (index_type
) : NULL_TREE
,
8413 typeless_storage
, shared
);
8419 /* Wrapper around build_array_type_1 with SHARED set to true. */
8422 build_array_type (tree elt_type
, tree index_type
, bool typeless_storage
)
8424 return build_array_type_1 (elt_type
, index_type
, typeless_storage
, true);
8427 /* Wrapper around build_array_type_1 with SHARED set to false. */
8430 build_nonshared_array_type (tree elt_type
, tree index_type
)
8432 return build_array_type_1 (elt_type
, index_type
, false, false);
8435 /* Return a representation of ELT_TYPE[NELTS], using indices of type
8439 build_array_type_nelts (tree elt_type
, poly_uint64 nelts
)
8441 return build_array_type (elt_type
, build_index_type (size_int (nelts
- 1)));
8444 /* Recursively examines the array elements of TYPE, until a non-array
8445 element type is found. */
8448 strip_array_types (tree type
)
8450 while (TREE_CODE (type
) == ARRAY_TYPE
)
8451 type
= TREE_TYPE (type
);
8456 /* Computes the canonical argument types from the argument type list
8459 Upon return, *ANY_STRUCTURAL_P will be true iff either it was true
8460 on entry to this function, or if any of the ARGTYPES are
8463 Upon return, *ANY_NONCANONICAL_P will be true iff either it was
8464 true on entry to this function, or if any of the ARGTYPES are
8467 Returns a canonical argument list, which may be ARGTYPES when the
8468 canonical argument list is unneeded (i.e., *ANY_STRUCTURAL_P is
8469 true) or would not differ from ARGTYPES. */
8472 maybe_canonicalize_argtypes (tree argtypes
,
8473 bool *any_structural_p
,
8474 bool *any_noncanonical_p
)
8477 bool any_noncanonical_argtypes_p
= false;
8479 for (arg
= argtypes
; arg
&& !(*any_structural_p
); arg
= TREE_CHAIN (arg
))
8481 if (!TREE_VALUE (arg
) || TREE_VALUE (arg
) == error_mark_node
)
8482 /* Fail gracefully by stating that the type is structural. */
8483 *any_structural_p
= true;
8484 else if (TYPE_STRUCTURAL_EQUALITY_P (TREE_VALUE (arg
)))
8485 *any_structural_p
= true;
8486 else if (TYPE_CANONICAL (TREE_VALUE (arg
)) != TREE_VALUE (arg
)
8487 || TREE_PURPOSE (arg
))
8488 /* If the argument has a default argument, we consider it
8489 non-canonical even though the type itself is canonical.
8490 That way, different variants of function and method types
8491 with default arguments will all point to the variant with
8492 no defaults as their canonical type. */
8493 any_noncanonical_argtypes_p
= true;
8496 if (*any_structural_p
)
8499 if (any_noncanonical_argtypes_p
)
8501 /* Build the canonical list of argument types. */
8502 tree canon_argtypes
= NULL_TREE
;
8503 bool is_void
= false;
8505 for (arg
= argtypes
; arg
; arg
= TREE_CHAIN (arg
))
8507 if (arg
== void_list_node
)
8510 canon_argtypes
= tree_cons (NULL_TREE
,
8511 TYPE_CANONICAL (TREE_VALUE (arg
)),
8515 canon_argtypes
= nreverse (canon_argtypes
);
8517 canon_argtypes
= chainon (canon_argtypes
, void_list_node
);
8519 /* There is a non-canonical type. */
8520 *any_noncanonical_p
= true;
8521 return canon_argtypes
;
8524 /* The canonical argument types are the same as ARGTYPES. */
8528 /* Construct, lay out and return
8529 the type of functions returning type VALUE_TYPE
8530 given arguments of types ARG_TYPES.
8531 ARG_TYPES is a chain of TREE_LIST nodes whose TREE_VALUEs
8532 are data type nodes for the arguments of the function.
8533 If such a type has already been constructed, reuse it. */
8536 build_function_type (tree value_type
, tree arg_types
)
8539 inchash::hash hstate
;
8540 bool any_structural_p
, any_noncanonical_p
;
8541 tree canon_argtypes
;
8543 gcc_assert (arg_types
!= error_mark_node
);
8545 if (TREE_CODE (value_type
) == FUNCTION_TYPE
)
8547 error ("function return type cannot be function");
8548 value_type
= integer_type_node
;
8551 /* Make a node of the sort we want. */
8552 t
= make_node (FUNCTION_TYPE
);
8553 TREE_TYPE (t
) = value_type
;
8554 TYPE_ARG_TYPES (t
) = arg_types
;
8556 /* If we already have such a type, use the old one. */
8557 hashval_t hash
= type_hash_canon_hash (t
);
8558 t
= type_hash_canon (hash
, t
);
8560 /* Set up the canonical type. */
8561 any_structural_p
= TYPE_STRUCTURAL_EQUALITY_P (value_type
);
8562 any_noncanonical_p
= TYPE_CANONICAL (value_type
) != value_type
;
8563 canon_argtypes
= maybe_canonicalize_argtypes (arg_types
,
8565 &any_noncanonical_p
);
8566 if (any_structural_p
)
8567 SET_TYPE_STRUCTURAL_EQUALITY (t
);
8568 else if (any_noncanonical_p
)
8569 TYPE_CANONICAL (t
) = build_function_type (TYPE_CANONICAL (value_type
),
8572 if (!COMPLETE_TYPE_P (t
))
8577 /* Build a function type. The RETURN_TYPE is the type returned by the
8578 function. If VAARGS is set, no void_type_node is appended to the
8579 list. ARGP must be always be terminated be a NULL_TREE. */
8582 build_function_type_list_1 (bool vaargs
, tree return_type
, va_list argp
)
8586 t
= va_arg (argp
, tree
);
8587 for (args
= NULL_TREE
; t
!= NULL_TREE
; t
= va_arg (argp
, tree
))
8588 args
= tree_cons (NULL_TREE
, t
, args
);
8593 if (args
!= NULL_TREE
)
8594 args
= nreverse (args
);
8595 gcc_assert (last
!= void_list_node
);
8597 else if (args
== NULL_TREE
)
8598 args
= void_list_node
;
8602 args
= nreverse (args
);
8603 TREE_CHAIN (last
) = void_list_node
;
8605 args
= build_function_type (return_type
, args
);
8610 /* Build a function type. The RETURN_TYPE is the type returned by the
8611 function. If additional arguments are provided, they are
8612 additional argument types. The list of argument types must always
8613 be terminated by NULL_TREE. */
8616 build_function_type_list (tree return_type
, ...)
8621 va_start (p
, return_type
);
8622 args
= build_function_type_list_1 (false, return_type
, p
);
8627 /* Build a variable argument function type. The RETURN_TYPE is the
8628 type returned by the function. If additional arguments are provided,
8629 they are additional argument types. The list of argument types must
8630 always be terminated by NULL_TREE. */
8633 build_varargs_function_type_list (tree return_type
, ...)
8638 va_start (p
, return_type
);
8639 args
= build_function_type_list_1 (true, return_type
, p
);
8645 /* Build a function type. RETURN_TYPE is the type returned by the
8646 function; VAARGS indicates whether the function takes varargs. The
8647 function takes N named arguments, the types of which are provided in
8651 build_function_type_array_1 (bool vaargs
, tree return_type
, int n
,
8655 tree t
= vaargs
? NULL_TREE
: void_list_node
;
8657 for (i
= n
- 1; i
>= 0; i
--)
8658 t
= tree_cons (NULL_TREE
, arg_types
[i
], t
);
8660 return build_function_type (return_type
, t
);
8663 /* Build a function type. RETURN_TYPE is the type returned by the
8664 function. The function takes N named arguments, the types of which
8665 are provided in ARG_TYPES. */
8668 build_function_type_array (tree return_type
, int n
, tree
*arg_types
)
8670 return build_function_type_array_1 (false, return_type
, n
, arg_types
);
8673 /* Build a variable argument function type. RETURN_TYPE is the type
8674 returned by the function. The function takes N named arguments, the
8675 types of which are provided in ARG_TYPES. */
8678 build_varargs_function_type_array (tree return_type
, int n
, tree
*arg_types
)
8680 return build_function_type_array_1 (true, return_type
, n
, arg_types
);
8683 /* Build a METHOD_TYPE for a member of BASETYPE. The RETTYPE (a TYPE)
8684 and ARGTYPES (a TREE_LIST) are the return type and arguments types
8685 for the method. An implicit additional parameter (of type
8686 pointer-to-BASETYPE) is added to the ARGTYPES. */
8689 build_method_type_directly (tree basetype
,
8695 bool any_structural_p
, any_noncanonical_p
;
8696 tree canon_argtypes
;
8698 /* Make a node of the sort we want. */
8699 t
= make_node (METHOD_TYPE
);
8701 TYPE_METHOD_BASETYPE (t
) = TYPE_MAIN_VARIANT (basetype
);
8702 TREE_TYPE (t
) = rettype
;
8703 ptype
= build_pointer_type (basetype
);
8705 /* The actual arglist for this function includes a "hidden" argument
8706 which is "this". Put it into the list of argument types. */
8707 argtypes
= tree_cons (NULL_TREE
, ptype
, argtypes
);
8708 TYPE_ARG_TYPES (t
) = argtypes
;
8710 /* If we already have such a type, use the old one. */
8711 hashval_t hash
= type_hash_canon_hash (t
);
8712 t
= type_hash_canon (hash
, t
);
8714 /* Set up the canonical type. */
8716 = (TYPE_STRUCTURAL_EQUALITY_P (basetype
)
8717 || TYPE_STRUCTURAL_EQUALITY_P (rettype
));
8719 = (TYPE_CANONICAL (basetype
) != basetype
8720 || TYPE_CANONICAL (rettype
) != rettype
);
8721 canon_argtypes
= maybe_canonicalize_argtypes (TREE_CHAIN (argtypes
),
8723 &any_noncanonical_p
);
8724 if (any_structural_p
)
8725 SET_TYPE_STRUCTURAL_EQUALITY (t
);
8726 else if (any_noncanonical_p
)
8728 = build_method_type_directly (TYPE_CANONICAL (basetype
),
8729 TYPE_CANONICAL (rettype
),
8731 if (!COMPLETE_TYPE_P (t
))
8737 /* Construct, lay out and return the type of methods belonging to class
8738 BASETYPE and whose arguments and values are described by TYPE.
8739 If that type exists already, reuse it.
8740 TYPE must be a FUNCTION_TYPE node. */
8743 build_method_type (tree basetype
, tree type
)
8745 gcc_assert (TREE_CODE (type
) == FUNCTION_TYPE
);
8747 return build_method_type_directly (basetype
,
8749 TYPE_ARG_TYPES (type
));
8752 /* Construct, lay out and return the type of offsets to a value
8753 of type TYPE, within an object of type BASETYPE.
8754 If a suitable offset type exists already, reuse it. */
8757 build_offset_type (tree basetype
, tree type
)
8761 /* Make a node of the sort we want. */
8762 t
= make_node (OFFSET_TYPE
);
8764 TYPE_OFFSET_BASETYPE (t
) = TYPE_MAIN_VARIANT (basetype
);
8765 TREE_TYPE (t
) = type
;
8767 /* If we already have such a type, use the old one. */
8768 hashval_t hash
= type_hash_canon_hash (t
);
8769 t
= type_hash_canon (hash
, t
);
8771 if (!COMPLETE_TYPE_P (t
))
8774 if (TYPE_CANONICAL (t
) == t
)
8776 if (TYPE_STRUCTURAL_EQUALITY_P (basetype
)
8777 || TYPE_STRUCTURAL_EQUALITY_P (type
))
8778 SET_TYPE_STRUCTURAL_EQUALITY (t
);
8779 else if (TYPE_CANONICAL (TYPE_MAIN_VARIANT (basetype
)) != basetype
8780 || TYPE_CANONICAL (type
) != type
)
8782 = build_offset_type (TYPE_CANONICAL (TYPE_MAIN_VARIANT (basetype
)),
8783 TYPE_CANONICAL (type
));
8789 /* Create a complex type whose components are COMPONENT_TYPE.
8791 If NAMED is true, the type is given a TYPE_NAME. We do not always
8792 do so because this creates a DECL node and thus make the DECL_UIDs
8793 dependent on the type canonicalization hashtable, which is GC-ed,
8794 so the DECL_UIDs would not be stable wrt garbage collection. */
8797 build_complex_type (tree component_type
, bool named
)
8799 gcc_assert (INTEGRAL_TYPE_P (component_type
)
8800 || SCALAR_FLOAT_TYPE_P (component_type
)
8801 || FIXED_POINT_TYPE_P (component_type
));
8803 /* Make a node of the sort we want. */
8804 tree probe
= make_node (COMPLEX_TYPE
);
8806 TREE_TYPE (probe
) = TYPE_MAIN_VARIANT (component_type
);
8808 /* If we already have such a type, use the old one. */
8809 hashval_t hash
= type_hash_canon_hash (probe
);
8810 tree t
= type_hash_canon (hash
, probe
);
8814 /* We created a new type. The hash insertion will have laid
8815 out the type. We need to check the canonicalization and
8816 maybe set the name. */
8817 gcc_checking_assert (COMPLETE_TYPE_P (t
)
8819 && TYPE_CANONICAL (t
) == t
);
8821 if (TYPE_STRUCTURAL_EQUALITY_P (TREE_TYPE (t
)))
8822 SET_TYPE_STRUCTURAL_EQUALITY (t
);
8823 else if (TYPE_CANONICAL (TREE_TYPE (t
)) != TREE_TYPE (t
))
8825 = build_complex_type (TYPE_CANONICAL (TREE_TYPE (t
)), named
);
8827 /* We need to create a name, since complex is a fundamental type. */
8830 const char *name
= NULL
;
8832 if (TREE_TYPE (t
) == char_type_node
)
8833 name
= "complex char";
8834 else if (TREE_TYPE (t
) == signed_char_type_node
)
8835 name
= "complex signed char";
8836 else if (TREE_TYPE (t
) == unsigned_char_type_node
)
8837 name
= "complex unsigned char";
8838 else if (TREE_TYPE (t
) == short_integer_type_node
)
8839 name
= "complex short int";
8840 else if (TREE_TYPE (t
) == short_unsigned_type_node
)
8841 name
= "complex short unsigned int";
8842 else if (TREE_TYPE (t
) == integer_type_node
)
8843 name
= "complex int";
8844 else if (TREE_TYPE (t
) == unsigned_type_node
)
8845 name
= "complex unsigned int";
8846 else if (TREE_TYPE (t
) == long_integer_type_node
)
8847 name
= "complex long int";
8848 else if (TREE_TYPE (t
) == long_unsigned_type_node
)
8849 name
= "complex long unsigned int";
8850 else if (TREE_TYPE (t
) == long_long_integer_type_node
)
8851 name
= "complex long long int";
8852 else if (TREE_TYPE (t
) == long_long_unsigned_type_node
)
8853 name
= "complex long long unsigned int";
8856 TYPE_NAME (t
) = build_decl (UNKNOWN_LOCATION
, TYPE_DECL
,
8857 get_identifier (name
), t
);
8861 return build_qualified_type (t
, TYPE_QUALS (component_type
));
8864 /* If TYPE is a real or complex floating-point type and the target
8865 does not directly support arithmetic on TYPE then return the wider
8866 type to be used for arithmetic on TYPE. Otherwise, return
8870 excess_precision_type (tree type
)
8872 /* The target can give two different responses to the question of
8873 which excess precision mode it would like depending on whether we
8874 are in -fexcess-precision=standard or -fexcess-precision=fast. */
8876 enum excess_precision_type requested_type
8877 = (flag_excess_precision
== EXCESS_PRECISION_FAST
8878 ? EXCESS_PRECISION_TYPE_FAST
8879 : EXCESS_PRECISION_TYPE_STANDARD
);
8881 enum flt_eval_method target_flt_eval_method
8882 = targetm
.c
.excess_precision (requested_type
);
8884 /* The target should not ask for unpredictable float evaluation (though
8885 it might advertise that implicitly the evaluation is unpredictable,
8886 but we don't care about that here, it will have been reported
8887 elsewhere). If it does ask for unpredictable evaluation, we have
8888 nothing to do here. */
8889 gcc_assert (target_flt_eval_method
!= FLT_EVAL_METHOD_UNPREDICTABLE
);
8891 /* Nothing to do. The target has asked for all types we know about
8892 to be computed with their native precision and range. */
8893 if (target_flt_eval_method
== FLT_EVAL_METHOD_PROMOTE_TO_FLOAT16
)
8896 /* The target will promote this type in a target-dependent way, so excess
8897 precision ought to leave it alone. */
8898 if (targetm
.promoted_type (type
) != NULL_TREE
)
8901 machine_mode float16_type_mode
= (float16_type_node
8902 ? TYPE_MODE (float16_type_node
)
8904 machine_mode float_type_mode
= TYPE_MODE (float_type_node
);
8905 machine_mode double_type_mode
= TYPE_MODE (double_type_node
);
8907 switch (TREE_CODE (type
))
8911 machine_mode type_mode
= TYPE_MODE (type
);
8912 switch (target_flt_eval_method
)
8914 case FLT_EVAL_METHOD_PROMOTE_TO_FLOAT
:
8915 if (type_mode
== float16_type_mode
)
8916 return float_type_node
;
8918 case FLT_EVAL_METHOD_PROMOTE_TO_DOUBLE
:
8919 if (type_mode
== float16_type_mode
8920 || type_mode
== float_type_mode
)
8921 return double_type_node
;
8923 case FLT_EVAL_METHOD_PROMOTE_TO_LONG_DOUBLE
:
8924 if (type_mode
== float16_type_mode
8925 || type_mode
== float_type_mode
8926 || type_mode
== double_type_mode
)
8927 return long_double_type_node
;
8936 if (TREE_CODE (TREE_TYPE (type
)) != REAL_TYPE
)
8938 machine_mode type_mode
= TYPE_MODE (TREE_TYPE (type
));
8939 switch (target_flt_eval_method
)
8941 case FLT_EVAL_METHOD_PROMOTE_TO_FLOAT
:
8942 if (type_mode
== float16_type_mode
)
8943 return complex_float_type_node
;
8945 case FLT_EVAL_METHOD_PROMOTE_TO_DOUBLE
:
8946 if (type_mode
== float16_type_mode
8947 || type_mode
== float_type_mode
)
8948 return complex_double_type_node
;
8950 case FLT_EVAL_METHOD_PROMOTE_TO_LONG_DOUBLE
:
8951 if (type_mode
== float16_type_mode
8952 || type_mode
== float_type_mode
8953 || type_mode
== double_type_mode
)
8954 return complex_long_double_type_node
;
8968 /* Return OP, stripped of any conversions to wider types as much as is safe.
8969 Converting the value back to OP's type makes a value equivalent to OP.
8971 If FOR_TYPE is nonzero, we return a value which, if converted to
8972 type FOR_TYPE, would be equivalent to converting OP to type FOR_TYPE.
8974 OP must have integer, real or enumeral type. Pointers are not allowed!
8976 There are some cases where the obvious value we could return
8977 would regenerate to OP if converted to OP's type,
8978 but would not extend like OP to wider types.
8979 If FOR_TYPE indicates such extension is contemplated, we eschew such values.
8980 For example, if OP is (unsigned short)(signed char)-1,
8981 we avoid returning (signed char)-1 if FOR_TYPE is int,
8982 even though extending that to an unsigned short would regenerate OP,
8983 since the result of extending (signed char)-1 to (int)
8984 is different from (int) OP. */
8987 get_unwidened (tree op
, tree for_type
)
8989 /* Set UNS initially if converting OP to FOR_TYPE is a zero-extension. */
8990 tree type
= TREE_TYPE (op
);
8992 = TYPE_PRECISION (for_type
!= 0 ? for_type
: type
);
8994 = (for_type
!= 0 && for_type
!= type
8995 && final_prec
> TYPE_PRECISION (type
)
8996 && TYPE_UNSIGNED (type
));
8999 while (CONVERT_EXPR_P (op
))
9003 /* TYPE_PRECISION on vector types has different meaning
9004 (TYPE_VECTOR_SUBPARTS) and casts from vectors are view conversions,
9005 so avoid them here. */
9006 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (op
, 0))) == VECTOR_TYPE
)
9009 bitschange
= TYPE_PRECISION (TREE_TYPE (op
))
9010 - TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op
, 0)));
9012 /* Truncations are many-one so cannot be removed.
9013 Unless we are later going to truncate down even farther. */
9015 && final_prec
> TYPE_PRECISION (TREE_TYPE (op
)))
9018 /* See what's inside this conversion. If we decide to strip it,
9020 op
= TREE_OPERAND (op
, 0);
9022 /* If we have not stripped any zero-extensions (uns is 0),
9023 we can strip any kind of extension.
9024 If we have previously stripped a zero-extension,
9025 only zero-extensions can safely be stripped.
9026 Any extension can be stripped if the bits it would produce
9027 are all going to be discarded later by truncating to FOR_TYPE. */
9031 if (! uns
|| final_prec
<= TYPE_PRECISION (TREE_TYPE (op
)))
9033 /* TYPE_UNSIGNED says whether this is a zero-extension.
9034 Let's avoid computing it if it does not affect WIN
9035 and if UNS will not be needed again. */
9037 || CONVERT_EXPR_P (op
))
9038 && TYPE_UNSIGNED (TREE_TYPE (op
)))
9046 /* If we finally reach a constant see if it fits in sth smaller and
9047 in that case convert it. */
9048 if (TREE_CODE (win
) == INTEGER_CST
)
9050 tree wtype
= TREE_TYPE (win
);
9051 unsigned prec
= wi::min_precision (wi::to_wide (win
), TYPE_SIGN (wtype
));
9053 prec
= MAX (prec
, final_prec
);
9054 if (prec
< TYPE_PRECISION (wtype
))
9056 tree t
= lang_hooks
.types
.type_for_size (prec
, TYPE_UNSIGNED (wtype
));
9057 if (t
&& TYPE_PRECISION (t
) < TYPE_PRECISION (wtype
))
9058 win
= fold_convert (t
, win
);
9065 /* Return OP or a simpler expression for a narrower value
9066 which can be sign-extended or zero-extended to give back OP.
9067 Store in *UNSIGNEDP_PTR either 1 if the value should be zero-extended
9068 or 0 if the value should be sign-extended. */
9071 get_narrower (tree op
, int *unsignedp_ptr
)
9076 bool integral_p
= INTEGRAL_TYPE_P (TREE_TYPE (op
));
9078 while (TREE_CODE (op
) == NOP_EXPR
)
9081 = (TYPE_PRECISION (TREE_TYPE (op
))
9082 - TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op
, 0))));
9084 /* Truncations are many-one so cannot be removed. */
9088 /* See what's inside this conversion. If we decide to strip it,
9093 op
= TREE_OPERAND (op
, 0);
9094 /* An extension: the outermost one can be stripped,
9095 but remember whether it is zero or sign extension. */
9097 uns
= TYPE_UNSIGNED (TREE_TYPE (op
));
9098 /* Otherwise, if a sign extension has been stripped,
9099 only sign extensions can now be stripped;
9100 if a zero extension has been stripped, only zero-extensions. */
9101 else if (uns
!= TYPE_UNSIGNED (TREE_TYPE (op
)))
9105 else /* bitschange == 0 */
9107 /* A change in nominal type can always be stripped, but we must
9108 preserve the unsignedness. */
9110 uns
= TYPE_UNSIGNED (TREE_TYPE (op
));
9112 op
= TREE_OPERAND (op
, 0);
9113 /* Keep trying to narrow, but don't assign op to win if it
9114 would turn an integral type into something else. */
9115 if (INTEGRAL_TYPE_P (TREE_TYPE (op
)) != integral_p
)
9122 if (TREE_CODE (op
) == COMPONENT_REF
9123 /* Since type_for_size always gives an integer type. */
9124 && TREE_CODE (TREE_TYPE (op
)) != REAL_TYPE
9125 && TREE_CODE (TREE_TYPE (op
)) != FIXED_POINT_TYPE
9126 /* Ensure field is laid out already. */
9127 && DECL_SIZE (TREE_OPERAND (op
, 1)) != 0
9128 && tree_fits_uhwi_p (DECL_SIZE (TREE_OPERAND (op
, 1))))
9130 unsigned HOST_WIDE_INT innerprec
9131 = tree_to_uhwi (DECL_SIZE (TREE_OPERAND (op
, 1)));
9132 int unsignedp
= (DECL_UNSIGNED (TREE_OPERAND (op
, 1))
9133 || TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op
, 1))));
9134 tree type
= lang_hooks
.types
.type_for_size (innerprec
, unsignedp
);
9136 /* We can get this structure field in a narrower type that fits it,
9137 but the resulting extension to its nominal type (a fullword type)
9138 must satisfy the same conditions as for other extensions.
9140 Do this only for fields that are aligned (not bit-fields),
9141 because when bit-field insns will be used there is no
9142 advantage in doing this. */
9144 if (innerprec
< TYPE_PRECISION (TREE_TYPE (op
))
9145 && ! DECL_BIT_FIELD (TREE_OPERAND (op
, 1))
9146 && (first
|| uns
== DECL_UNSIGNED (TREE_OPERAND (op
, 1)))
9150 uns
= DECL_UNSIGNED (TREE_OPERAND (op
, 1));
9151 win
= fold_convert (type
, op
);
9155 *unsignedp_ptr
= uns
;
9159 /* Return true if integer constant C has a value that is permissible
9160 for TYPE, an integral type. */
9163 int_fits_type_p (const_tree c
, const_tree type
)
9165 tree type_low_bound
, type_high_bound
;
9166 bool ok_for_low_bound
, ok_for_high_bound
;
9167 signop sgn_c
= TYPE_SIGN (TREE_TYPE (c
));
9169 /* Non-standard boolean types can have arbitrary precision but various
9170 transformations assume that they can only take values 0 and +/-1. */
9171 if (TREE_CODE (type
) == BOOLEAN_TYPE
)
9172 return wi::fits_to_boolean_p (wi::to_wide (c
), type
);
9175 type_low_bound
= TYPE_MIN_VALUE (type
);
9176 type_high_bound
= TYPE_MAX_VALUE (type
);
9178 /* If at least one bound of the type is a constant integer, we can check
9179 ourselves and maybe make a decision. If no such decision is possible, but
9180 this type is a subtype, try checking against that. Otherwise, use
9181 fits_to_tree_p, which checks against the precision.
9183 Compute the status for each possibly constant bound, and return if we see
9184 one does not match. Use ok_for_xxx_bound for this purpose, assigning -1
9185 for "unknown if constant fits", 0 for "constant known *not* to fit" and 1
9186 for "constant known to fit". */
9188 /* Check if c >= type_low_bound. */
9189 if (type_low_bound
&& TREE_CODE (type_low_bound
) == INTEGER_CST
)
9191 if (tree_int_cst_lt (c
, type_low_bound
))
9193 ok_for_low_bound
= true;
9196 ok_for_low_bound
= false;
9198 /* Check if c <= type_high_bound. */
9199 if (type_high_bound
&& TREE_CODE (type_high_bound
) == INTEGER_CST
)
9201 if (tree_int_cst_lt (type_high_bound
, c
))
9203 ok_for_high_bound
= true;
9206 ok_for_high_bound
= false;
9208 /* If the constant fits both bounds, the result is known. */
9209 if (ok_for_low_bound
&& ok_for_high_bound
)
9212 /* Perform some generic filtering which may allow making a decision
9213 even if the bounds are not constant. First, negative integers
9214 never fit in unsigned types, */
9215 if (TYPE_UNSIGNED (type
) && sgn_c
== SIGNED
&& wi::neg_p (wi::to_wide (c
)))
9218 /* Second, narrower types always fit in wider ones. */
9219 if (TYPE_PRECISION (type
) > TYPE_PRECISION (TREE_TYPE (c
)))
9222 /* Third, unsigned integers with top bit set never fit signed types. */
9223 if (!TYPE_UNSIGNED (type
) && sgn_c
== UNSIGNED
)
9225 int prec
= GET_MODE_PRECISION (SCALAR_INT_TYPE_MODE (TREE_TYPE (c
))) - 1;
9226 if (prec
< TYPE_PRECISION (TREE_TYPE (c
)))
9228 /* When a tree_cst is converted to a wide-int, the precision
9229 is taken from the type. However, if the precision of the
9230 mode underneath the type is smaller than that, it is
9231 possible that the value will not fit. The test below
9232 fails if any bit is set between the sign bit of the
9233 underlying mode and the top bit of the type. */
9234 if (wi::zext (wi::to_wide (c
), prec
- 1) != wi::to_wide (c
))
9237 else if (wi::neg_p (wi::to_wide (c
)))
9241 /* If we haven't been able to decide at this point, there nothing more we
9242 can check ourselves here. Look at the base type if we have one and it
9243 has the same precision. */
9244 if (TREE_CODE (type
) == INTEGER_TYPE
9245 && TREE_TYPE (type
) != 0
9246 && TYPE_PRECISION (type
) == TYPE_PRECISION (TREE_TYPE (type
)))
9248 type
= TREE_TYPE (type
);
9252 /* Or to fits_to_tree_p, if nothing else. */
9253 return wi::fits_to_tree_p (wi::to_wide (c
), type
);
9256 /* Stores bounds of an integer TYPE in MIN and MAX. If TYPE has non-constant
9257 bounds or is a POINTER_TYPE, the maximum and/or minimum values that can be
9258 represented (assuming two's-complement arithmetic) within the bit
9259 precision of the type are returned instead. */
9262 get_type_static_bounds (const_tree type
, mpz_t min
, mpz_t max
)
9264 if (!POINTER_TYPE_P (type
) && TYPE_MIN_VALUE (type
)
9265 && TREE_CODE (TYPE_MIN_VALUE (type
)) == INTEGER_CST
)
9266 wi::to_mpz (wi::to_wide (TYPE_MIN_VALUE (type
)), min
, TYPE_SIGN (type
));
9269 if (TYPE_UNSIGNED (type
))
9270 mpz_set_ui (min
, 0);
9273 wide_int mn
= wi::min_value (TYPE_PRECISION (type
), SIGNED
);
9274 wi::to_mpz (mn
, min
, SIGNED
);
9278 if (!POINTER_TYPE_P (type
) && TYPE_MAX_VALUE (type
)
9279 && TREE_CODE (TYPE_MAX_VALUE (type
)) == INTEGER_CST
)
9280 wi::to_mpz (wi::to_wide (TYPE_MAX_VALUE (type
)), max
, TYPE_SIGN (type
));
9283 wide_int mn
= wi::max_value (TYPE_PRECISION (type
), TYPE_SIGN (type
));
9284 wi::to_mpz (mn
, max
, TYPE_SIGN (type
));
9288 /* Return true if VAR is an automatic variable. */
9291 auto_var_p (const_tree var
)
9293 return ((((VAR_P (var
) && ! DECL_EXTERNAL (var
))
9294 || TREE_CODE (var
) == PARM_DECL
)
9295 && ! TREE_STATIC (var
))
9296 || TREE_CODE (var
) == RESULT_DECL
);
9299 /* Return true if VAR is an automatic variable defined in function FN. */
9302 auto_var_in_fn_p (const_tree var
, const_tree fn
)
9304 return (DECL_P (var
) && DECL_CONTEXT (var
) == fn
9305 && (auto_var_p (var
)
9306 || TREE_CODE (var
) == LABEL_DECL
));
9309 /* Subprogram of following function. Called by walk_tree.
9311 Return *TP if it is an automatic variable or parameter of the
9312 function passed in as DATA. */
9315 find_var_from_fn (tree
*tp
, int *walk_subtrees
, void *data
)
9317 tree fn
= (tree
) data
;
9322 else if (DECL_P (*tp
)
9323 && auto_var_in_fn_p (*tp
, fn
))
9329 /* Returns true if T is, contains, or refers to a type with variable
9330 size. For METHOD_TYPEs and FUNCTION_TYPEs we exclude the
9331 arguments, but not the return type. If FN is nonzero, only return
9332 true if a modifier of the type or position of FN is a variable or
9333 parameter inside FN.
9335 This concept is more general than that of C99 'variably modified types':
9336 in C99, a struct type is never variably modified because a VLA may not
9337 appear as a structure member. However, in GNU C code like:
9339 struct S { int i[f()]; };
9341 is valid, and other languages may define similar constructs. */
9344 variably_modified_type_p (tree type
, tree fn
)
9348 /* Test if T is either variable (if FN is zero) or an expression containing
9349 a variable in FN. If TYPE isn't gimplified, return true also if
9350 gimplify_one_sizepos would gimplify the expression into a local
9352 #define RETURN_TRUE_IF_VAR(T) \
9353 do { tree _t = (T); \
9354 if (_t != NULL_TREE \
9355 && _t != error_mark_node \
9356 && !CONSTANT_CLASS_P (_t) \
9357 && TREE_CODE (_t) != PLACEHOLDER_EXPR \
9359 || (!TYPE_SIZES_GIMPLIFIED (type) \
9360 && (TREE_CODE (_t) != VAR_DECL \
9361 && !CONTAINS_PLACEHOLDER_P (_t))) \
9362 || walk_tree (&_t, find_var_from_fn, fn, NULL))) \
9363 return true; } while (0)
9365 if (type
== error_mark_node
)
9368 /* If TYPE itself has variable size, it is variably modified. */
9369 RETURN_TRUE_IF_VAR (TYPE_SIZE (type
));
9370 RETURN_TRUE_IF_VAR (TYPE_SIZE_UNIT (type
));
9372 switch (TREE_CODE (type
))
9375 case REFERENCE_TYPE
:
9377 /* Ada can have pointer types refering to themselves indirectly. */
9378 if (TREE_VISITED (type
))
9380 TREE_VISITED (type
) = true;
9381 if (variably_modified_type_p (TREE_TYPE (type
), fn
))
9383 TREE_VISITED (type
) = false;
9386 TREE_VISITED (type
) = false;
9391 /* If TYPE is a function type, it is variably modified if the
9392 return type is variably modified. */
9393 if (variably_modified_type_p (TREE_TYPE (type
), fn
))
9399 case FIXED_POINT_TYPE
:
9402 /* Scalar types are variably modified if their end points
9404 RETURN_TRUE_IF_VAR (TYPE_MIN_VALUE (type
));
9405 RETURN_TRUE_IF_VAR (TYPE_MAX_VALUE (type
));
9410 case QUAL_UNION_TYPE
:
9411 /* We can't see if any of the fields are variably-modified by the
9412 definition we normally use, since that would produce infinite
9413 recursion via pointers. */
9414 /* This is variably modified if some field's type is. */
9415 for (t
= TYPE_FIELDS (type
); t
; t
= DECL_CHAIN (t
))
9416 if (TREE_CODE (t
) == FIELD_DECL
)
9418 RETURN_TRUE_IF_VAR (DECL_FIELD_OFFSET (t
));
9419 RETURN_TRUE_IF_VAR (DECL_SIZE (t
));
9420 RETURN_TRUE_IF_VAR (DECL_SIZE_UNIT (t
));
9422 if (TREE_CODE (type
) == QUAL_UNION_TYPE
)
9423 RETURN_TRUE_IF_VAR (DECL_QUALIFIER (t
));
9428 /* Do not call ourselves to avoid infinite recursion. This is
9429 variably modified if the element type is. */
9430 RETURN_TRUE_IF_VAR (TYPE_SIZE (TREE_TYPE (type
)));
9431 RETURN_TRUE_IF_VAR (TYPE_SIZE_UNIT (TREE_TYPE (type
)));
9438 /* The current language may have other cases to check, but in general,
9439 all other types are not variably modified. */
9440 return lang_hooks
.tree_inlining
.var_mod_type_p (type
, fn
);
9442 #undef RETURN_TRUE_IF_VAR
9445 /* Given a DECL or TYPE, return the scope in which it was declared, or
9446 NULL_TREE if there is no containing scope. */
9449 get_containing_scope (const_tree t
)
9451 return (TYPE_P (t
) ? TYPE_CONTEXT (t
) : DECL_CONTEXT (t
));
9454 /* Returns the ultimate TRANSLATION_UNIT_DECL context of DECL or NULL. */
9457 get_ultimate_context (const_tree decl
)
9459 while (decl
&& TREE_CODE (decl
) != TRANSLATION_UNIT_DECL
)
9461 if (TREE_CODE (decl
) == BLOCK
)
9462 decl
= BLOCK_SUPERCONTEXT (decl
);
9464 decl
= get_containing_scope (decl
);
9469 /* Return the innermost context enclosing DECL that is
9470 a FUNCTION_DECL, or zero if none. */
9473 decl_function_context (const_tree decl
)
9477 if (TREE_CODE (decl
) == ERROR_MARK
)
9480 /* C++ virtual functions use DECL_CONTEXT for the class of the vtable
9481 where we look up the function at runtime. Such functions always take
9482 a first argument of type 'pointer to real context'.
9484 C++ should really be fixed to use DECL_CONTEXT for the real context,
9485 and use something else for the "virtual context". */
9486 else if (TREE_CODE (decl
) == FUNCTION_DECL
&& DECL_VIRTUAL_P (decl
))
9489 (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl
)))));
9491 context
= DECL_CONTEXT (decl
);
9493 while (context
&& TREE_CODE (context
) != FUNCTION_DECL
)
9495 if (TREE_CODE (context
) == BLOCK
)
9496 context
= BLOCK_SUPERCONTEXT (context
);
9498 context
= get_containing_scope (context
);
9504 /* Return the innermost context enclosing DECL that is
9505 a RECORD_TYPE, UNION_TYPE or QUAL_UNION_TYPE, or zero if none.
9506 TYPE_DECLs and FUNCTION_DECLs are transparent to this function. */
9509 decl_type_context (const_tree decl
)
9511 tree context
= DECL_CONTEXT (decl
);
9514 switch (TREE_CODE (context
))
9516 case NAMESPACE_DECL
:
9517 case TRANSLATION_UNIT_DECL
:
9522 case QUAL_UNION_TYPE
:
9527 context
= DECL_CONTEXT (context
);
9531 context
= BLOCK_SUPERCONTEXT (context
);
9541 /* CALL is a CALL_EXPR. Return the declaration for the function
9542 called, or NULL_TREE if the called function cannot be
9546 get_callee_fndecl (const_tree call
)
9550 if (call
== error_mark_node
)
9551 return error_mark_node
;
9553 /* It's invalid to call this function with anything but a
9555 gcc_assert (TREE_CODE (call
) == CALL_EXPR
);
9557 /* The first operand to the CALL is the address of the function
9559 addr
= CALL_EXPR_FN (call
);
9561 /* If there is no function, return early. */
9562 if (addr
== NULL_TREE
)
9567 /* If this is a readonly function pointer, extract its initial value. */
9568 if (DECL_P (addr
) && TREE_CODE (addr
) != FUNCTION_DECL
9569 && TREE_READONLY (addr
) && ! TREE_THIS_VOLATILE (addr
)
9570 && DECL_INITIAL (addr
))
9571 addr
= DECL_INITIAL (addr
);
9573 /* If the address is just `&f' for some function `f', then we know
9574 that `f' is being called. */
9575 if (TREE_CODE (addr
) == ADDR_EXPR
9576 && TREE_CODE (TREE_OPERAND (addr
, 0)) == FUNCTION_DECL
)
9577 return TREE_OPERAND (addr
, 0);
9579 /* We couldn't figure out what was being called. */
9583 /* If CALL_EXPR CALL calls a normal built-in function or an internal function,
9584 return the associated function code, otherwise return CFN_LAST. */
9587 get_call_combined_fn (const_tree call
)
9589 /* It's invalid to call this function with anything but a CALL_EXPR. */
9590 gcc_assert (TREE_CODE (call
) == CALL_EXPR
);
9592 if (!CALL_EXPR_FN (call
))
9593 return as_combined_fn (CALL_EXPR_IFN (call
));
9595 tree fndecl
= get_callee_fndecl (call
);
9596 if (fndecl
&& fndecl_built_in_p (fndecl
, BUILT_IN_NORMAL
))
9597 return as_combined_fn (DECL_FUNCTION_CODE (fndecl
));
9602 /* Comparator of indices based on tree_node_counts. */
9605 tree_nodes_cmp (const void *p1
, const void *p2
)
9607 const unsigned *n1
= (const unsigned *)p1
;
9608 const unsigned *n2
= (const unsigned *)p2
;
9610 return tree_node_counts
[*n1
] - tree_node_counts
[*n2
];
9613 /* Comparator of indices based on tree_code_counts. */
9616 tree_codes_cmp (const void *p1
, const void *p2
)
9618 const unsigned *n1
= (const unsigned *)p1
;
9619 const unsigned *n2
= (const unsigned *)p2
;
9621 return tree_code_counts
[*n1
] - tree_code_counts
[*n2
];
9624 #define TREE_MEM_USAGE_SPACES 40
9626 /* Print debugging information about tree nodes generated during the compile,
9627 and any language-specific information. */
9630 dump_tree_statistics (void)
9632 if (GATHER_STATISTICS
)
9634 uint64_t total_nodes
, total_bytes
;
9635 fprintf (stderr
, "\nKind Nodes Bytes\n");
9636 mem_usage::print_dash_line (TREE_MEM_USAGE_SPACES
);
9637 total_nodes
= total_bytes
= 0;
9640 auto_vec
<unsigned> indices (all_kinds
);
9641 for (unsigned i
= 0; i
< all_kinds
; i
++)
9642 indices
.quick_push (i
);
9643 indices
.qsort (tree_nodes_cmp
);
9645 for (unsigned i
= 0; i
< (int) all_kinds
; i
++)
9647 unsigned j
= indices
[i
];
9648 fprintf (stderr
, "%-20s %6" PRIu64
"%c %9" PRIu64
"%c\n",
9649 tree_node_kind_names
[i
], SIZE_AMOUNT (tree_node_counts
[j
]),
9650 SIZE_AMOUNT (tree_node_sizes
[j
]));
9651 total_nodes
+= tree_node_counts
[j
];
9652 total_bytes
+= tree_node_sizes
[j
];
9654 mem_usage::print_dash_line (TREE_MEM_USAGE_SPACES
);
9655 fprintf (stderr
, "%-20s %6" PRIu64
"%c %9" PRIu64
"%c\n", "Total",
9656 SIZE_AMOUNT (total_nodes
), SIZE_AMOUNT (total_bytes
));
9657 mem_usage::print_dash_line (TREE_MEM_USAGE_SPACES
);
9661 fprintf (stderr
, "Code Nodes\n");
9662 mem_usage::print_dash_line (TREE_MEM_USAGE_SPACES
);
9664 auto_vec
<unsigned> indices (MAX_TREE_CODES
);
9665 for (unsigned i
= 0; i
< MAX_TREE_CODES
; i
++)
9666 indices
.quick_push (i
);
9667 indices
.qsort (tree_codes_cmp
);
9669 for (unsigned i
= 0; i
< MAX_TREE_CODES
; i
++)
9671 unsigned j
= indices
[i
];
9672 fprintf (stderr
, "%-32s %6" PRIu64
"%c\n",
9673 get_tree_code_name ((enum tree_code
) j
),
9674 SIZE_AMOUNT (tree_code_counts
[j
]));
9676 mem_usage::print_dash_line (TREE_MEM_USAGE_SPACES
);
9677 fprintf (stderr
, "\n");
9678 ssanames_print_statistics ();
9679 fprintf (stderr
, "\n");
9680 phinodes_print_statistics ();
9681 fprintf (stderr
, "\n");
9685 fprintf (stderr
, "(No per-node statistics)\n");
9687 print_type_hash_statistics ();
9688 print_debug_expr_statistics ();
9689 print_value_expr_statistics ();
9690 lang_hooks
.print_statistics ();
9693 #define FILE_FUNCTION_FORMAT "_GLOBAL__%s_%s"
9695 /* Generate a crc32 of the low BYTES bytes of VALUE. */
9698 crc32_unsigned_n (unsigned chksum
, unsigned value
, unsigned bytes
)
9700 /* This relies on the raw feedback's top 4 bits being zero. */
9701 #define FEEDBACK(X) ((X) * 0x04c11db7)
9702 #define SYNDROME(X) (FEEDBACK ((X) & 1) ^ FEEDBACK ((X) & 2) \
9703 ^ FEEDBACK ((X) & 4) ^ FEEDBACK ((X) & 8))
9704 static const unsigned syndromes
[16] =
9706 SYNDROME(0x0), SYNDROME(0x1), SYNDROME(0x2), SYNDROME(0x3),
9707 SYNDROME(0x4), SYNDROME(0x5), SYNDROME(0x6), SYNDROME(0x7),
9708 SYNDROME(0x8), SYNDROME(0x9), SYNDROME(0xa), SYNDROME(0xb),
9709 SYNDROME(0xc), SYNDROME(0xd), SYNDROME(0xe), SYNDROME(0xf),
9714 value
<<= (32 - bytes
* 8);
9715 for (unsigned ix
= bytes
* 2; ix
--; value
<<= 4)
9717 unsigned feedback
= syndromes
[((value
^ chksum
) >> 28) & 0xf];
9719 chksum
= (chksum
<< 4) ^ feedback
;
9725 /* Generate a crc32 of a string. */
9728 crc32_string (unsigned chksum
, const char *string
)
9731 chksum
= crc32_byte (chksum
, *string
);
9736 /* P is a string that will be used in a symbol. Mask out any characters
9737 that are not valid in that context. */
9740 clean_symbol_name (char *p
)
9744 #ifndef NO_DOLLAR_IN_LABEL /* this for `$'; unlikely, but... -- kr */
9747 #ifndef NO_DOT_IN_LABEL /* this for `.'; unlikely, but... */
9754 static GTY(()) unsigned anon_cnt
= 0; /* Saved for PCH. */
9756 /* Create a unique anonymous identifier. The identifier is still a
9757 valid assembly label. */
9763 #if !defined (NO_DOT_IN_LABEL)
9765 #elif !defined (NO_DOLLAR_IN_LABEL)
9773 int len
= snprintf (buf
, sizeof (buf
), fmt
, anon_cnt
++);
9774 gcc_checking_assert (len
< int (sizeof (buf
)));
9776 tree id
= get_identifier_with_length (buf
, len
);
9777 IDENTIFIER_ANON_P (id
) = true;
9782 /* Generate a name for a special-purpose function.
9783 The generated name may need to be unique across the whole link.
9784 Changes to this function may also require corresponding changes to
9785 xstrdup_mask_random.
9786 TYPE is some string to identify the purpose of this function to the
9787 linker or collect2; it must start with an uppercase letter,
9789 I - for constructors
9791 N - for C++ anonymous namespaces
9792 F - for DWARF unwind frame information. */
9795 get_file_function_name (const char *type
)
9801 /* If we already have a name we know to be unique, just use that. */
9802 if (first_global_object_name
)
9803 p
= q
= ASTRDUP (first_global_object_name
);
9804 /* If the target is handling the constructors/destructors, they
9805 will be local to this file and the name is only necessary for
9807 We also assign sub_I and sub_D sufixes to constructors called from
9808 the global static constructors. These are always local. */
9809 else if (((type
[0] == 'I' || type
[0] == 'D') && targetm
.have_ctors_dtors
)
9810 || (strncmp (type
, "sub_", 4) == 0
9811 && (type
[4] == 'I' || type
[4] == 'D')))
9813 const char *file
= main_input_filename
;
9815 file
= LOCATION_FILE (input_location
);
9816 /* Just use the file's basename, because the full pathname
9817 might be quite long. */
9818 p
= q
= ASTRDUP (lbasename (file
));
9822 /* Otherwise, the name must be unique across the entire link.
9823 We don't have anything that we know to be unique to this translation
9824 unit, so use what we do have and throw in some randomness. */
9826 const char *name
= weak_global_object_name
;
9827 const char *file
= main_input_filename
;
9832 file
= LOCATION_FILE (input_location
);
9834 len
= strlen (file
);
9835 q
= (char *) alloca (9 + 19 + len
+ 1);
9836 memcpy (q
, file
, len
+ 1);
9838 snprintf (q
+ len
, 9 + 19 + 1, "_%08X_" HOST_WIDE_INT_PRINT_HEX
,
9839 crc32_string (0, name
), get_random_seed (false));
9844 clean_symbol_name (q
);
9845 buf
= (char *) alloca (sizeof (FILE_FUNCTION_FORMAT
) + strlen (p
)
9848 /* Set up the name of the file-level functions we may need.
9849 Use a global object (which is already required to be unique over
9850 the program) rather than the file name (which imposes extra
9852 sprintf (buf
, FILE_FUNCTION_FORMAT
, type
, p
);
9854 return get_identifier (buf
);
9857 #if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
9859 /* Complain that the tree code of NODE does not match the expected 0
9860 terminated list of trailing codes. The trailing code list can be
9861 empty, for a more vague error message. FILE, LINE, and FUNCTION
9862 are of the caller. */
9865 tree_check_failed (const_tree node
, const char *file
,
9866 int line
, const char *function
, ...)
9870 unsigned length
= 0;
9871 enum tree_code code
;
9873 va_start (args
, function
);
9874 while ((code
= (enum tree_code
) va_arg (args
, int)))
9875 length
+= 4 + strlen (get_tree_code_name (code
));
9880 va_start (args
, function
);
9881 length
+= strlen ("expected ");
9882 buffer
= tmp
= (char *) alloca (length
);
9884 while ((code
= (enum tree_code
) va_arg (args
, int)))
9886 const char *prefix
= length
? " or " : "expected ";
9888 strcpy (tmp
+ length
, prefix
);
9889 length
+= strlen (prefix
);
9890 strcpy (tmp
+ length
, get_tree_code_name (code
));
9891 length
+= strlen (get_tree_code_name (code
));
9896 buffer
= "unexpected node";
9898 internal_error ("tree check: %s, have %s in %s, at %s:%d",
9899 buffer
, get_tree_code_name (TREE_CODE (node
)),
9900 function
, trim_filename (file
), line
);
9903 /* Complain that the tree code of NODE does match the expected 0
9904 terminated list of trailing codes. FILE, LINE, and FUNCTION are of
9908 tree_not_check_failed (const_tree node
, const char *file
,
9909 int line
, const char *function
, ...)
9913 unsigned length
= 0;
9914 enum tree_code code
;
9916 va_start (args
, function
);
9917 while ((code
= (enum tree_code
) va_arg (args
, int)))
9918 length
+= 4 + strlen (get_tree_code_name (code
));
9920 va_start (args
, function
);
9921 buffer
= (char *) alloca (length
);
9923 while ((code
= (enum tree_code
) va_arg (args
, int)))
9927 strcpy (buffer
+ length
, " or ");
9930 strcpy (buffer
+ length
, get_tree_code_name (code
));
9931 length
+= strlen (get_tree_code_name (code
));
9935 internal_error ("tree check: expected none of %s, have %s in %s, at %s:%d",
9936 buffer
, get_tree_code_name (TREE_CODE (node
)),
9937 function
, trim_filename (file
), line
);
9940 /* Similar to tree_check_failed, except that we check for a class of tree
9941 code, given in CL. */
9944 tree_class_check_failed (const_tree node
, const enum tree_code_class cl
,
9945 const char *file
, int line
, const char *function
)
9948 ("tree check: expected class %qs, have %qs (%s) in %s, at %s:%d",
9949 TREE_CODE_CLASS_STRING (cl
),
9950 TREE_CODE_CLASS_STRING (TREE_CODE_CLASS (TREE_CODE (node
))),
9951 get_tree_code_name (TREE_CODE (node
)), function
, trim_filename (file
), line
);
9954 /* Similar to tree_check_failed, except that instead of specifying a
9955 dozen codes, use the knowledge that they're all sequential. */
9958 tree_range_check_failed (const_tree node
, const char *file
, int line
,
9959 const char *function
, enum tree_code c1
,
9963 unsigned length
= 0;
9966 for (c
= c1
; c
<= c2
; ++c
)
9967 length
+= 4 + strlen (get_tree_code_name ((enum tree_code
) c
));
9969 length
+= strlen ("expected ");
9970 buffer
= (char *) alloca (length
);
9973 for (c
= c1
; c
<= c2
; ++c
)
9975 const char *prefix
= length
? " or " : "expected ";
9977 strcpy (buffer
+ length
, prefix
);
9978 length
+= strlen (prefix
);
9979 strcpy (buffer
+ length
, get_tree_code_name ((enum tree_code
) c
));
9980 length
+= strlen (get_tree_code_name ((enum tree_code
) c
));
9983 internal_error ("tree check: %s, have %s in %s, at %s:%d",
9984 buffer
, get_tree_code_name (TREE_CODE (node
)),
9985 function
, trim_filename (file
), line
);
9989 /* Similar to tree_check_failed, except that we check that a tree does
9990 not have the specified code, given in CL. */
9993 tree_not_class_check_failed (const_tree node
, const enum tree_code_class cl
,
9994 const char *file
, int line
, const char *function
)
9997 ("tree check: did not expect class %qs, have %qs (%s) in %s, at %s:%d",
9998 TREE_CODE_CLASS_STRING (cl
),
9999 TREE_CODE_CLASS_STRING (TREE_CODE_CLASS (TREE_CODE (node
))),
10000 get_tree_code_name (TREE_CODE (node
)), function
, trim_filename (file
), line
);
10004 /* Similar to tree_check_failed but applied to OMP_CLAUSE codes. */
10007 omp_clause_check_failed (const_tree node
, const char *file
, int line
,
10008 const char *function
, enum omp_clause_code code
)
10010 internal_error ("tree check: expected %<omp_clause %s%>, have %qs "
10012 omp_clause_code_name
[code
],
10013 get_tree_code_name (TREE_CODE (node
)),
10014 function
, trim_filename (file
), line
);
10018 /* Similar to tree_range_check_failed but applied to OMP_CLAUSE codes. */
10021 omp_clause_range_check_failed (const_tree node
, const char *file
, int line
,
10022 const char *function
, enum omp_clause_code c1
,
10023 enum omp_clause_code c2
)
10026 unsigned length
= 0;
10029 for (c
= c1
; c
<= c2
; ++c
)
10030 length
+= 4 + strlen (omp_clause_code_name
[c
]);
10032 length
+= strlen ("expected ");
10033 buffer
= (char *) alloca (length
);
10036 for (c
= c1
; c
<= c2
; ++c
)
10038 const char *prefix
= length
? " or " : "expected ";
10040 strcpy (buffer
+ length
, prefix
);
10041 length
+= strlen (prefix
);
10042 strcpy (buffer
+ length
, omp_clause_code_name
[c
]);
10043 length
+= strlen (omp_clause_code_name
[c
]);
10046 internal_error ("tree check: %s, have %s in %s, at %s:%d",
10047 buffer
, omp_clause_code_name
[TREE_CODE (node
)],
10048 function
, trim_filename (file
), line
);
10052 #undef DEFTREESTRUCT
10053 #define DEFTREESTRUCT(VAL, NAME) NAME,
10055 static const char *ts_enum_names
[] = {
10056 #include "treestruct.def"
10058 #undef DEFTREESTRUCT
10060 #define TS_ENUM_NAME(EN) (ts_enum_names[(EN)])
10062 /* Similar to tree_class_check_failed, except that we check for
10063 whether CODE contains the tree structure identified by EN. */
10066 tree_contains_struct_check_failed (const_tree node
,
10067 const enum tree_node_structure_enum en
,
10068 const char *file
, int line
,
10069 const char *function
)
10072 ("tree check: expected tree that contains %qs structure, have %qs in %s, at %s:%d",
10074 get_tree_code_name (TREE_CODE (node
)), function
, trim_filename (file
), line
);
10078 /* Similar to above, except that the check is for the bounds of a TREE_VEC's
10079 (dynamically sized) vector. */
10082 tree_int_cst_elt_check_failed (int idx
, int len
, const char *file
, int line
,
10083 const char *function
)
10086 ("tree check: accessed elt %d of %<tree_int_cst%> with %d elts in %s, "
10088 idx
+ 1, len
, function
, trim_filename (file
), line
);
10091 /* Similar to above, except that the check is for the bounds of a TREE_VEC's
10092 (dynamically sized) vector. */
10095 tree_vec_elt_check_failed (int idx
, int len
, const char *file
, int line
,
10096 const char *function
)
10099 ("tree check: accessed elt %d of %<tree_vec%> with %d elts in %s, at %s:%d",
10100 idx
+ 1, len
, function
, trim_filename (file
), line
);
10103 /* Similar to above, except that the check is for the bounds of the operand
10104 vector of an expression node EXP. */
10107 tree_operand_check_failed (int idx
, const_tree exp
, const char *file
,
10108 int line
, const char *function
)
10110 enum tree_code code
= TREE_CODE (exp
);
10112 ("tree check: accessed operand %d of %s with %d operands in %s, at %s:%d",
10113 idx
+ 1, get_tree_code_name (code
), TREE_OPERAND_LENGTH (exp
),
10114 function
, trim_filename (file
), line
);
10117 /* Similar to above, except that the check is for the number of
10118 operands of an OMP_CLAUSE node. */
10121 omp_clause_operand_check_failed (int idx
, const_tree t
, const char *file
,
10122 int line
, const char *function
)
10125 ("tree check: accessed operand %d of %<omp_clause %s%> with %d operands "
10126 "in %s, at %s:%d", idx
+ 1, omp_clause_code_name
[OMP_CLAUSE_CODE (t
)],
10127 omp_clause_num_ops
[OMP_CLAUSE_CODE (t
)], function
,
10128 trim_filename (file
), line
);
10130 #endif /* ENABLE_TREE_CHECKING */
10132 /* Create a new vector type node holding NUNITS units of type INNERTYPE,
10133 and mapped to the machine mode MODE. Initialize its fields and build
10134 the information necessary for debugging output. */
10137 make_vector_type (tree innertype
, poly_int64 nunits
, machine_mode mode
)
10140 tree mv_innertype
= TYPE_MAIN_VARIANT (innertype
);
10142 t
= make_node (VECTOR_TYPE
);
10143 TREE_TYPE (t
) = mv_innertype
;
10144 SET_TYPE_VECTOR_SUBPARTS (t
, nunits
);
10145 SET_TYPE_MODE (t
, mode
);
10147 if (TYPE_STRUCTURAL_EQUALITY_P (mv_innertype
) || in_lto_p
)
10148 SET_TYPE_STRUCTURAL_EQUALITY (t
);
10149 else if ((TYPE_CANONICAL (mv_innertype
) != innertype
10150 || mode
!= VOIDmode
)
10151 && !VECTOR_BOOLEAN_TYPE_P (t
))
10153 = make_vector_type (TYPE_CANONICAL (mv_innertype
), nunits
, VOIDmode
);
10157 hashval_t hash
= type_hash_canon_hash (t
);
10158 t
= type_hash_canon (hash
, t
);
10160 /* We have built a main variant, based on the main variant of the
10161 inner type. Use it to build the variant we return. */
10162 if ((TYPE_ATTRIBUTES (innertype
) || TYPE_QUALS (innertype
))
10163 && TREE_TYPE (t
) != innertype
)
10164 return build_type_attribute_qual_variant (t
,
10165 TYPE_ATTRIBUTES (innertype
),
10166 TYPE_QUALS (innertype
));
10172 make_or_reuse_type (unsigned size
, int unsignedp
)
10176 if (size
== INT_TYPE_SIZE
)
10177 return unsignedp
? unsigned_type_node
: integer_type_node
;
10178 if (size
== CHAR_TYPE_SIZE
)
10179 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
10180 if (size
== SHORT_TYPE_SIZE
)
10181 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
10182 if (size
== LONG_TYPE_SIZE
)
10183 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
10184 if (size
== LONG_LONG_TYPE_SIZE
)
10185 return (unsignedp
? long_long_unsigned_type_node
10186 : long_long_integer_type_node
);
10188 for (i
= 0; i
< NUM_INT_N_ENTS
; i
++)
10189 if (size
== int_n_data
[i
].bitsize
10190 && int_n_enabled_p
[i
])
10191 return (unsignedp
? int_n_trees
[i
].unsigned_type
10192 : int_n_trees
[i
].signed_type
);
10195 return make_unsigned_type (size
);
10197 return make_signed_type (size
);
10200 /* Create or reuse a fract type by SIZE, UNSIGNEDP, and SATP. */
10203 make_or_reuse_fract_type (unsigned size
, int unsignedp
, int satp
)
10207 if (size
== SHORT_FRACT_TYPE_SIZE
)
10208 return unsignedp
? sat_unsigned_short_fract_type_node
10209 : sat_short_fract_type_node
;
10210 if (size
== FRACT_TYPE_SIZE
)
10211 return unsignedp
? sat_unsigned_fract_type_node
: sat_fract_type_node
;
10212 if (size
== LONG_FRACT_TYPE_SIZE
)
10213 return unsignedp
? sat_unsigned_long_fract_type_node
10214 : sat_long_fract_type_node
;
10215 if (size
== LONG_LONG_FRACT_TYPE_SIZE
)
10216 return unsignedp
? sat_unsigned_long_long_fract_type_node
10217 : sat_long_long_fract_type_node
;
10221 if (size
== SHORT_FRACT_TYPE_SIZE
)
10222 return unsignedp
? unsigned_short_fract_type_node
10223 : short_fract_type_node
;
10224 if (size
== FRACT_TYPE_SIZE
)
10225 return unsignedp
? unsigned_fract_type_node
: fract_type_node
;
10226 if (size
== LONG_FRACT_TYPE_SIZE
)
10227 return unsignedp
? unsigned_long_fract_type_node
10228 : long_fract_type_node
;
10229 if (size
== LONG_LONG_FRACT_TYPE_SIZE
)
10230 return unsignedp
? unsigned_long_long_fract_type_node
10231 : long_long_fract_type_node
;
10234 return make_fract_type (size
, unsignedp
, satp
);
10237 /* Create or reuse an accum type by SIZE, UNSIGNEDP, and SATP. */
10240 make_or_reuse_accum_type (unsigned size
, int unsignedp
, int satp
)
10244 if (size
== SHORT_ACCUM_TYPE_SIZE
)
10245 return unsignedp
? sat_unsigned_short_accum_type_node
10246 : sat_short_accum_type_node
;
10247 if (size
== ACCUM_TYPE_SIZE
)
10248 return unsignedp
? sat_unsigned_accum_type_node
: sat_accum_type_node
;
10249 if (size
== LONG_ACCUM_TYPE_SIZE
)
10250 return unsignedp
? sat_unsigned_long_accum_type_node
10251 : sat_long_accum_type_node
;
10252 if (size
== LONG_LONG_ACCUM_TYPE_SIZE
)
10253 return unsignedp
? sat_unsigned_long_long_accum_type_node
10254 : sat_long_long_accum_type_node
;
10258 if (size
== SHORT_ACCUM_TYPE_SIZE
)
10259 return unsignedp
? unsigned_short_accum_type_node
10260 : short_accum_type_node
;
10261 if (size
== ACCUM_TYPE_SIZE
)
10262 return unsignedp
? unsigned_accum_type_node
: accum_type_node
;
10263 if (size
== LONG_ACCUM_TYPE_SIZE
)
10264 return unsignedp
? unsigned_long_accum_type_node
10265 : long_accum_type_node
;
10266 if (size
== LONG_LONG_ACCUM_TYPE_SIZE
)
10267 return unsignedp
? unsigned_long_long_accum_type_node
10268 : long_long_accum_type_node
;
10271 return make_accum_type (size
, unsignedp
, satp
);
10275 /* Create an atomic variant node for TYPE. This routine is called
10276 during initialization of data types to create the 5 basic atomic
10277 types. The generic build_variant_type function requires these to
10278 already be set up in order to function properly, so cannot be
10279 called from there. If ALIGN is non-zero, then ensure alignment is
10280 overridden to this value. */
10283 build_atomic_base (tree type
, unsigned int align
)
10287 /* Make sure its not already registered. */
10288 if ((t
= get_qualified_type (type
, TYPE_QUAL_ATOMIC
)))
10291 t
= build_variant_type_copy (type
);
10292 set_type_quals (t
, TYPE_QUAL_ATOMIC
);
10295 SET_TYPE_ALIGN (t
, align
);
10300 /* Information about the _FloatN and _FloatNx types. This must be in
10301 the same order as the corresponding TI_* enum values. */
10302 const floatn_type_info floatn_nx_types
[NUM_FLOATN_NX_TYPES
] =
10314 /* Create nodes for all integer types (and error_mark_node) using the sizes
10315 of C datatypes. SIGNED_CHAR specifies whether char is signed. */
10318 build_common_tree_nodes (bool signed_char
)
10322 error_mark_node
= make_node (ERROR_MARK
);
10323 TREE_TYPE (error_mark_node
) = error_mark_node
;
10325 initialize_sizetypes ();
10327 /* Define both `signed char' and `unsigned char'. */
10328 signed_char_type_node
= make_signed_type (CHAR_TYPE_SIZE
);
10329 TYPE_STRING_FLAG (signed_char_type_node
) = 1;
10330 unsigned_char_type_node
= make_unsigned_type (CHAR_TYPE_SIZE
);
10331 TYPE_STRING_FLAG (unsigned_char_type_node
) = 1;
10333 /* Define `char', which is like either `signed char' or `unsigned char'
10334 but not the same as either. */
10337 ? make_signed_type (CHAR_TYPE_SIZE
)
10338 : make_unsigned_type (CHAR_TYPE_SIZE
));
10339 TYPE_STRING_FLAG (char_type_node
) = 1;
10341 short_integer_type_node
= make_signed_type (SHORT_TYPE_SIZE
);
10342 short_unsigned_type_node
= make_unsigned_type (SHORT_TYPE_SIZE
);
10343 integer_type_node
= make_signed_type (INT_TYPE_SIZE
);
10344 unsigned_type_node
= make_unsigned_type (INT_TYPE_SIZE
);
10345 long_integer_type_node
= make_signed_type (LONG_TYPE_SIZE
);
10346 long_unsigned_type_node
= make_unsigned_type (LONG_TYPE_SIZE
);
10347 long_long_integer_type_node
= make_signed_type (LONG_LONG_TYPE_SIZE
);
10348 long_long_unsigned_type_node
= make_unsigned_type (LONG_LONG_TYPE_SIZE
);
10350 for (i
= 0; i
< NUM_INT_N_ENTS
; i
++)
10352 int_n_trees
[i
].signed_type
= make_signed_type (int_n_data
[i
].bitsize
);
10353 int_n_trees
[i
].unsigned_type
= make_unsigned_type (int_n_data
[i
].bitsize
);
10355 if (int_n_enabled_p
[i
])
10357 integer_types
[itk_intN_0
+ i
* 2] = int_n_trees
[i
].signed_type
;
10358 integer_types
[itk_unsigned_intN_0
+ i
* 2] = int_n_trees
[i
].unsigned_type
;
10362 /* Define a boolean type. This type only represents boolean values but
10363 may be larger than char depending on the value of BOOL_TYPE_SIZE. */
10364 boolean_type_node
= make_unsigned_type (BOOL_TYPE_SIZE
);
10365 TREE_SET_CODE (boolean_type_node
, BOOLEAN_TYPE
);
10366 TYPE_PRECISION (boolean_type_node
) = 1;
10367 TYPE_MAX_VALUE (boolean_type_node
) = build_int_cst (boolean_type_node
, 1);
10369 /* Define what type to use for size_t. */
10370 if (strcmp (SIZE_TYPE
, "unsigned int") == 0)
10371 size_type_node
= unsigned_type_node
;
10372 else if (strcmp (SIZE_TYPE
, "long unsigned int") == 0)
10373 size_type_node
= long_unsigned_type_node
;
10374 else if (strcmp (SIZE_TYPE
, "long long unsigned int") == 0)
10375 size_type_node
= long_long_unsigned_type_node
;
10376 else if (strcmp (SIZE_TYPE
, "short unsigned int") == 0)
10377 size_type_node
= short_unsigned_type_node
;
10382 size_type_node
= NULL_TREE
;
10383 for (i
= 0; i
< NUM_INT_N_ENTS
; i
++)
10384 if (int_n_enabled_p
[i
])
10386 char name
[50], altname
[50];
10387 sprintf (name
, "__int%d unsigned", int_n_data
[i
].bitsize
);
10388 sprintf (altname
, "__int%d__ unsigned", int_n_data
[i
].bitsize
);
10390 if (strcmp (name
, SIZE_TYPE
) == 0
10391 || strcmp (altname
, SIZE_TYPE
) == 0)
10393 size_type_node
= int_n_trees
[i
].unsigned_type
;
10396 if (size_type_node
== NULL_TREE
)
10397 gcc_unreachable ();
10400 /* Define what type to use for ptrdiff_t. */
10401 if (strcmp (PTRDIFF_TYPE
, "int") == 0)
10402 ptrdiff_type_node
= integer_type_node
;
10403 else if (strcmp (PTRDIFF_TYPE
, "long int") == 0)
10404 ptrdiff_type_node
= long_integer_type_node
;
10405 else if (strcmp (PTRDIFF_TYPE
, "long long int") == 0)
10406 ptrdiff_type_node
= long_long_integer_type_node
;
10407 else if (strcmp (PTRDIFF_TYPE
, "short int") == 0)
10408 ptrdiff_type_node
= short_integer_type_node
;
10411 ptrdiff_type_node
= NULL_TREE
;
10412 for (int i
= 0; i
< NUM_INT_N_ENTS
; i
++)
10413 if (int_n_enabled_p
[i
])
10415 char name
[50], altname
[50];
10416 sprintf (name
, "__int%d", int_n_data
[i
].bitsize
);
10417 sprintf (altname
, "__int%d__", int_n_data
[i
].bitsize
);
10419 if (strcmp (name
, PTRDIFF_TYPE
) == 0
10420 || strcmp (altname
, PTRDIFF_TYPE
) == 0)
10421 ptrdiff_type_node
= int_n_trees
[i
].signed_type
;
10423 if (ptrdiff_type_node
== NULL_TREE
)
10424 gcc_unreachable ();
10427 /* Fill in the rest of the sized types. Reuse existing type nodes
10429 intQI_type_node
= make_or_reuse_type (GET_MODE_BITSIZE (QImode
), 0);
10430 intHI_type_node
= make_or_reuse_type (GET_MODE_BITSIZE (HImode
), 0);
10431 intSI_type_node
= make_or_reuse_type (GET_MODE_BITSIZE (SImode
), 0);
10432 intDI_type_node
= make_or_reuse_type (GET_MODE_BITSIZE (DImode
), 0);
10433 intTI_type_node
= make_or_reuse_type (GET_MODE_BITSIZE (TImode
), 0);
10435 unsigned_intQI_type_node
= make_or_reuse_type (GET_MODE_BITSIZE (QImode
), 1);
10436 unsigned_intHI_type_node
= make_or_reuse_type (GET_MODE_BITSIZE (HImode
), 1);
10437 unsigned_intSI_type_node
= make_or_reuse_type (GET_MODE_BITSIZE (SImode
), 1);
10438 unsigned_intDI_type_node
= make_or_reuse_type (GET_MODE_BITSIZE (DImode
), 1);
10439 unsigned_intTI_type_node
= make_or_reuse_type (GET_MODE_BITSIZE (TImode
), 1);
10441 /* Don't call build_qualified type for atomics. That routine does
10442 special processing for atomics, and until they are initialized
10443 it's better not to make that call.
10445 Check to see if there is a target override for atomic types. */
10447 atomicQI_type_node
= build_atomic_base (unsigned_intQI_type_node
,
10448 targetm
.atomic_align_for_mode (QImode
));
10449 atomicHI_type_node
= build_atomic_base (unsigned_intHI_type_node
,
10450 targetm
.atomic_align_for_mode (HImode
));
10451 atomicSI_type_node
= build_atomic_base (unsigned_intSI_type_node
,
10452 targetm
.atomic_align_for_mode (SImode
));
10453 atomicDI_type_node
= build_atomic_base (unsigned_intDI_type_node
,
10454 targetm
.atomic_align_for_mode (DImode
));
10455 atomicTI_type_node
= build_atomic_base (unsigned_intTI_type_node
,
10456 targetm
.atomic_align_for_mode (TImode
));
10458 access_public_node
= get_identifier ("public");
10459 access_protected_node
= get_identifier ("protected");
10460 access_private_node
= get_identifier ("private");
10462 /* Define these next since types below may used them. */
10463 integer_zero_node
= build_int_cst (integer_type_node
, 0);
10464 integer_one_node
= build_int_cst (integer_type_node
, 1);
10465 integer_three_node
= build_int_cst (integer_type_node
, 3);
10466 integer_minus_one_node
= build_int_cst (integer_type_node
, -1);
10468 size_zero_node
= size_int (0);
10469 size_one_node
= size_int (1);
10470 bitsize_zero_node
= bitsize_int (0);
10471 bitsize_one_node
= bitsize_int (1);
10472 bitsize_unit_node
= bitsize_int (BITS_PER_UNIT
);
10474 boolean_false_node
= TYPE_MIN_VALUE (boolean_type_node
);
10475 boolean_true_node
= TYPE_MAX_VALUE (boolean_type_node
);
10477 void_type_node
= make_node (VOID_TYPE
);
10478 layout_type (void_type_node
);
10480 /* We are not going to have real types in C with less than byte alignment,
10481 so we might as well not have any types that claim to have it. */
10482 SET_TYPE_ALIGN (void_type_node
, BITS_PER_UNIT
);
10483 TYPE_USER_ALIGN (void_type_node
) = 0;
10485 void_node
= make_node (VOID_CST
);
10486 TREE_TYPE (void_node
) = void_type_node
;
10488 null_pointer_node
= build_int_cst (build_pointer_type (void_type_node
), 0);
10489 layout_type (TREE_TYPE (null_pointer_node
));
10491 ptr_type_node
= build_pointer_type (void_type_node
);
10492 const_ptr_type_node
10493 = build_pointer_type (build_type_variant (void_type_node
, 1, 0));
10494 for (unsigned i
= 0;
10495 i
< sizeof (builtin_structptr_types
) / sizeof (builtin_structptr_type
);
10497 builtin_structptr_types
[i
].node
= builtin_structptr_types
[i
].base
;
10499 pointer_sized_int_node
= build_nonstandard_integer_type (POINTER_SIZE
, 1);
10501 float_type_node
= make_node (REAL_TYPE
);
10502 TYPE_PRECISION (float_type_node
) = FLOAT_TYPE_SIZE
;
10503 layout_type (float_type_node
);
10505 double_type_node
= make_node (REAL_TYPE
);
10506 TYPE_PRECISION (double_type_node
) = DOUBLE_TYPE_SIZE
;
10507 layout_type (double_type_node
);
10509 long_double_type_node
= make_node (REAL_TYPE
);
10510 TYPE_PRECISION (long_double_type_node
) = LONG_DOUBLE_TYPE_SIZE
;
10511 layout_type (long_double_type_node
);
10513 for (i
= 0; i
< NUM_FLOATN_NX_TYPES
; i
++)
10515 int n
= floatn_nx_types
[i
].n
;
10516 bool extended
= floatn_nx_types
[i
].extended
;
10517 scalar_float_mode mode
;
10518 if (!targetm
.floatn_mode (n
, extended
).exists (&mode
))
10520 int precision
= GET_MODE_PRECISION (mode
);
10521 /* Work around the rs6000 KFmode having precision 113 not
10523 const struct real_format
*fmt
= REAL_MODE_FORMAT (mode
);
10524 gcc_assert (fmt
->b
== 2 && fmt
->emin
+ fmt
->emax
== 3);
10525 int min_precision
= fmt
->p
+ ceil_log2 (fmt
->emax
- fmt
->emin
);
10527 gcc_assert (min_precision
== n
);
10528 if (precision
< min_precision
)
10529 precision
= min_precision
;
10530 FLOATN_NX_TYPE_NODE (i
) = make_node (REAL_TYPE
);
10531 TYPE_PRECISION (FLOATN_NX_TYPE_NODE (i
)) = precision
;
10532 layout_type (FLOATN_NX_TYPE_NODE (i
));
10533 SET_TYPE_MODE (FLOATN_NX_TYPE_NODE (i
), mode
);
10536 float_ptr_type_node
= build_pointer_type (float_type_node
);
10537 double_ptr_type_node
= build_pointer_type (double_type_node
);
10538 long_double_ptr_type_node
= build_pointer_type (long_double_type_node
);
10539 integer_ptr_type_node
= build_pointer_type (integer_type_node
);
10541 /* Fixed size integer types. */
10542 uint16_type_node
= make_or_reuse_type (16, 1);
10543 uint32_type_node
= make_or_reuse_type (32, 1);
10544 uint64_type_node
= make_or_reuse_type (64, 1);
10546 /* Decimal float types. */
10547 dfloat32_type_node
= make_node (REAL_TYPE
);
10548 TYPE_PRECISION (dfloat32_type_node
) = DECIMAL32_TYPE_SIZE
;
10549 SET_TYPE_MODE (dfloat32_type_node
, SDmode
);
10550 layout_type (dfloat32_type_node
);
10551 dfloat32_ptr_type_node
= build_pointer_type (dfloat32_type_node
);
10553 dfloat64_type_node
= make_node (REAL_TYPE
);
10554 TYPE_PRECISION (dfloat64_type_node
) = DECIMAL64_TYPE_SIZE
;
10555 SET_TYPE_MODE (dfloat64_type_node
, DDmode
);
10556 layout_type (dfloat64_type_node
);
10557 dfloat64_ptr_type_node
= build_pointer_type (dfloat64_type_node
);
10559 dfloat128_type_node
= make_node (REAL_TYPE
);
10560 TYPE_PRECISION (dfloat128_type_node
) = DECIMAL128_TYPE_SIZE
;
10561 SET_TYPE_MODE (dfloat128_type_node
, TDmode
);
10562 layout_type (dfloat128_type_node
);
10563 dfloat128_ptr_type_node
= build_pointer_type (dfloat128_type_node
);
10565 complex_integer_type_node
= build_complex_type (integer_type_node
, true);
10566 complex_float_type_node
= build_complex_type (float_type_node
, true);
10567 complex_double_type_node
= build_complex_type (double_type_node
, true);
10568 complex_long_double_type_node
= build_complex_type (long_double_type_node
,
10571 for (i
= 0; i
< NUM_FLOATN_NX_TYPES
; i
++)
10573 if (FLOATN_NX_TYPE_NODE (i
) != NULL_TREE
)
10574 COMPLEX_FLOATN_NX_TYPE_NODE (i
)
10575 = build_complex_type (FLOATN_NX_TYPE_NODE (i
));
10578 /* Make fixed-point nodes based on sat/non-sat and signed/unsigned. */
10579 #define MAKE_FIXED_TYPE_NODE(KIND,SIZE) \
10580 sat_ ## KIND ## _type_node = \
10581 make_sat_signed_ ## KIND ## _type (SIZE); \
10582 sat_unsigned_ ## KIND ## _type_node = \
10583 make_sat_unsigned_ ## KIND ## _type (SIZE); \
10584 KIND ## _type_node = make_signed_ ## KIND ## _type (SIZE); \
10585 unsigned_ ## KIND ## _type_node = \
10586 make_unsigned_ ## KIND ## _type (SIZE);
10588 #define MAKE_FIXED_TYPE_NODE_WIDTH(KIND,WIDTH,SIZE) \
10589 sat_ ## WIDTH ## KIND ## _type_node = \
10590 make_sat_signed_ ## KIND ## _type (SIZE); \
10591 sat_unsigned_ ## WIDTH ## KIND ## _type_node = \
10592 make_sat_unsigned_ ## KIND ## _type (SIZE); \
10593 WIDTH ## KIND ## _type_node = make_signed_ ## KIND ## _type (SIZE); \
10594 unsigned_ ## WIDTH ## KIND ## _type_node = \
10595 make_unsigned_ ## KIND ## _type (SIZE);
10597 /* Make fixed-point type nodes based on four different widths. */
10598 #define MAKE_FIXED_TYPE_NODE_FAMILY(N1,N2) \
10599 MAKE_FIXED_TYPE_NODE_WIDTH (N1, short_, SHORT_ ## N2 ## _TYPE_SIZE) \
10600 MAKE_FIXED_TYPE_NODE (N1, N2 ## _TYPE_SIZE) \
10601 MAKE_FIXED_TYPE_NODE_WIDTH (N1, long_, LONG_ ## N2 ## _TYPE_SIZE) \
10602 MAKE_FIXED_TYPE_NODE_WIDTH (N1, long_long_, LONG_LONG_ ## N2 ## _TYPE_SIZE)
10604 /* Make fixed-point mode nodes based on sat/non-sat and signed/unsigned. */
10605 #define MAKE_FIXED_MODE_NODE(KIND,NAME,MODE) \
10606 NAME ## _type_node = \
10607 make_or_reuse_signed_ ## KIND ## _type (GET_MODE_BITSIZE (MODE ## mode)); \
10608 u ## NAME ## _type_node = \
10609 make_or_reuse_unsigned_ ## KIND ## _type \
10610 (GET_MODE_BITSIZE (U ## MODE ## mode)); \
10611 sat_ ## NAME ## _type_node = \
10612 make_or_reuse_sat_signed_ ## KIND ## _type \
10613 (GET_MODE_BITSIZE (MODE ## mode)); \
10614 sat_u ## NAME ## _type_node = \
10615 make_or_reuse_sat_unsigned_ ## KIND ## _type \
10616 (GET_MODE_BITSIZE (U ## MODE ## mode));
10618 /* Fixed-point type and mode nodes. */
10619 MAKE_FIXED_TYPE_NODE_FAMILY (fract
, FRACT
)
10620 MAKE_FIXED_TYPE_NODE_FAMILY (accum
, ACCUM
)
10621 MAKE_FIXED_MODE_NODE (fract
, qq
, QQ
)
10622 MAKE_FIXED_MODE_NODE (fract
, hq
, HQ
)
10623 MAKE_FIXED_MODE_NODE (fract
, sq
, SQ
)
10624 MAKE_FIXED_MODE_NODE (fract
, dq
, DQ
)
10625 MAKE_FIXED_MODE_NODE (fract
, tq
, TQ
)
10626 MAKE_FIXED_MODE_NODE (accum
, ha
, HA
)
10627 MAKE_FIXED_MODE_NODE (accum
, sa
, SA
)
10628 MAKE_FIXED_MODE_NODE (accum
, da
, DA
)
10629 MAKE_FIXED_MODE_NODE (accum
, ta
, TA
)
10632 tree t
= targetm
.build_builtin_va_list ();
10634 /* Many back-ends define record types without setting TYPE_NAME.
10635 If we copied the record type here, we'd keep the original
10636 record type without a name. This breaks name mangling. So,
10637 don't copy record types and let c_common_nodes_and_builtins()
10638 declare the type to be __builtin_va_list. */
10639 if (TREE_CODE (t
) != RECORD_TYPE
)
10640 t
= build_variant_type_copy (t
);
10642 va_list_type_node
= t
;
10646 /* Modify DECL for given flags.
10647 TM_PURE attribute is set only on types, so the function will modify
10648 DECL's type when ECF_TM_PURE is used. */
10651 set_call_expr_flags (tree decl
, int flags
)
10653 if (flags
& ECF_NOTHROW
)
10654 TREE_NOTHROW (decl
) = 1;
10655 if (flags
& ECF_CONST
)
10656 TREE_READONLY (decl
) = 1;
10657 if (flags
& ECF_PURE
)
10658 DECL_PURE_P (decl
) = 1;
10659 if (flags
& ECF_LOOPING_CONST_OR_PURE
)
10660 DECL_LOOPING_CONST_OR_PURE_P (decl
) = 1;
10661 if (flags
& ECF_NOVOPS
)
10662 DECL_IS_NOVOPS (decl
) = 1;
10663 if (flags
& ECF_NORETURN
)
10664 TREE_THIS_VOLATILE (decl
) = 1;
10665 if (flags
& ECF_MALLOC
)
10666 DECL_IS_MALLOC (decl
) = 1;
10667 if (flags
& ECF_RETURNS_TWICE
)
10668 DECL_IS_RETURNS_TWICE (decl
) = 1;
10669 if (flags
& ECF_LEAF
)
10670 DECL_ATTRIBUTES (decl
) = tree_cons (get_identifier ("leaf"),
10671 NULL
, DECL_ATTRIBUTES (decl
));
10672 if (flags
& ECF_COLD
)
10673 DECL_ATTRIBUTES (decl
) = tree_cons (get_identifier ("cold"),
10674 NULL
, DECL_ATTRIBUTES (decl
));
10675 if (flags
& ECF_RET1
)
10676 DECL_ATTRIBUTES (decl
)
10677 = tree_cons (get_identifier ("fn spec"),
10678 build_tree_list (NULL_TREE
, build_string (1, "1")),
10679 DECL_ATTRIBUTES (decl
));
10680 if ((flags
& ECF_TM_PURE
) && flag_tm
)
10681 apply_tm_attr (decl
, get_identifier ("transaction_pure"));
10682 /* Looping const or pure is implied by noreturn.
10683 There is currently no way to declare looping const or looping pure alone. */
10684 gcc_assert (!(flags
& ECF_LOOPING_CONST_OR_PURE
)
10685 || ((flags
& ECF_NORETURN
) && (flags
& (ECF_CONST
| ECF_PURE
))));
10689 /* A subroutine of build_common_builtin_nodes. Define a builtin function. */
10692 local_define_builtin (const char *name
, tree type
, enum built_in_function code
,
10693 const char *library_name
, int ecf_flags
)
10697 decl
= add_builtin_function (name
, type
, code
, BUILT_IN_NORMAL
,
10698 library_name
, NULL_TREE
);
10699 set_call_expr_flags (decl
, ecf_flags
);
10701 set_builtin_decl (code
, decl
, true);
10704 /* Call this function after instantiating all builtins that the language
10705 front end cares about. This will build the rest of the builtins
10706 and internal functions that are relied upon by the tree optimizers and
10710 build_common_builtin_nodes (void)
10715 if (!builtin_decl_explicit_p (BUILT_IN_UNREACHABLE
)
10716 || !builtin_decl_explicit_p (BUILT_IN_ABORT
))
10718 ftype
= build_function_type (void_type_node
, void_list_node
);
10719 if (!builtin_decl_explicit_p (BUILT_IN_UNREACHABLE
))
10720 local_define_builtin ("__builtin_unreachable", ftype
,
10721 BUILT_IN_UNREACHABLE
,
10722 "__builtin_unreachable",
10723 ECF_NOTHROW
| ECF_LEAF
| ECF_NORETURN
10724 | ECF_CONST
| ECF_COLD
);
10725 if (!builtin_decl_explicit_p (BUILT_IN_ABORT
))
10726 local_define_builtin ("__builtin_abort", ftype
, BUILT_IN_ABORT
,
10728 ECF_LEAF
| ECF_NORETURN
| ECF_CONST
| ECF_COLD
);
10731 if (!builtin_decl_explicit_p (BUILT_IN_MEMCPY
)
10732 || !builtin_decl_explicit_p (BUILT_IN_MEMMOVE
))
10734 ftype
= build_function_type_list (ptr_type_node
,
10735 ptr_type_node
, const_ptr_type_node
,
10736 size_type_node
, NULL_TREE
);
10738 if (!builtin_decl_explicit_p (BUILT_IN_MEMCPY
))
10739 local_define_builtin ("__builtin_memcpy", ftype
, BUILT_IN_MEMCPY
,
10740 "memcpy", ECF_NOTHROW
| ECF_LEAF
| ECF_RET1
);
10741 if (!builtin_decl_explicit_p (BUILT_IN_MEMMOVE
))
10742 local_define_builtin ("__builtin_memmove", ftype
, BUILT_IN_MEMMOVE
,
10743 "memmove", ECF_NOTHROW
| ECF_LEAF
| ECF_RET1
);
10746 if (!builtin_decl_explicit_p (BUILT_IN_MEMCMP
))
10748 ftype
= build_function_type_list (integer_type_node
, const_ptr_type_node
,
10749 const_ptr_type_node
, size_type_node
,
10751 local_define_builtin ("__builtin_memcmp", ftype
, BUILT_IN_MEMCMP
,
10752 "memcmp", ECF_PURE
| ECF_NOTHROW
| ECF_LEAF
);
10755 if (!builtin_decl_explicit_p (BUILT_IN_MEMSET
))
10757 ftype
= build_function_type_list (ptr_type_node
,
10758 ptr_type_node
, integer_type_node
,
10759 size_type_node
, NULL_TREE
);
10760 local_define_builtin ("__builtin_memset", ftype
, BUILT_IN_MEMSET
,
10761 "memset", ECF_NOTHROW
| ECF_LEAF
| ECF_RET1
);
10764 /* If we're checking the stack, `alloca' can throw. */
10765 const int alloca_flags
10766 = ECF_MALLOC
| ECF_LEAF
| (flag_stack_check
? 0 : ECF_NOTHROW
);
10768 if (!builtin_decl_explicit_p (BUILT_IN_ALLOCA
))
10770 ftype
= build_function_type_list (ptr_type_node
,
10771 size_type_node
, NULL_TREE
);
10772 local_define_builtin ("__builtin_alloca", ftype
, BUILT_IN_ALLOCA
,
10773 "alloca", alloca_flags
);
10776 ftype
= build_function_type_list (ptr_type_node
, size_type_node
,
10777 size_type_node
, NULL_TREE
);
10778 local_define_builtin ("__builtin_alloca_with_align", ftype
,
10779 BUILT_IN_ALLOCA_WITH_ALIGN
,
10780 "__builtin_alloca_with_align",
10783 ftype
= build_function_type_list (ptr_type_node
, size_type_node
,
10784 size_type_node
, size_type_node
, NULL_TREE
);
10785 local_define_builtin ("__builtin_alloca_with_align_and_max", ftype
,
10786 BUILT_IN_ALLOCA_WITH_ALIGN_AND_MAX
,
10787 "__builtin_alloca_with_align_and_max",
10790 ftype
= build_function_type_list (void_type_node
,
10791 ptr_type_node
, ptr_type_node
,
10792 ptr_type_node
, NULL_TREE
);
10793 local_define_builtin ("__builtin_init_trampoline", ftype
,
10794 BUILT_IN_INIT_TRAMPOLINE
,
10795 "__builtin_init_trampoline", ECF_NOTHROW
| ECF_LEAF
);
10796 local_define_builtin ("__builtin_init_heap_trampoline", ftype
,
10797 BUILT_IN_INIT_HEAP_TRAMPOLINE
,
10798 "__builtin_init_heap_trampoline",
10799 ECF_NOTHROW
| ECF_LEAF
);
10800 local_define_builtin ("__builtin_init_descriptor", ftype
,
10801 BUILT_IN_INIT_DESCRIPTOR
,
10802 "__builtin_init_descriptor", ECF_NOTHROW
| ECF_LEAF
);
10804 ftype
= build_function_type_list (ptr_type_node
, ptr_type_node
, NULL_TREE
);
10805 local_define_builtin ("__builtin_adjust_trampoline", ftype
,
10806 BUILT_IN_ADJUST_TRAMPOLINE
,
10807 "__builtin_adjust_trampoline",
10808 ECF_CONST
| ECF_NOTHROW
);
10809 local_define_builtin ("__builtin_adjust_descriptor", ftype
,
10810 BUILT_IN_ADJUST_DESCRIPTOR
,
10811 "__builtin_adjust_descriptor",
10812 ECF_CONST
| ECF_NOTHROW
);
10814 ftype
= build_function_type_list (void_type_node
,
10815 ptr_type_node
, ptr_type_node
, NULL_TREE
);
10816 local_define_builtin ("__builtin_nonlocal_goto", ftype
,
10817 BUILT_IN_NONLOCAL_GOTO
,
10818 "__builtin_nonlocal_goto",
10819 ECF_NORETURN
| ECF_NOTHROW
);
10821 ftype
= build_function_type_list (void_type_node
,
10822 ptr_type_node
, ptr_type_node
, NULL_TREE
);
10823 local_define_builtin ("__builtin_setjmp_setup", ftype
,
10824 BUILT_IN_SETJMP_SETUP
,
10825 "__builtin_setjmp_setup", ECF_NOTHROW
);
10827 ftype
= build_function_type_list (void_type_node
, ptr_type_node
, NULL_TREE
);
10828 local_define_builtin ("__builtin_setjmp_receiver", ftype
,
10829 BUILT_IN_SETJMP_RECEIVER
,
10830 "__builtin_setjmp_receiver", ECF_NOTHROW
| ECF_LEAF
);
10832 ftype
= build_function_type_list (ptr_type_node
, NULL_TREE
);
10833 local_define_builtin ("__builtin_stack_save", ftype
, BUILT_IN_STACK_SAVE
,
10834 "__builtin_stack_save", ECF_NOTHROW
| ECF_LEAF
);
10836 ftype
= build_function_type_list (void_type_node
, ptr_type_node
, NULL_TREE
);
10837 local_define_builtin ("__builtin_stack_restore", ftype
,
10838 BUILT_IN_STACK_RESTORE
,
10839 "__builtin_stack_restore", ECF_NOTHROW
| ECF_LEAF
);
10841 ftype
= build_function_type_list (integer_type_node
, const_ptr_type_node
,
10842 const_ptr_type_node
, size_type_node
,
10844 local_define_builtin ("__builtin_memcmp_eq", ftype
, BUILT_IN_MEMCMP_EQ
,
10845 "__builtin_memcmp_eq",
10846 ECF_PURE
| ECF_NOTHROW
| ECF_LEAF
);
10848 local_define_builtin ("__builtin_strncmp_eq", ftype
, BUILT_IN_STRNCMP_EQ
,
10849 "__builtin_strncmp_eq",
10850 ECF_PURE
| ECF_NOTHROW
| ECF_LEAF
);
10852 local_define_builtin ("__builtin_strcmp_eq", ftype
, BUILT_IN_STRCMP_EQ
,
10853 "__builtin_strcmp_eq",
10854 ECF_PURE
| ECF_NOTHROW
| ECF_LEAF
);
10856 /* If there's a possibility that we might use the ARM EABI, build the
10857 alternate __cxa_end_cleanup node used to resume from C++. */
10858 if (targetm
.arm_eabi_unwinder
)
10860 ftype
= build_function_type_list (void_type_node
, NULL_TREE
);
10861 local_define_builtin ("__builtin_cxa_end_cleanup", ftype
,
10862 BUILT_IN_CXA_END_CLEANUP
,
10863 "__cxa_end_cleanup", ECF_NORETURN
| ECF_LEAF
);
10866 ftype
= build_function_type_list (void_type_node
, ptr_type_node
, NULL_TREE
);
10867 local_define_builtin ("__builtin_unwind_resume", ftype
,
10868 BUILT_IN_UNWIND_RESUME
,
10869 ((targetm_common
.except_unwind_info (&global_options
)
10871 ? "_Unwind_SjLj_Resume" : "_Unwind_Resume"),
10874 if (builtin_decl_explicit (BUILT_IN_RETURN_ADDRESS
) == NULL_TREE
)
10876 ftype
= build_function_type_list (ptr_type_node
, integer_type_node
,
10878 local_define_builtin ("__builtin_return_address", ftype
,
10879 BUILT_IN_RETURN_ADDRESS
,
10880 "__builtin_return_address",
10884 if (!builtin_decl_explicit_p (BUILT_IN_PROFILE_FUNC_ENTER
)
10885 || !builtin_decl_explicit_p (BUILT_IN_PROFILE_FUNC_EXIT
))
10887 ftype
= build_function_type_list (void_type_node
, ptr_type_node
,
10888 ptr_type_node
, NULL_TREE
);
10889 if (!builtin_decl_explicit_p (BUILT_IN_PROFILE_FUNC_ENTER
))
10890 local_define_builtin ("__cyg_profile_func_enter", ftype
,
10891 BUILT_IN_PROFILE_FUNC_ENTER
,
10892 "__cyg_profile_func_enter", 0);
10893 if (!builtin_decl_explicit_p (BUILT_IN_PROFILE_FUNC_EXIT
))
10894 local_define_builtin ("__cyg_profile_func_exit", ftype
,
10895 BUILT_IN_PROFILE_FUNC_EXIT
,
10896 "__cyg_profile_func_exit", 0);
10899 /* The exception object and filter values from the runtime. The argument
10900 must be zero before exception lowering, i.e. from the front end. After
10901 exception lowering, it will be the region number for the exception
10902 landing pad. These functions are PURE instead of CONST to prevent
10903 them from being hoisted past the exception edge that will initialize
10904 its value in the landing pad. */
10905 ftype
= build_function_type_list (ptr_type_node
,
10906 integer_type_node
, NULL_TREE
);
10907 ecf_flags
= ECF_PURE
| ECF_NOTHROW
| ECF_LEAF
;
10908 /* Only use TM_PURE if we have TM language support. */
10909 if (builtin_decl_explicit_p (BUILT_IN_TM_LOAD_1
))
10910 ecf_flags
|= ECF_TM_PURE
;
10911 local_define_builtin ("__builtin_eh_pointer", ftype
, BUILT_IN_EH_POINTER
,
10912 "__builtin_eh_pointer", ecf_flags
);
10914 tmp
= lang_hooks
.types
.type_for_mode (targetm
.eh_return_filter_mode (), 0);
10915 ftype
= build_function_type_list (tmp
, integer_type_node
, NULL_TREE
);
10916 local_define_builtin ("__builtin_eh_filter", ftype
, BUILT_IN_EH_FILTER
,
10917 "__builtin_eh_filter", ECF_PURE
| ECF_NOTHROW
| ECF_LEAF
);
10919 ftype
= build_function_type_list (void_type_node
,
10920 integer_type_node
, integer_type_node
,
10922 local_define_builtin ("__builtin_eh_copy_values", ftype
,
10923 BUILT_IN_EH_COPY_VALUES
,
10924 "__builtin_eh_copy_values", ECF_NOTHROW
);
10926 /* Complex multiplication and division. These are handled as builtins
10927 rather than optabs because emit_library_call_value doesn't support
10928 complex. Further, we can do slightly better with folding these
10929 beasties if the real and complex parts of the arguments are separate. */
10933 for (mode
= MIN_MODE_COMPLEX_FLOAT
; mode
<= MAX_MODE_COMPLEX_FLOAT
; ++mode
)
10935 char mode_name_buf
[4], *q
;
10937 enum built_in_function mcode
, dcode
;
10938 tree type
, inner_type
;
10939 const char *prefix
= "__";
10941 if (targetm
.libfunc_gnu_prefix
)
10944 type
= lang_hooks
.types
.type_for_mode ((machine_mode
) mode
, 0);
10947 inner_type
= TREE_TYPE (type
);
10949 ftype
= build_function_type_list (type
, inner_type
, inner_type
,
10950 inner_type
, inner_type
, NULL_TREE
);
10952 mcode
= ((enum built_in_function
)
10953 (BUILT_IN_COMPLEX_MUL_MIN
+ mode
- MIN_MODE_COMPLEX_FLOAT
));
10954 dcode
= ((enum built_in_function
)
10955 (BUILT_IN_COMPLEX_DIV_MIN
+ mode
- MIN_MODE_COMPLEX_FLOAT
));
10957 for (p
= GET_MODE_NAME (mode
), q
= mode_name_buf
; *p
; p
++, q
++)
10961 /* For -ftrapping-math these should throw from a former
10962 -fnon-call-exception stmt. */
10963 built_in_names
[mcode
] = concat (prefix
, "mul", mode_name_buf
, "3",
10965 local_define_builtin (built_in_names
[mcode
], ftype
, mcode
,
10966 built_in_names
[mcode
],
10967 ECF_CONST
| ECF_LEAF
);
10969 built_in_names
[dcode
] = concat (prefix
, "div", mode_name_buf
, "3",
10971 local_define_builtin (built_in_names
[dcode
], ftype
, dcode
,
10972 built_in_names
[dcode
],
10973 ECF_CONST
| ECF_LEAF
);
10977 init_internal_fns ();
10980 /* HACK. GROSS. This is absolutely disgusting. I wish there was a
10983 If we requested a pointer to a vector, build up the pointers that
10984 we stripped off while looking for the inner type. Similarly for
10985 return values from functions.
10987 The argument TYPE is the top of the chain, and BOTTOM is the
10988 new type which we will point to. */
10991 reconstruct_complex_type (tree type
, tree bottom
)
10995 if (TREE_CODE (type
) == POINTER_TYPE
)
10997 inner
= reconstruct_complex_type (TREE_TYPE (type
), bottom
);
10998 outer
= build_pointer_type_for_mode (inner
, TYPE_MODE (type
),
10999 TYPE_REF_CAN_ALIAS_ALL (type
));
11001 else if (TREE_CODE (type
) == REFERENCE_TYPE
)
11003 inner
= reconstruct_complex_type (TREE_TYPE (type
), bottom
);
11004 outer
= build_reference_type_for_mode (inner
, TYPE_MODE (type
),
11005 TYPE_REF_CAN_ALIAS_ALL (type
));
11007 else if (TREE_CODE (type
) == ARRAY_TYPE
)
11009 inner
= reconstruct_complex_type (TREE_TYPE (type
), bottom
);
11010 outer
= build_array_type (inner
, TYPE_DOMAIN (type
));
11012 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
11014 inner
= reconstruct_complex_type (TREE_TYPE (type
), bottom
);
11015 outer
= build_function_type (inner
, TYPE_ARG_TYPES (type
));
11017 else if (TREE_CODE (type
) == METHOD_TYPE
)
11019 inner
= reconstruct_complex_type (TREE_TYPE (type
), bottom
);
11020 /* The build_method_type_directly() routine prepends 'this' to argument list,
11021 so we must compensate by getting rid of it. */
11023 = build_method_type_directly
11024 (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (type
))),
11026 TREE_CHAIN (TYPE_ARG_TYPES (type
)));
11028 else if (TREE_CODE (type
) == OFFSET_TYPE
)
11030 inner
= reconstruct_complex_type (TREE_TYPE (type
), bottom
);
11031 outer
= build_offset_type (TYPE_OFFSET_BASETYPE (type
), inner
);
11036 return build_type_attribute_qual_variant (outer
, TYPE_ATTRIBUTES (type
),
11037 TYPE_QUALS (type
));
11040 /* Returns a vector tree node given a mode (integer, vector, or BLKmode) and
11043 build_vector_type_for_mode (tree innertype
, machine_mode mode
)
11046 unsigned int bitsize
;
11048 switch (GET_MODE_CLASS (mode
))
11050 case MODE_VECTOR_BOOL
:
11051 case MODE_VECTOR_INT
:
11052 case MODE_VECTOR_FLOAT
:
11053 case MODE_VECTOR_FRACT
:
11054 case MODE_VECTOR_UFRACT
:
11055 case MODE_VECTOR_ACCUM
:
11056 case MODE_VECTOR_UACCUM
:
11057 nunits
= GET_MODE_NUNITS (mode
);
11061 /* Check that there are no leftover bits. */
11062 bitsize
= GET_MODE_BITSIZE (as_a
<scalar_int_mode
> (mode
));
11063 gcc_assert (bitsize
% TREE_INT_CST_LOW (TYPE_SIZE (innertype
)) == 0);
11064 nunits
= bitsize
/ TREE_INT_CST_LOW (TYPE_SIZE (innertype
));
11068 gcc_unreachable ();
11071 return make_vector_type (innertype
, nunits
, mode
);
11074 /* Similarly, but takes the inner type and number of units, which must be
11078 build_vector_type (tree innertype
, poly_int64 nunits
)
11080 return make_vector_type (innertype
, nunits
, VOIDmode
);
11083 /* Build truth vector with specified length and number of units. */
11086 build_truth_vector_type (poly_uint64 nunits
, poly_uint64 vector_size
)
11088 machine_mode mask_mode
11089 = targetm
.vectorize
.get_mask_mode (nunits
, vector_size
).else_blk ();
11092 if (mask_mode
== BLKmode
)
11093 vsize
= vector_size
* BITS_PER_UNIT
;
11095 vsize
= GET_MODE_BITSIZE (mask_mode
);
11097 unsigned HOST_WIDE_INT esize
= vector_element_size (vsize
, nunits
);
11099 tree bool_type
= build_nonstandard_boolean_type (esize
);
11101 return make_vector_type (bool_type
, nunits
, mask_mode
);
11104 /* Returns a vector type corresponding to a comparison of VECTYPE. */
11107 build_same_sized_truth_vector_type (tree vectype
)
11109 if (VECTOR_BOOLEAN_TYPE_P (vectype
))
11112 poly_uint64 size
= GET_MODE_SIZE (TYPE_MODE (vectype
));
11114 if (known_eq (size
, 0U))
11115 size
= tree_to_uhwi (TYPE_SIZE_UNIT (vectype
));
11117 return build_truth_vector_type (TYPE_VECTOR_SUBPARTS (vectype
), size
);
11120 /* Similarly, but builds a variant type with TYPE_VECTOR_OPAQUE set. */
11123 build_opaque_vector_type (tree innertype
, poly_int64 nunits
)
11125 tree t
= make_vector_type (innertype
, nunits
, VOIDmode
);
11127 /* We always build the non-opaque variant before the opaque one,
11128 so if it already exists, it is TYPE_NEXT_VARIANT of this one. */
11129 cand
= TYPE_NEXT_VARIANT (t
);
11131 && TYPE_VECTOR_OPAQUE (cand
)
11132 && check_qualified_type (cand
, t
, TYPE_QUALS (t
)))
11134 /* Othewise build a variant type and make sure to queue it after
11135 the non-opaque type. */
11136 cand
= build_distinct_type_copy (t
);
11137 TYPE_VECTOR_OPAQUE (cand
) = true;
11138 TYPE_CANONICAL (cand
) = TYPE_CANONICAL (t
);
11139 TYPE_NEXT_VARIANT (cand
) = TYPE_NEXT_VARIANT (t
);
11140 TYPE_NEXT_VARIANT (t
) = cand
;
11141 TYPE_MAIN_VARIANT (cand
) = TYPE_MAIN_VARIANT (t
);
11145 /* Return the value of element I of VECTOR_CST T as a wide_int. */
11148 vector_cst_int_elt (const_tree t
, unsigned int i
)
11150 /* First handle elements that are directly encoded. */
11151 unsigned int encoded_nelts
= vector_cst_encoded_nelts (t
);
11152 if (i
< encoded_nelts
)
11153 return wi::to_wide (VECTOR_CST_ENCODED_ELT (t
, i
));
11155 /* Identify the pattern that contains element I and work out the index of
11156 the last encoded element for that pattern. */
11157 unsigned int npatterns
= VECTOR_CST_NPATTERNS (t
);
11158 unsigned int pattern
= i
% npatterns
;
11159 unsigned int count
= i
/ npatterns
;
11160 unsigned int final_i
= encoded_nelts
- npatterns
+ pattern
;
11162 /* If there are no steps, the final encoded value is the right one. */
11163 if (!VECTOR_CST_STEPPED_P (t
))
11164 return wi::to_wide (VECTOR_CST_ENCODED_ELT (t
, final_i
));
11166 /* Otherwise work out the value from the last two encoded elements. */
11167 tree v1
= VECTOR_CST_ENCODED_ELT (t
, final_i
- npatterns
);
11168 tree v2
= VECTOR_CST_ENCODED_ELT (t
, final_i
);
11169 wide_int diff
= wi::to_wide (v2
) - wi::to_wide (v1
);
11170 return wi::to_wide (v2
) + (count
- 2) * diff
;
11173 /* Return the value of element I of VECTOR_CST T. */
11176 vector_cst_elt (const_tree t
, unsigned int i
)
11178 /* First handle elements that are directly encoded. */
11179 unsigned int encoded_nelts
= vector_cst_encoded_nelts (t
);
11180 if (i
< encoded_nelts
)
11181 return VECTOR_CST_ENCODED_ELT (t
, i
);
11183 /* If there are no steps, the final encoded value is the right one. */
11184 if (!VECTOR_CST_STEPPED_P (t
))
11186 /* Identify the pattern that contains element I and work out the index of
11187 the last encoded element for that pattern. */
11188 unsigned int npatterns
= VECTOR_CST_NPATTERNS (t
);
11189 unsigned int pattern
= i
% npatterns
;
11190 unsigned int final_i
= encoded_nelts
- npatterns
+ pattern
;
11191 return VECTOR_CST_ENCODED_ELT (t
, final_i
);
11194 /* Otherwise work out the value from the last two encoded elements. */
11195 return wide_int_to_tree (TREE_TYPE (TREE_TYPE (t
)),
11196 vector_cst_int_elt (t
, i
));
11199 /* Given an initializer INIT, return TRUE if INIT is zero or some
11200 aggregate of zeros. Otherwise return FALSE. If NONZERO is not
11201 null, set *NONZERO if and only if INIT is known not to be all
11202 zeros. The combination of return value of false and *NONZERO
11203 false implies that INIT may but need not be all zeros. Other
11204 combinations indicate definitive answers. */
11207 initializer_zerop (const_tree init
, bool *nonzero
/* = NULL */)
11213 /* Conservatively clear NONZERO and set it only if INIT is definitely
11219 unsigned HOST_WIDE_INT off
= 0;
11221 switch (TREE_CODE (init
))
11224 if (integer_zerop (init
))
11231 /* ??? Note that this is not correct for C4X float formats. There,
11232 a bit pattern of all zeros is 1.0; 0.0 is encoded with the most
11233 negative exponent. */
11234 if (real_zerop (init
)
11235 && !REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (init
)))
11242 if (fixed_zerop (init
))
11249 if (integer_zerop (init
)
11250 || (real_zerop (init
)
11251 && !REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (TREE_REALPART (init
)))
11252 && !REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (TREE_IMAGPART (init
)))))
11259 if (VECTOR_CST_NPATTERNS (init
) == 1
11260 && VECTOR_CST_DUPLICATE_P (init
)
11261 && initializer_zerop (VECTOR_CST_ENCODED_ELT (init
, 0)))
11269 if (TREE_CLOBBER_P (init
))
11272 unsigned HOST_WIDE_INT idx
;
11275 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (init
), idx
, elt
)
11276 if (!initializer_zerop (elt
, nonzero
))
11284 tree arg
= TREE_OPERAND (init
, 0);
11285 if (TREE_CODE (arg
) != ADDR_EXPR
)
11287 tree offset
= TREE_OPERAND (init
, 1);
11288 if (TREE_CODE (offset
) != INTEGER_CST
11289 || !tree_fits_uhwi_p (offset
))
11291 off
= tree_to_uhwi (offset
);
11294 arg
= TREE_OPERAND (arg
, 0);
11295 if (TREE_CODE (arg
) != STRING_CST
)
11299 /* Fall through. */
11303 gcc_assert (off
<= INT_MAX
);
11306 int n
= TREE_STRING_LENGTH (init
);
11310 /* We need to loop through all elements to handle cases like
11311 "\0" and "\0foobar". */
11312 for (i
= 0; i
< n
; ++i
)
11313 if (TREE_STRING_POINTER (init
)[i
] != '\0')
11327 /* Return true if EXPR is an initializer expression in which every element
11328 is a constant that is numerically equal to 0 or 1. The elements do not
11329 need to be equal to each other. */
11332 initializer_each_zero_or_onep (const_tree expr
)
11334 STRIP_ANY_LOCATION_WRAPPER (expr
);
11336 switch (TREE_CODE (expr
))
11339 return integer_zerop (expr
) || integer_onep (expr
);
11342 return real_zerop (expr
) || real_onep (expr
);
11346 unsigned HOST_WIDE_INT nelts
= vector_cst_encoded_nelts (expr
);
11347 if (VECTOR_CST_STEPPED_P (expr
)
11348 && !TYPE_VECTOR_SUBPARTS (TREE_TYPE (expr
)).is_constant (&nelts
))
11351 for (unsigned int i
= 0; i
< nelts
; ++i
)
11353 tree elt
= vector_cst_elt (expr
, i
);
11354 if (!initializer_each_zero_or_onep (elt
))
11366 /* Check if vector VEC consists of all the equal elements and
11367 that the number of elements corresponds to the type of VEC.
11368 The function returns first element of the vector
11369 or NULL_TREE if the vector is not uniform. */
11371 uniform_vector_p (const_tree vec
)
11374 unsigned HOST_WIDE_INT i
, nelts
;
11376 if (vec
== NULL_TREE
)
11379 gcc_assert (VECTOR_TYPE_P (TREE_TYPE (vec
)));
11381 if (TREE_CODE (vec
) == VEC_DUPLICATE_EXPR
)
11382 return TREE_OPERAND (vec
, 0);
11384 else if (TREE_CODE (vec
) == VECTOR_CST
)
11386 if (VECTOR_CST_NPATTERNS (vec
) == 1 && VECTOR_CST_DUPLICATE_P (vec
))
11387 return VECTOR_CST_ENCODED_ELT (vec
, 0);
11391 else if (TREE_CODE (vec
) == CONSTRUCTOR
11392 && TYPE_VECTOR_SUBPARTS (TREE_TYPE (vec
)).is_constant (&nelts
))
11394 first
= error_mark_node
;
11396 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (vec
), i
, t
)
11403 if (!operand_equal_p (first
, t
, 0))
11415 /* If the argument is INTEGER_CST, return it. If the argument is vector
11416 with all elements the same INTEGER_CST, return that INTEGER_CST. Otherwise
11418 Look through location wrappers. */
11421 uniform_integer_cst_p (tree t
)
11423 STRIP_ANY_LOCATION_WRAPPER (t
);
11425 if (TREE_CODE (t
) == INTEGER_CST
)
11428 if (VECTOR_TYPE_P (TREE_TYPE (t
)))
11430 t
= uniform_vector_p (t
);
11431 if (t
&& TREE_CODE (t
) == INTEGER_CST
)
11438 /* If VECTOR_CST T has a single nonzero element, return the index of that
11439 element, otherwise return -1. */
11442 single_nonzero_element (const_tree t
)
11444 unsigned HOST_WIDE_INT nelts
;
11445 unsigned int repeat_nelts
;
11446 if (VECTOR_CST_NELTS (t
).is_constant (&nelts
))
11447 repeat_nelts
= nelts
;
11448 else if (VECTOR_CST_NELTS_PER_PATTERN (t
) == 2)
11450 nelts
= vector_cst_encoded_nelts (t
);
11451 repeat_nelts
= VECTOR_CST_NPATTERNS (t
);
11457 for (unsigned int i
= 0; i
< nelts
; ++i
)
11459 tree elt
= vector_cst_elt (t
, i
);
11460 if (!integer_zerop (elt
) && !real_zerop (elt
))
11462 if (res
>= 0 || i
>= repeat_nelts
)
11470 /* Build an empty statement at location LOC. */
11473 build_empty_stmt (location_t loc
)
11475 tree t
= build1 (NOP_EXPR
, void_type_node
, size_zero_node
);
11476 SET_EXPR_LOCATION (t
, loc
);
11481 /* Build an OpenMP clause with code CODE. LOC is the location of the
11485 build_omp_clause (location_t loc
, enum omp_clause_code code
)
11490 length
= omp_clause_num_ops
[code
];
11491 size
= (sizeof (struct tree_omp_clause
) + (length
- 1) * sizeof (tree
));
11493 record_node_allocation_statistics (OMP_CLAUSE
, size
);
11495 t
= (tree
) ggc_internal_alloc (size
);
11496 memset (t
, 0, size
);
11497 TREE_SET_CODE (t
, OMP_CLAUSE
);
11498 OMP_CLAUSE_SET_CODE (t
, code
);
11499 OMP_CLAUSE_LOCATION (t
) = loc
;
11504 /* Build a tcc_vl_exp object with code CODE and room for LEN operands. LEN
11505 includes the implicit operand count in TREE_OPERAND 0, and so must be >= 1.
11506 Except for the CODE and operand count field, other storage for the
11507 object is initialized to zeros. */
11510 build_vl_exp (enum tree_code code
, int len MEM_STAT_DECL
)
11513 int length
= (len
- 1) * sizeof (tree
) + sizeof (struct tree_exp
);
11515 gcc_assert (TREE_CODE_CLASS (code
) == tcc_vl_exp
);
11516 gcc_assert (len
>= 1);
11518 record_node_allocation_statistics (code
, length
);
11520 t
= ggc_alloc_cleared_tree_node_stat (length PASS_MEM_STAT
);
11522 TREE_SET_CODE (t
, code
);
11524 /* Can't use TREE_OPERAND to store the length because if checking is
11525 enabled, it will try to check the length before we store it. :-P */
11526 t
->exp
.operands
[0] = build_int_cst (sizetype
, len
);
11531 /* Helper function for build_call_* functions; build a CALL_EXPR with
11532 indicated RETURN_TYPE, FN, and NARGS, but do not initialize any of
11533 the argument slots. */
11536 build_call_1 (tree return_type
, tree fn
, int nargs
)
11540 t
= build_vl_exp (CALL_EXPR
, nargs
+ 3);
11541 TREE_TYPE (t
) = return_type
;
11542 CALL_EXPR_FN (t
) = fn
;
11543 CALL_EXPR_STATIC_CHAIN (t
) = NULL
;
11548 /* Build a CALL_EXPR of class tcc_vl_exp with the indicated RETURN_TYPE and
11549 FN and a null static chain slot. NARGS is the number of call arguments
11550 which are specified as "..." arguments. */
11553 build_call_nary (tree return_type
, tree fn
, int nargs
, ...)
11557 va_start (args
, nargs
);
11558 ret
= build_call_valist (return_type
, fn
, nargs
, args
);
11563 /* Build a CALL_EXPR of class tcc_vl_exp with the indicated RETURN_TYPE and
11564 FN and a null static chain slot. NARGS is the number of call arguments
11565 which are specified as a va_list ARGS. */
11568 build_call_valist (tree return_type
, tree fn
, int nargs
, va_list args
)
11573 t
= build_call_1 (return_type
, fn
, nargs
);
11574 for (i
= 0; i
< nargs
; i
++)
11575 CALL_EXPR_ARG (t
, i
) = va_arg (args
, tree
);
11576 process_call_operands (t
);
11580 /* Build a CALL_EXPR of class tcc_vl_exp with the indicated RETURN_TYPE and
11581 FN and a null static chain slot. NARGS is the number of call arguments
11582 which are specified as a tree array ARGS. */
11585 build_call_array_loc (location_t loc
, tree return_type
, tree fn
,
11586 int nargs
, const tree
*args
)
11591 t
= build_call_1 (return_type
, fn
, nargs
);
11592 for (i
= 0; i
< nargs
; i
++)
11593 CALL_EXPR_ARG (t
, i
) = args
[i
];
11594 process_call_operands (t
);
11595 SET_EXPR_LOCATION (t
, loc
);
11599 /* Like build_call_array, but takes a vec. */
11602 build_call_vec (tree return_type
, tree fn
, vec
<tree
, va_gc
> *args
)
11607 ret
= build_call_1 (return_type
, fn
, vec_safe_length (args
));
11608 FOR_EACH_VEC_SAFE_ELT (args
, ix
, t
)
11609 CALL_EXPR_ARG (ret
, ix
) = t
;
11610 process_call_operands (ret
);
11614 /* Conveniently construct a function call expression. FNDECL names the
11615 function to be called and N arguments are passed in the array
11619 build_call_expr_loc_array (location_t loc
, tree fndecl
, int n
, tree
*argarray
)
11621 tree fntype
= TREE_TYPE (fndecl
);
11622 tree fn
= build1 (ADDR_EXPR
, build_pointer_type (fntype
), fndecl
);
11624 return fold_build_call_array_loc (loc
, TREE_TYPE (fntype
), fn
, n
, argarray
);
11627 /* Conveniently construct a function call expression. FNDECL names the
11628 function to be called and the arguments are passed in the vector
11632 build_call_expr_loc_vec (location_t loc
, tree fndecl
, vec
<tree
, va_gc
> *vec
)
11634 return build_call_expr_loc_array (loc
, fndecl
, vec_safe_length (vec
),
11635 vec_safe_address (vec
));
11639 /* Conveniently construct a function call expression. FNDECL names the
11640 function to be called, N is the number of arguments, and the "..."
11641 parameters are the argument expressions. */
11644 build_call_expr_loc (location_t loc
, tree fndecl
, int n
, ...)
11647 tree
*argarray
= XALLOCAVEC (tree
, n
);
11651 for (i
= 0; i
< n
; i
++)
11652 argarray
[i
] = va_arg (ap
, tree
);
11654 return build_call_expr_loc_array (loc
, fndecl
, n
, argarray
);
11657 /* Like build_call_expr_loc (UNKNOWN_LOCATION, ...). Duplicated because
11658 varargs macros aren't supported by all bootstrap compilers. */
11661 build_call_expr (tree fndecl
, int n
, ...)
11664 tree
*argarray
= XALLOCAVEC (tree
, n
);
11668 for (i
= 0; i
< n
; i
++)
11669 argarray
[i
] = va_arg (ap
, tree
);
11671 return build_call_expr_loc_array (UNKNOWN_LOCATION
, fndecl
, n
, argarray
);
11674 /* Build an internal call to IFN, with arguments ARGS[0:N-1] and with return
11675 type TYPE. This is just like CALL_EXPR, except its CALL_EXPR_FN is NULL.
11676 It will get gimplified later into an ordinary internal function. */
11679 build_call_expr_internal_loc_array (location_t loc
, internal_fn ifn
,
11680 tree type
, int n
, const tree
*args
)
11682 tree t
= build_call_1 (type
, NULL_TREE
, n
);
11683 for (int i
= 0; i
< n
; ++i
)
11684 CALL_EXPR_ARG (t
, i
) = args
[i
];
11685 SET_EXPR_LOCATION (t
, loc
);
11686 CALL_EXPR_IFN (t
) = ifn
;
11690 /* Build internal call expression. This is just like CALL_EXPR, except
11691 its CALL_EXPR_FN is NULL. It will get gimplified later into ordinary
11692 internal function. */
11695 build_call_expr_internal_loc (location_t loc
, enum internal_fn ifn
,
11696 tree type
, int n
, ...)
11699 tree
*argarray
= XALLOCAVEC (tree
, n
);
11703 for (i
= 0; i
< n
; i
++)
11704 argarray
[i
] = va_arg (ap
, tree
);
11706 return build_call_expr_internal_loc_array (loc
, ifn
, type
, n
, argarray
);
11709 /* Return a function call to FN, if the target is guaranteed to support it,
11712 N is the number of arguments, passed in the "...", and TYPE is the
11713 type of the return value. */
11716 maybe_build_call_expr_loc (location_t loc
, combined_fn fn
, tree type
,
11720 tree
*argarray
= XALLOCAVEC (tree
, n
);
11724 for (i
= 0; i
< n
; i
++)
11725 argarray
[i
] = va_arg (ap
, tree
);
11727 if (internal_fn_p (fn
))
11729 internal_fn ifn
= as_internal_fn (fn
);
11730 if (direct_internal_fn_p (ifn
))
11732 tree_pair types
= direct_internal_fn_types (ifn
, type
, argarray
);
11733 if (!direct_internal_fn_supported_p (ifn
, types
,
11734 OPTIMIZE_FOR_BOTH
))
11737 return build_call_expr_internal_loc_array (loc
, ifn
, type
, n
, argarray
);
11741 tree fndecl
= builtin_decl_implicit (as_builtin_fn (fn
));
11744 return build_call_expr_loc_array (loc
, fndecl
, n
, argarray
);
11748 /* Return a function call to the appropriate builtin alloca variant.
11750 SIZE is the size to be allocated. ALIGN, if non-zero, is the requested
11751 alignment of the allocated area. MAX_SIZE, if non-negative, is an upper
11752 bound for SIZE in case it is not a fixed value. */
11755 build_alloca_call_expr (tree size
, unsigned int align
, HOST_WIDE_INT max_size
)
11759 tree t
= builtin_decl_explicit (BUILT_IN_ALLOCA_WITH_ALIGN_AND_MAX
);
11761 build_call_expr (t
, 3, size
, size_int (align
), size_int (max_size
));
11763 else if (align
> 0)
11765 tree t
= builtin_decl_explicit (BUILT_IN_ALLOCA_WITH_ALIGN
);
11766 return build_call_expr (t
, 2, size
, size_int (align
));
11770 tree t
= builtin_decl_explicit (BUILT_IN_ALLOCA
);
11771 return build_call_expr (t
, 1, size
);
11775 /* Create a new constant string literal consisting of elements of type
11776 ELTYPE and return a tree node representing char* pointer to it as
11777 an ADDR_EXPR (ARRAY_REF (ELTYPE, ...)). The STRING_CST value is
11778 the LEN bytes at STR (the representation of the string, which may
11782 build_string_literal (int len
, const char *str
,
11783 tree eltype
/* = char_type_node */)
11785 tree t
= build_string (len
, str
);
11786 tree index
= build_index_type (size_int (len
- 1));
11787 eltype
= build_type_variant (eltype
, 1, 0);
11788 tree type
= build_array_type (eltype
, index
);
11789 TREE_TYPE (t
) = type
;
11790 TREE_CONSTANT (t
) = 1;
11791 TREE_READONLY (t
) = 1;
11792 TREE_STATIC (t
) = 1;
11794 type
= build_pointer_type (eltype
);
11795 t
= build1 (ADDR_EXPR
, type
,
11796 build4 (ARRAY_REF
, eltype
,
11797 t
, integer_zero_node
, NULL_TREE
, NULL_TREE
));
11803 /* Return true if T (assumed to be a DECL) must be assigned a memory
11807 needs_to_live_in_memory (const_tree t
)
11809 return (TREE_ADDRESSABLE (t
)
11810 || is_global_var (t
)
11811 || (TREE_CODE (t
) == RESULT_DECL
11812 && !DECL_BY_REFERENCE (t
)
11813 && aggregate_value_p (t
, current_function_decl
)));
11816 /* Return value of a constant X and sign-extend it. */
11819 int_cst_value (const_tree x
)
11821 unsigned bits
= TYPE_PRECISION (TREE_TYPE (x
));
11822 unsigned HOST_WIDE_INT val
= TREE_INT_CST_LOW (x
);
11824 /* Make sure the sign-extended value will fit in a HOST_WIDE_INT. */
11825 gcc_assert (cst_and_fits_in_hwi (x
));
11827 if (bits
< HOST_BITS_PER_WIDE_INT
)
11829 bool negative
= ((val
>> (bits
- 1)) & 1) != 0;
11831 val
|= HOST_WIDE_INT_M1U
<< (bits
- 1) << 1;
11833 val
&= ~(HOST_WIDE_INT_M1U
<< (bits
- 1) << 1);
11839 /* If TYPE is an integral or pointer type, return an integer type with
11840 the same precision which is unsigned iff UNSIGNEDP is true, or itself
11841 if TYPE is already an integer type of signedness UNSIGNEDP.
11842 If TYPE is a floating-point type, return an integer type with the same
11843 bitsize and with the signedness given by UNSIGNEDP; this is useful
11844 when doing bit-level operations on a floating-point value. */
11847 signed_or_unsigned_type_for (int unsignedp
, tree type
)
11849 if (ANY_INTEGRAL_TYPE_P (type
) && TYPE_UNSIGNED (type
) == unsignedp
)
11852 if (TREE_CODE (type
) == VECTOR_TYPE
)
11854 tree inner
= TREE_TYPE (type
);
11855 tree inner2
= signed_or_unsigned_type_for (unsignedp
, inner
);
11858 if (inner
== inner2
)
11860 return build_vector_type (inner2
, TYPE_VECTOR_SUBPARTS (type
));
11863 if (TREE_CODE (type
) == COMPLEX_TYPE
)
11865 tree inner
= TREE_TYPE (type
);
11866 tree inner2
= signed_or_unsigned_type_for (unsignedp
, inner
);
11869 if (inner
== inner2
)
11871 return build_complex_type (inner2
);
11875 if (INTEGRAL_TYPE_P (type
)
11876 || POINTER_TYPE_P (type
)
11877 || TREE_CODE (type
) == OFFSET_TYPE
)
11878 bits
= TYPE_PRECISION (type
);
11879 else if (TREE_CODE (type
) == REAL_TYPE
)
11880 bits
= GET_MODE_BITSIZE (SCALAR_TYPE_MODE (type
));
11884 return build_nonstandard_integer_type (bits
, unsignedp
);
11887 /* If TYPE is an integral or pointer type, return an integer type with
11888 the same precision which is unsigned, or itself if TYPE is already an
11889 unsigned integer type. If TYPE is a floating-point type, return an
11890 unsigned integer type with the same bitsize as TYPE. */
11893 unsigned_type_for (tree type
)
11895 return signed_or_unsigned_type_for (1, type
);
11898 /* If TYPE is an integral or pointer type, return an integer type with
11899 the same precision which is signed, or itself if TYPE is already a
11900 signed integer type. If TYPE is a floating-point type, return a
11901 signed integer type with the same bitsize as TYPE. */
11904 signed_type_for (tree type
)
11906 return signed_or_unsigned_type_for (0, type
);
11909 /* If TYPE is a vector type, return a signed integer vector type with the
11910 same width and number of subparts. Otherwise return boolean_type_node. */
11913 truth_type_for (tree type
)
11915 if (TREE_CODE (type
) == VECTOR_TYPE
)
11917 if (VECTOR_BOOLEAN_TYPE_P (type
))
11919 return build_truth_vector_type (TYPE_VECTOR_SUBPARTS (type
),
11920 GET_MODE_SIZE (TYPE_MODE (type
)));
11923 return boolean_type_node
;
11926 /* Returns the largest value obtainable by casting something in INNER type to
11930 upper_bound_in_type (tree outer
, tree inner
)
11932 unsigned int det
= 0;
11933 unsigned oprec
= TYPE_PRECISION (outer
);
11934 unsigned iprec
= TYPE_PRECISION (inner
);
11937 /* Compute a unique number for every combination. */
11938 det
|= (oprec
> iprec
) ? 4 : 0;
11939 det
|= TYPE_UNSIGNED (outer
) ? 2 : 0;
11940 det
|= TYPE_UNSIGNED (inner
) ? 1 : 0;
11942 /* Determine the exponent to use. */
11947 /* oprec <= iprec, outer: signed, inner: don't care. */
11952 /* oprec <= iprec, outer: unsigned, inner: don't care. */
11956 /* oprec > iprec, outer: signed, inner: signed. */
11960 /* oprec > iprec, outer: signed, inner: unsigned. */
11964 /* oprec > iprec, outer: unsigned, inner: signed. */
11968 /* oprec > iprec, outer: unsigned, inner: unsigned. */
11972 gcc_unreachable ();
11975 return wide_int_to_tree (outer
,
11976 wi::mask (prec
, false, TYPE_PRECISION (outer
)));
11979 /* Returns the smallest value obtainable by casting something in INNER type to
11983 lower_bound_in_type (tree outer
, tree inner
)
11985 unsigned oprec
= TYPE_PRECISION (outer
);
11986 unsigned iprec
= TYPE_PRECISION (inner
);
11988 /* If OUTER type is unsigned, we can definitely cast 0 to OUTER type
11990 if (TYPE_UNSIGNED (outer
)
11991 /* If we are widening something of an unsigned type, OUTER type
11992 contains all values of INNER type. In particular, both INNER
11993 and OUTER types have zero in common. */
11994 || (oprec
> iprec
&& TYPE_UNSIGNED (inner
)))
11995 return build_int_cst (outer
, 0);
11998 /* If we are widening a signed type to another signed type, we
11999 want to obtain -2^^(iprec-1). If we are keeping the
12000 precision or narrowing to a signed type, we want to obtain
12002 unsigned prec
= oprec
> iprec
? iprec
: oprec
;
12003 return wide_int_to_tree (outer
,
12004 wi::mask (prec
- 1, true,
12005 TYPE_PRECISION (outer
)));
12009 /* Return nonzero if two operands that are suitable for PHI nodes are
12010 necessarily equal. Specifically, both ARG0 and ARG1 must be either
12011 SSA_NAME or invariant. Note that this is strictly an optimization.
12012 That is, callers of this function can directly call operand_equal_p
12013 and get the same result, only slower. */
12016 operand_equal_for_phi_arg_p (const_tree arg0
, const_tree arg1
)
12020 if (TREE_CODE (arg0
) == SSA_NAME
|| TREE_CODE (arg1
) == SSA_NAME
)
12022 return operand_equal_p (arg0
, arg1
, 0);
12025 /* Returns number of zeros at the end of binary representation of X. */
12028 num_ending_zeros (const_tree x
)
12030 return build_int_cst (TREE_TYPE (x
), wi::ctz (wi::to_wide (x
)));
12034 #define WALK_SUBTREE(NODE) \
12037 result = walk_tree_1 (&(NODE), func, data, pset, lh); \
12043 /* This is a subroutine of walk_tree that walks field of TYPE that are to
12044 be walked whenever a type is seen in the tree. Rest of operands and return
12045 value are as for walk_tree. */
12048 walk_type_fields (tree type
, walk_tree_fn func
, void *data
,
12049 hash_set
<tree
> *pset
, walk_tree_lh lh
)
12051 tree result
= NULL_TREE
;
12053 switch (TREE_CODE (type
))
12056 case REFERENCE_TYPE
:
12058 /* We have to worry about mutually recursive pointers. These can't
12059 be written in C. They can in Ada. It's pathological, but
12060 there's an ACATS test (c38102a) that checks it. Deal with this
12061 by checking if we're pointing to another pointer, that one
12062 points to another pointer, that one does too, and we have no htab.
12063 If so, get a hash table. We check three levels deep to avoid
12064 the cost of the hash table if we don't need one. */
12065 if (POINTER_TYPE_P (TREE_TYPE (type
))
12066 && POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (type
)))
12067 && POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (TREE_TYPE (type
))))
12070 result
= walk_tree_without_duplicates (&TREE_TYPE (type
),
12081 WALK_SUBTREE (TREE_TYPE (type
));
12085 WALK_SUBTREE (TYPE_METHOD_BASETYPE (type
));
12087 /* Fall through. */
12089 case FUNCTION_TYPE
:
12090 WALK_SUBTREE (TREE_TYPE (type
));
12094 /* We never want to walk into default arguments. */
12095 for (arg
= TYPE_ARG_TYPES (type
); arg
; arg
= TREE_CHAIN (arg
))
12096 WALK_SUBTREE (TREE_VALUE (arg
));
12101 /* Don't follow this nodes's type if a pointer for fear that
12102 we'll have infinite recursion. If we have a PSET, then we
12105 || (!POINTER_TYPE_P (TREE_TYPE (type
))
12106 && TREE_CODE (TREE_TYPE (type
)) != OFFSET_TYPE
))
12107 WALK_SUBTREE (TREE_TYPE (type
));
12108 WALK_SUBTREE (TYPE_DOMAIN (type
));
12112 WALK_SUBTREE (TREE_TYPE (type
));
12113 WALK_SUBTREE (TYPE_OFFSET_BASETYPE (type
));
12123 /* Apply FUNC to all the sub-trees of TP in a pre-order traversal. FUNC is
12124 called with the DATA and the address of each sub-tree. If FUNC returns a
12125 non-NULL value, the traversal is stopped, and the value returned by FUNC
12126 is returned. If PSET is non-NULL it is used to record the nodes visited,
12127 and to avoid visiting a node more than once. */
12130 walk_tree_1 (tree
*tp
, walk_tree_fn func
, void *data
,
12131 hash_set
<tree
> *pset
, walk_tree_lh lh
)
12133 enum tree_code code
;
12137 #define WALK_SUBTREE_TAIL(NODE) \
12141 goto tail_recurse; \
12146 /* Skip empty subtrees. */
12150 /* Don't walk the same tree twice, if the user has requested
12151 that we avoid doing so. */
12152 if (pset
&& pset
->add (*tp
))
12155 /* Call the function. */
12157 result
= (*func
) (tp
, &walk_subtrees
, data
);
12159 /* If we found something, return it. */
12163 code
= TREE_CODE (*tp
);
12165 /* Even if we didn't, FUNC may have decided that there was nothing
12166 interesting below this point in the tree. */
12167 if (!walk_subtrees
)
12169 /* But we still need to check our siblings. */
12170 if (code
== TREE_LIST
)
12171 WALK_SUBTREE_TAIL (TREE_CHAIN (*tp
));
12172 else if (code
== OMP_CLAUSE
)
12173 WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp
));
12180 result
= (*lh
) (tp
, &walk_subtrees
, func
, data
, pset
);
12181 if (result
|| !walk_subtrees
)
12188 case IDENTIFIER_NODE
:
12195 case PLACEHOLDER_EXPR
:
12199 /* None of these have subtrees other than those already walked
12204 WALK_SUBTREE (TREE_VALUE (*tp
));
12205 WALK_SUBTREE_TAIL (TREE_CHAIN (*tp
));
12210 int len
= TREE_VEC_LENGTH (*tp
);
12215 /* Walk all elements but the first. */
12217 WALK_SUBTREE (TREE_VEC_ELT (*tp
, len
));
12219 /* Now walk the first one as a tail call. */
12220 WALK_SUBTREE_TAIL (TREE_VEC_ELT (*tp
, 0));
12224 WALK_SUBTREE (TREE_REALPART (*tp
));
12225 WALK_SUBTREE_TAIL (TREE_IMAGPART (*tp
));
12229 unsigned HOST_WIDE_INT idx
;
12230 constructor_elt
*ce
;
12232 for (idx
= 0; vec_safe_iterate (CONSTRUCTOR_ELTS (*tp
), idx
, &ce
);
12234 WALK_SUBTREE (ce
->value
);
12239 WALK_SUBTREE_TAIL (TREE_OPERAND (*tp
, 0));
12244 for (decl
= BIND_EXPR_VARS (*tp
); decl
; decl
= DECL_CHAIN (decl
))
12246 /* Walk the DECL_INITIAL and DECL_SIZE. We don't want to walk
12247 into declarations that are just mentioned, rather than
12248 declared; they don't really belong to this part of the tree.
12249 And, we can see cycles: the initializer for a declaration
12250 can refer to the declaration itself. */
12251 WALK_SUBTREE (DECL_INITIAL (decl
));
12252 WALK_SUBTREE (DECL_SIZE (decl
));
12253 WALK_SUBTREE (DECL_SIZE_UNIT (decl
));
12255 WALK_SUBTREE_TAIL (BIND_EXPR_BODY (*tp
));
12258 case STATEMENT_LIST
:
12260 tree_stmt_iterator i
;
12261 for (i
= tsi_start (*tp
); !tsi_end_p (i
); tsi_next (&i
))
12262 WALK_SUBTREE (*tsi_stmt_ptr (i
));
12267 switch (OMP_CLAUSE_CODE (*tp
))
12269 case OMP_CLAUSE_GANG
:
12270 case OMP_CLAUSE__GRIDDIM_
:
12271 WALK_SUBTREE (OMP_CLAUSE_OPERAND (*tp
, 1));
12274 case OMP_CLAUSE_ASYNC
:
12275 case OMP_CLAUSE_WAIT
:
12276 case OMP_CLAUSE_WORKER
:
12277 case OMP_CLAUSE_VECTOR
:
12278 case OMP_CLAUSE_NUM_GANGS
:
12279 case OMP_CLAUSE_NUM_WORKERS
:
12280 case OMP_CLAUSE_VECTOR_LENGTH
:
12281 case OMP_CLAUSE_PRIVATE
:
12282 case OMP_CLAUSE_SHARED
:
12283 case OMP_CLAUSE_FIRSTPRIVATE
:
12284 case OMP_CLAUSE_COPYIN
:
12285 case OMP_CLAUSE_COPYPRIVATE
:
12286 case OMP_CLAUSE_FINAL
:
12287 case OMP_CLAUSE_IF
:
12288 case OMP_CLAUSE_NUM_THREADS
:
12289 case OMP_CLAUSE_SCHEDULE
:
12290 case OMP_CLAUSE_UNIFORM
:
12291 case OMP_CLAUSE_DEPEND
:
12292 case OMP_CLAUSE_NONTEMPORAL
:
12293 case OMP_CLAUSE_NUM_TEAMS
:
12294 case OMP_CLAUSE_THREAD_LIMIT
:
12295 case OMP_CLAUSE_DEVICE
:
12296 case OMP_CLAUSE_DIST_SCHEDULE
:
12297 case OMP_CLAUSE_SAFELEN
:
12298 case OMP_CLAUSE_SIMDLEN
:
12299 case OMP_CLAUSE_ORDERED
:
12300 case OMP_CLAUSE_PRIORITY
:
12301 case OMP_CLAUSE_GRAINSIZE
:
12302 case OMP_CLAUSE_NUM_TASKS
:
12303 case OMP_CLAUSE_HINT
:
12304 case OMP_CLAUSE_TO_DECLARE
:
12305 case OMP_CLAUSE_LINK
:
12306 case OMP_CLAUSE_USE_DEVICE_PTR
:
12307 case OMP_CLAUSE_IS_DEVICE_PTR
:
12308 case OMP_CLAUSE_INCLUSIVE
:
12309 case OMP_CLAUSE_EXCLUSIVE
:
12310 case OMP_CLAUSE__LOOPTEMP_
:
12311 case OMP_CLAUSE__REDUCTEMP_
:
12312 case OMP_CLAUSE__CONDTEMP_
:
12313 case OMP_CLAUSE__SIMDUID_
:
12314 WALK_SUBTREE (OMP_CLAUSE_OPERAND (*tp
, 0));
12317 case OMP_CLAUSE_INDEPENDENT
:
12318 case OMP_CLAUSE_NOWAIT
:
12319 case OMP_CLAUSE_DEFAULT
:
12320 case OMP_CLAUSE_UNTIED
:
12321 case OMP_CLAUSE_MERGEABLE
:
12322 case OMP_CLAUSE_PROC_BIND
:
12323 case OMP_CLAUSE_INBRANCH
:
12324 case OMP_CLAUSE_NOTINBRANCH
:
12325 case OMP_CLAUSE_FOR
:
12326 case OMP_CLAUSE_PARALLEL
:
12327 case OMP_CLAUSE_SECTIONS
:
12328 case OMP_CLAUSE_TASKGROUP
:
12329 case OMP_CLAUSE_NOGROUP
:
12330 case OMP_CLAUSE_THREADS
:
12331 case OMP_CLAUSE_SIMD
:
12332 case OMP_CLAUSE_DEFAULTMAP
:
12333 case OMP_CLAUSE_AUTO
:
12334 case OMP_CLAUSE_SEQ
:
12335 case OMP_CLAUSE_TILE
:
12336 case OMP_CLAUSE__SIMT_
:
12337 case OMP_CLAUSE_IF_PRESENT
:
12338 case OMP_CLAUSE_FINALIZE
:
12339 WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp
));
12341 case OMP_CLAUSE_LASTPRIVATE
:
12342 WALK_SUBTREE (OMP_CLAUSE_DECL (*tp
));
12343 WALK_SUBTREE (OMP_CLAUSE_LASTPRIVATE_STMT (*tp
));
12344 WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp
));
12346 case OMP_CLAUSE_COLLAPSE
:
12349 for (i
= 0; i
< 3; i
++)
12350 WALK_SUBTREE (OMP_CLAUSE_OPERAND (*tp
, i
));
12351 WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp
));
12354 case OMP_CLAUSE_LINEAR
:
12355 WALK_SUBTREE (OMP_CLAUSE_DECL (*tp
));
12356 WALK_SUBTREE (OMP_CLAUSE_LINEAR_STEP (*tp
));
12357 WALK_SUBTREE (OMP_CLAUSE_LINEAR_STMT (*tp
));
12358 WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp
));
12360 case OMP_CLAUSE_ALIGNED
:
12361 case OMP_CLAUSE_FROM
:
12362 case OMP_CLAUSE_TO
:
12363 case OMP_CLAUSE_MAP
:
12364 case OMP_CLAUSE__CACHE_
:
12365 WALK_SUBTREE (OMP_CLAUSE_DECL (*tp
));
12366 WALK_SUBTREE (OMP_CLAUSE_OPERAND (*tp
, 1));
12367 WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp
));
12369 case OMP_CLAUSE_REDUCTION
:
12370 case OMP_CLAUSE_TASK_REDUCTION
:
12371 case OMP_CLAUSE_IN_REDUCTION
:
12374 for (i
= 0; i
< 5; i
++)
12375 WALK_SUBTREE (OMP_CLAUSE_OPERAND (*tp
, i
));
12376 WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp
));
12380 gcc_unreachable ();
12388 /* TARGET_EXPRs are peculiar: operands 1 and 3 can be the same.
12389 But, we only want to walk once. */
12390 len
= (TREE_OPERAND (*tp
, 3) == TREE_OPERAND (*tp
, 1)) ? 2 : 3;
12391 for (i
= 0; i
< len
; ++i
)
12392 WALK_SUBTREE (TREE_OPERAND (*tp
, i
));
12393 WALK_SUBTREE_TAIL (TREE_OPERAND (*tp
, len
));
12397 /* If this is a TYPE_DECL, walk into the fields of the type that it's
12398 defining. We only want to walk into these fields of a type in this
12399 case and not in the general case of a mere reference to the type.
12401 The criterion is as follows: if the field can be an expression, it
12402 must be walked only here. This should be in keeping with the fields
12403 that are directly gimplified in gimplify_type_sizes in order for the
12404 mark/copy-if-shared/unmark machinery of the gimplifier to work with
12405 variable-sized types.
12407 Note that DECLs get walked as part of processing the BIND_EXPR. */
12408 if (TREE_CODE (DECL_EXPR_DECL (*tp
)) == TYPE_DECL
)
12410 tree
*type_p
= &TREE_TYPE (DECL_EXPR_DECL (*tp
));
12411 if (TREE_CODE (*type_p
) == ERROR_MARK
)
12414 /* Call the function for the type. See if it returns anything or
12415 doesn't want us to continue. If we are to continue, walk both
12416 the normal fields and those for the declaration case. */
12417 result
= (*func
) (type_p
, &walk_subtrees
, data
);
12418 if (result
|| !walk_subtrees
)
12421 /* But do not walk a pointed-to type since it may itself need to
12422 be walked in the declaration case if it isn't anonymous. */
12423 if (!POINTER_TYPE_P (*type_p
))
12425 result
= walk_type_fields (*type_p
, func
, data
, pset
, lh
);
12430 /* If this is a record type, also walk the fields. */
12431 if (RECORD_OR_UNION_TYPE_P (*type_p
))
12435 for (field
= TYPE_FIELDS (*type_p
); field
;
12436 field
= DECL_CHAIN (field
))
12438 /* We'd like to look at the type of the field, but we can
12439 easily get infinite recursion. So assume it's pointed
12440 to elsewhere in the tree. Also, ignore things that
12442 if (TREE_CODE (field
) != FIELD_DECL
)
12445 WALK_SUBTREE (DECL_FIELD_OFFSET (field
));
12446 WALK_SUBTREE (DECL_SIZE (field
));
12447 WALK_SUBTREE (DECL_SIZE_UNIT (field
));
12448 if (TREE_CODE (*type_p
) == QUAL_UNION_TYPE
)
12449 WALK_SUBTREE (DECL_QUALIFIER (field
));
12453 /* Same for scalar types. */
12454 else if (TREE_CODE (*type_p
) == BOOLEAN_TYPE
12455 || TREE_CODE (*type_p
) == ENUMERAL_TYPE
12456 || TREE_CODE (*type_p
) == INTEGER_TYPE
12457 || TREE_CODE (*type_p
) == FIXED_POINT_TYPE
12458 || TREE_CODE (*type_p
) == REAL_TYPE
)
12460 WALK_SUBTREE (TYPE_MIN_VALUE (*type_p
));
12461 WALK_SUBTREE (TYPE_MAX_VALUE (*type_p
));
12464 WALK_SUBTREE (TYPE_SIZE (*type_p
));
12465 WALK_SUBTREE_TAIL (TYPE_SIZE_UNIT (*type_p
));
12470 if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (code
)))
12474 /* Walk over all the sub-trees of this operand. */
12475 len
= TREE_OPERAND_LENGTH (*tp
);
12477 /* Go through the subtrees. We need to do this in forward order so
12478 that the scope of a FOR_EXPR is handled properly. */
12481 for (i
= 0; i
< len
- 1; ++i
)
12482 WALK_SUBTREE (TREE_OPERAND (*tp
, i
));
12483 WALK_SUBTREE_TAIL (TREE_OPERAND (*tp
, len
- 1));
12486 /* If this is a type, walk the needed fields in the type. */
12487 else if (TYPE_P (*tp
))
12488 return walk_type_fields (*tp
, func
, data
, pset
, lh
);
12492 /* We didn't find what we were looking for. */
12495 #undef WALK_SUBTREE_TAIL
12497 #undef WALK_SUBTREE
12499 /* Like walk_tree, but does not walk duplicate nodes more than once. */
12502 walk_tree_without_duplicates_1 (tree
*tp
, walk_tree_fn func
, void *data
,
12507 hash_set
<tree
> pset
;
12508 result
= walk_tree_1 (tp
, func
, data
, &pset
, lh
);
12514 tree_block (tree t
)
12516 const enum tree_code_class c
= TREE_CODE_CLASS (TREE_CODE (t
));
12518 if (IS_EXPR_CODE_CLASS (c
))
12519 return LOCATION_BLOCK (t
->exp
.locus
);
12520 gcc_unreachable ();
12525 tree_set_block (tree t
, tree b
)
12527 const enum tree_code_class c
= TREE_CODE_CLASS (TREE_CODE (t
));
12529 if (IS_EXPR_CODE_CLASS (c
))
12531 t
->exp
.locus
= set_block (t
->exp
.locus
, b
);
12534 gcc_unreachable ();
12537 /* Create a nameless artificial label and put it in the current
12538 function context. The label has a location of LOC. Returns the
12539 newly created label. */
12542 create_artificial_label (location_t loc
)
12544 tree lab
= build_decl (loc
,
12545 LABEL_DECL
, NULL_TREE
, void_type_node
);
12547 DECL_ARTIFICIAL (lab
) = 1;
12548 DECL_IGNORED_P (lab
) = 1;
12549 DECL_CONTEXT (lab
) = current_function_decl
;
12553 /* Given a tree, try to return a useful variable name that we can use
12554 to prefix a temporary that is being assigned the value of the tree.
12555 I.E. given <temp> = &A, return A. */
12560 tree stripped_decl
;
12563 STRIP_NOPS (stripped_decl
);
12564 if (DECL_P (stripped_decl
) && DECL_NAME (stripped_decl
))
12565 return IDENTIFIER_POINTER (DECL_NAME (stripped_decl
));
12566 else if (TREE_CODE (stripped_decl
) == SSA_NAME
)
12568 tree name
= SSA_NAME_IDENTIFIER (stripped_decl
);
12571 return IDENTIFIER_POINTER (name
);
12575 switch (TREE_CODE (stripped_decl
))
12578 return get_name (TREE_OPERAND (stripped_decl
, 0));
12585 /* Return true if TYPE has a variable argument list. */
12588 stdarg_p (const_tree fntype
)
12590 function_args_iterator args_iter
;
12591 tree n
= NULL_TREE
, t
;
12596 FOREACH_FUNCTION_ARGS (fntype
, t
, args_iter
)
12601 return n
!= NULL_TREE
&& n
!= void_type_node
;
12604 /* Return true if TYPE has a prototype. */
12607 prototype_p (const_tree fntype
)
12611 gcc_assert (fntype
!= NULL_TREE
);
12613 t
= TYPE_ARG_TYPES (fntype
);
12614 return (t
!= NULL_TREE
);
12617 /* If BLOCK is inlined from an __attribute__((__artificial__))
12618 routine, return pointer to location from where it has been
12621 block_nonartificial_location (tree block
)
12623 location_t
*ret
= NULL
;
12625 while (block
&& TREE_CODE (block
) == BLOCK
12626 && BLOCK_ABSTRACT_ORIGIN (block
))
12628 tree ao
= BLOCK_ABSTRACT_ORIGIN (block
);
12629 if (TREE_CODE (ao
) == FUNCTION_DECL
)
12631 /* If AO is an artificial inline, point RET to the
12632 call site locus at which it has been inlined and continue
12633 the loop, in case AO's caller is also an artificial
12635 if (DECL_DECLARED_INLINE_P (ao
)
12636 && lookup_attribute ("artificial", DECL_ATTRIBUTES (ao
)))
12637 ret
= &BLOCK_SOURCE_LOCATION (block
);
12641 else if (TREE_CODE (ao
) != BLOCK
)
12644 block
= BLOCK_SUPERCONTEXT (block
);
12650 /* If EXP is inlined from an __attribute__((__artificial__))
12651 function, return the location of the original call expression. */
12654 tree_nonartificial_location (tree exp
)
12656 location_t
*loc
= block_nonartificial_location (TREE_BLOCK (exp
));
12661 return EXPR_LOCATION (exp
);
12665 /* These are the hash table functions for the hash table of OPTIMIZATION_NODEq
12668 /* Return the hash code X, an OPTIMIZATION_NODE or TARGET_OPTION code. */
12671 cl_option_hasher::hash (tree x
)
12673 const_tree
const t
= x
;
12677 hashval_t hash
= 0;
12679 if (TREE_CODE (t
) == OPTIMIZATION_NODE
)
12681 p
= (const char *)TREE_OPTIMIZATION (t
);
12682 len
= sizeof (struct cl_optimization
);
12685 else if (TREE_CODE (t
) == TARGET_OPTION_NODE
)
12686 return cl_target_option_hash (TREE_TARGET_OPTION (t
));
12689 gcc_unreachable ();
12691 /* assume most opt flags are just 0/1, some are 2-3, and a few might be
12693 for (i
= 0; i
< len
; i
++)
12695 hash
= (hash
<< 4) ^ ((i
<< 2) | p
[i
]);
12700 /* Return nonzero if the value represented by *X (an OPTIMIZATION or
12701 TARGET_OPTION tree node) is the same as that given by *Y, which is the
12705 cl_option_hasher::equal (tree x
, tree y
)
12707 const_tree
const xt
= x
;
12708 const_tree
const yt
= y
;
12710 if (TREE_CODE (xt
) != TREE_CODE (yt
))
12713 if (TREE_CODE (xt
) == OPTIMIZATION_NODE
)
12714 return cl_optimization_option_eq (TREE_OPTIMIZATION (xt
),
12715 TREE_OPTIMIZATION (yt
));
12716 else if (TREE_CODE (xt
) == TARGET_OPTION_NODE
)
12717 return cl_target_option_eq (TREE_TARGET_OPTION (xt
),
12718 TREE_TARGET_OPTION (yt
));
12720 gcc_unreachable ();
12723 /* Build an OPTIMIZATION_NODE based on the options in OPTS. */
12726 build_optimization_node (struct gcc_options
*opts
)
12730 /* Use the cache of optimization nodes. */
12732 cl_optimization_save (TREE_OPTIMIZATION (cl_optimization_node
),
12735 tree
*slot
= cl_option_hash_table
->find_slot (cl_optimization_node
, INSERT
);
12739 /* Insert this one into the hash table. */
12740 t
= cl_optimization_node
;
12743 /* Make a new node for next time round. */
12744 cl_optimization_node
= make_node (OPTIMIZATION_NODE
);
12750 /* Build a TARGET_OPTION_NODE based on the options in OPTS. */
12753 build_target_option_node (struct gcc_options
*opts
)
12757 /* Use the cache of optimization nodes. */
12759 cl_target_option_save (TREE_TARGET_OPTION (cl_target_option_node
),
12762 tree
*slot
= cl_option_hash_table
->find_slot (cl_target_option_node
, INSERT
);
12766 /* Insert this one into the hash table. */
12767 t
= cl_target_option_node
;
12770 /* Make a new node for next time round. */
12771 cl_target_option_node
= make_node (TARGET_OPTION_NODE
);
12777 /* Clear TREE_TARGET_GLOBALS of all TARGET_OPTION_NODE trees,
12778 so that they aren't saved during PCH writing. */
12781 prepare_target_option_nodes_for_pch (void)
12783 hash_table
<cl_option_hasher
>::iterator iter
= cl_option_hash_table
->begin ();
12784 for (; iter
!= cl_option_hash_table
->end (); ++iter
)
12785 if (TREE_CODE (*iter
) == TARGET_OPTION_NODE
)
12786 TREE_TARGET_GLOBALS (*iter
) = NULL
;
12789 /* Determine the "ultimate origin" of a block. */
12792 block_ultimate_origin (const_tree block
)
12794 tree origin
= BLOCK_ABSTRACT_ORIGIN (block
);
12796 if (origin
== NULL_TREE
)
12800 gcc_checking_assert ((DECL_P (origin
)
12801 && DECL_ORIGIN (origin
) == origin
)
12802 || BLOCK_ORIGIN (origin
) == origin
);
12807 /* Return true iff conversion from INNER_TYPE to OUTER_TYPE generates
12811 tree_nop_conversion_p (const_tree outer_type
, const_tree inner_type
)
12813 /* Do not strip casts into or out of differing address spaces. */
12814 if (POINTER_TYPE_P (outer_type
)
12815 && TYPE_ADDR_SPACE (TREE_TYPE (outer_type
)) != ADDR_SPACE_GENERIC
)
12817 if (!POINTER_TYPE_P (inner_type
)
12818 || (TYPE_ADDR_SPACE (TREE_TYPE (outer_type
))
12819 != TYPE_ADDR_SPACE (TREE_TYPE (inner_type
))))
12822 else if (POINTER_TYPE_P (inner_type
)
12823 && TYPE_ADDR_SPACE (TREE_TYPE (inner_type
)) != ADDR_SPACE_GENERIC
)
12825 /* We already know that outer_type is not a pointer with
12826 a non-generic address space. */
12830 /* Use precision rather then machine mode when we can, which gives
12831 the correct answer even for submode (bit-field) types. */
12832 if ((INTEGRAL_TYPE_P (outer_type
)
12833 || POINTER_TYPE_P (outer_type
)
12834 || TREE_CODE (outer_type
) == OFFSET_TYPE
)
12835 && (INTEGRAL_TYPE_P (inner_type
)
12836 || POINTER_TYPE_P (inner_type
)
12837 || TREE_CODE (inner_type
) == OFFSET_TYPE
))
12838 return TYPE_PRECISION (outer_type
) == TYPE_PRECISION (inner_type
);
12840 /* Otherwise fall back on comparing machine modes (e.g. for
12841 aggregate types, floats). */
12842 return TYPE_MODE (outer_type
) == TYPE_MODE (inner_type
);
12845 /* Return true iff conversion in EXP generates no instruction. Mark
12846 it inline so that we fully inline into the stripping functions even
12847 though we have two uses of this function. */
12850 tree_nop_conversion (const_tree exp
)
12852 tree outer_type
, inner_type
;
12854 if (location_wrapper_p (exp
))
12856 if (!CONVERT_EXPR_P (exp
)
12857 && TREE_CODE (exp
) != NON_LVALUE_EXPR
)
12860 outer_type
= TREE_TYPE (exp
);
12861 inner_type
= TREE_TYPE (TREE_OPERAND (exp
, 0));
12862 if (!inner_type
|| inner_type
== error_mark_node
)
12865 return tree_nop_conversion_p (outer_type
, inner_type
);
12868 /* Return true iff conversion in EXP generates no instruction. Don't
12869 consider conversions changing the signedness. */
12872 tree_sign_nop_conversion (const_tree exp
)
12874 tree outer_type
, inner_type
;
12876 if (!tree_nop_conversion (exp
))
12879 outer_type
= TREE_TYPE (exp
);
12880 inner_type
= TREE_TYPE (TREE_OPERAND (exp
, 0));
12882 return (TYPE_UNSIGNED (outer_type
) == TYPE_UNSIGNED (inner_type
)
12883 && POINTER_TYPE_P (outer_type
) == POINTER_TYPE_P (inner_type
));
12886 /* Strip conversions from EXP according to tree_nop_conversion and
12887 return the resulting expression. */
12890 tree_strip_nop_conversions (tree exp
)
12892 while (tree_nop_conversion (exp
))
12893 exp
= TREE_OPERAND (exp
, 0);
12897 /* Strip conversions from EXP according to tree_sign_nop_conversion
12898 and return the resulting expression. */
12901 tree_strip_sign_nop_conversions (tree exp
)
12903 while (tree_sign_nop_conversion (exp
))
12904 exp
= TREE_OPERAND (exp
, 0);
12908 /* Avoid any floating point extensions from EXP. */
12910 strip_float_extensions (tree exp
)
12912 tree sub
, expt
, subt
;
12914 /* For floating point constant look up the narrowest type that can hold
12915 it properly and handle it like (type)(narrowest_type)constant.
12916 This way we can optimize for instance a=a*2.0 where "a" is float
12917 but 2.0 is double constant. */
12918 if (TREE_CODE (exp
) == REAL_CST
&& !DECIMAL_FLOAT_TYPE_P (TREE_TYPE (exp
)))
12920 REAL_VALUE_TYPE orig
;
12923 orig
= TREE_REAL_CST (exp
);
12924 if (TYPE_PRECISION (TREE_TYPE (exp
)) > TYPE_PRECISION (float_type_node
)
12925 && exact_real_truncate (TYPE_MODE (float_type_node
), &orig
))
12926 type
= float_type_node
;
12927 else if (TYPE_PRECISION (TREE_TYPE (exp
))
12928 > TYPE_PRECISION (double_type_node
)
12929 && exact_real_truncate (TYPE_MODE (double_type_node
), &orig
))
12930 type
= double_type_node
;
12932 return build_real_truncate (type
, orig
);
12935 if (!CONVERT_EXPR_P (exp
))
12938 sub
= TREE_OPERAND (exp
, 0);
12939 subt
= TREE_TYPE (sub
);
12940 expt
= TREE_TYPE (exp
);
12942 if (!FLOAT_TYPE_P (subt
))
12945 if (DECIMAL_FLOAT_TYPE_P (expt
) != DECIMAL_FLOAT_TYPE_P (subt
))
12948 if (TYPE_PRECISION (subt
) > TYPE_PRECISION (expt
))
12951 return strip_float_extensions (sub
);
12954 /* Strip out all handled components that produce invariant
12958 strip_invariant_refs (const_tree op
)
12960 while (handled_component_p (op
))
12962 switch (TREE_CODE (op
))
12965 case ARRAY_RANGE_REF
:
12966 if (!is_gimple_constant (TREE_OPERAND (op
, 1))
12967 || TREE_OPERAND (op
, 2) != NULL_TREE
12968 || TREE_OPERAND (op
, 3) != NULL_TREE
)
12972 case COMPONENT_REF
:
12973 if (TREE_OPERAND (op
, 2) != NULL_TREE
)
12979 op
= TREE_OPERAND (op
, 0);
12985 static GTY(()) tree gcc_eh_personality_decl
;
12987 /* Return the GCC personality function decl. */
12990 lhd_gcc_personality (void)
12992 if (!gcc_eh_personality_decl
)
12993 gcc_eh_personality_decl
= build_personality_function ("gcc");
12994 return gcc_eh_personality_decl
;
12997 /* TARGET is a call target of GIMPLE call statement
12998 (obtained by gimple_call_fn). Return true if it is
12999 OBJ_TYPE_REF representing an virtual call of C++ method.
13000 (As opposed to OBJ_TYPE_REF representing objc calls
13001 through a cast where middle-end devirtualization machinery
13005 virtual_method_call_p (const_tree target
)
13007 if (TREE_CODE (target
) != OBJ_TYPE_REF
)
13009 tree t
= TREE_TYPE (target
);
13010 gcc_checking_assert (TREE_CODE (t
) == POINTER_TYPE
);
13012 if (TREE_CODE (t
) == FUNCTION_TYPE
)
13014 gcc_checking_assert (TREE_CODE (t
) == METHOD_TYPE
);
13015 /* If we do not have BINFO associated, it means that type was built
13016 without devirtualization enabled. Do not consider this a virtual
13018 if (!TYPE_BINFO (obj_type_ref_class (target
)))
13023 /* Lookup sub-BINFO of BINFO of TYPE at offset POS. */
13026 lookup_binfo_at_offset (tree binfo
, tree type
, HOST_WIDE_INT pos
)
13029 tree base_binfo
, b
;
13031 for (i
= 0; BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
13032 if (pos
== tree_to_shwi (BINFO_OFFSET (base_binfo
))
13033 && types_same_for_odr (TREE_TYPE (base_binfo
), type
))
13035 else if ((b
= lookup_binfo_at_offset (base_binfo
, type
, pos
)) != NULL
)
13040 /* Try to find a base info of BINFO that would have its field decl at offset
13041 OFFSET within the BINFO type and which is of EXPECTED_TYPE. If it can be
13042 found, return, otherwise return NULL_TREE. */
13045 get_binfo_at_offset (tree binfo
, poly_int64 offset
, tree expected_type
)
13047 tree type
= BINFO_TYPE (binfo
);
13051 HOST_WIDE_INT pos
, size
;
13055 if (types_same_for_odr (type
, expected_type
))
13057 if (maybe_lt (offset
, 0))
13060 for (fld
= TYPE_FIELDS (type
); fld
; fld
= DECL_CHAIN (fld
))
13062 if (TREE_CODE (fld
) != FIELD_DECL
|| !DECL_ARTIFICIAL (fld
))
13065 pos
= int_bit_position (fld
);
13066 size
= tree_to_uhwi (DECL_SIZE (fld
));
13067 if (known_in_range_p (offset
, pos
, size
))
13070 if (!fld
|| TREE_CODE (TREE_TYPE (fld
)) != RECORD_TYPE
)
13073 /* Offset 0 indicates the primary base, whose vtable contents are
13074 represented in the binfo for the derived class. */
13075 else if (maybe_ne (offset
, 0))
13077 tree found_binfo
= NULL
, base_binfo
;
13078 /* Offsets in BINFO are in bytes relative to the whole structure
13079 while POS is in bits relative to the containing field. */
13080 int binfo_offset
= (tree_to_shwi (BINFO_OFFSET (binfo
)) + pos
13083 for (i
= 0; BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
13084 if (tree_to_shwi (BINFO_OFFSET (base_binfo
)) == binfo_offset
13085 && types_same_for_odr (TREE_TYPE (base_binfo
), TREE_TYPE (fld
)))
13087 found_binfo
= base_binfo
;
13091 binfo
= found_binfo
;
13093 binfo
= lookup_binfo_at_offset (binfo
, TREE_TYPE (fld
),
13097 type
= TREE_TYPE (fld
);
13102 /* Returns true if X is a typedef decl. */
13105 is_typedef_decl (const_tree x
)
13107 return (x
&& TREE_CODE (x
) == TYPE_DECL
13108 && DECL_ORIGINAL_TYPE (x
) != NULL_TREE
);
13111 /* Returns true iff TYPE is a type variant created for a typedef. */
13114 typedef_variant_p (const_tree type
)
13116 return is_typedef_decl (TYPE_NAME (type
));
13119 /* A class to handle converting a string that might contain
13120 control characters, (eg newline, form-feed, etc), into one
13121 in which contains escape sequences instead. */
13123 class escaped_string
13126 escaped_string () { m_owned
= false; m_str
= NULL
; };
13127 ~escaped_string () { if (m_owned
) free (m_str
); }
13128 operator const char *() const { return (const char *) m_str
; }
13129 void escape (const char *);
13135 /* PR 84195: Replace control characters in "unescaped" with their
13136 escaped equivalents. Allow newlines if -fmessage-length has
13137 been set to a non-zero value. This is done here, rather than
13138 where the attribute is recorded as the message length can
13139 change between these two locations. */
13142 escaped_string::escape (const char *unescaped
)
13145 size_t i
, new_i
, len
;
13150 m_str
= const_cast<char *> (unescaped
);
13153 if (unescaped
== NULL
|| *unescaped
== 0)
13156 len
= strlen (unescaped
);
13160 for (i
= 0; i
< len
; i
++)
13162 char c
= unescaped
[i
];
13167 escaped
[new_i
++] = c
;
13171 if (c
!= '\n' || !pp_is_wrapping_line (global_dc
->printer
))
13173 if (escaped
== NULL
)
13175 /* We only allocate space for a new string if we
13176 actually encounter a control character that
13177 needs replacing. */
13178 escaped
= (char *) xmalloc (len
* 2 + 1);
13179 strncpy (escaped
, unescaped
, i
);
13183 escaped
[new_i
++] = '\\';
13187 case '\a': escaped
[new_i
++] = 'a'; break;
13188 case '\b': escaped
[new_i
++] = 'b'; break;
13189 case '\f': escaped
[new_i
++] = 'f'; break;
13190 case '\n': escaped
[new_i
++] = 'n'; break;
13191 case '\r': escaped
[new_i
++] = 'r'; break;
13192 case '\t': escaped
[new_i
++] = 't'; break;
13193 case '\v': escaped
[new_i
++] = 'v'; break;
13194 default: escaped
[new_i
++] = '?'; break;
13198 escaped
[new_i
++] = c
;
13203 escaped
[new_i
] = 0;
13209 /* Warn about a use of an identifier which was marked deprecated. Returns
13210 whether a warning was given. */
13213 warn_deprecated_use (tree node
, tree attr
)
13215 escaped_string msg
;
13217 if (node
== 0 || !warn_deprecated_decl
)
13223 attr
= DECL_ATTRIBUTES (node
);
13224 else if (TYPE_P (node
))
13226 tree decl
= TYPE_STUB_DECL (node
);
13228 attr
= lookup_attribute ("deprecated",
13229 TYPE_ATTRIBUTES (TREE_TYPE (decl
)));
13234 attr
= lookup_attribute ("deprecated", attr
);
13237 msg
.escape (TREE_STRING_POINTER (TREE_VALUE (TREE_VALUE (attr
))));
13242 auto_diagnostic_group d
;
13244 w
= warning (OPT_Wdeprecated_declarations
,
13245 "%qD is deprecated: %s", node
, (const char *) msg
);
13247 w
= warning (OPT_Wdeprecated_declarations
,
13248 "%qD is deprecated", node
);
13250 inform (DECL_SOURCE_LOCATION (node
), "declared here");
13252 else if (TYPE_P (node
))
13254 tree what
= NULL_TREE
;
13255 tree decl
= TYPE_STUB_DECL (node
);
13257 if (TYPE_NAME (node
))
13259 if (TREE_CODE (TYPE_NAME (node
)) == IDENTIFIER_NODE
)
13260 what
= TYPE_NAME (node
);
13261 else if (TREE_CODE (TYPE_NAME (node
)) == TYPE_DECL
13262 && DECL_NAME (TYPE_NAME (node
)))
13263 what
= DECL_NAME (TYPE_NAME (node
));
13266 auto_diagnostic_group d
;
13270 w
= warning (OPT_Wdeprecated_declarations
,
13271 "%qE is deprecated: %s", what
, (const char *) msg
);
13273 w
= warning (OPT_Wdeprecated_declarations
,
13274 "%qE is deprecated", what
);
13279 w
= warning (OPT_Wdeprecated_declarations
,
13280 "type is deprecated: %s", (const char *) msg
);
13282 w
= warning (OPT_Wdeprecated_declarations
,
13283 "type is deprecated");
13287 inform (DECL_SOURCE_LOCATION (decl
), "declared here");
13293 /* Return true if REF has a COMPONENT_REF with a bit-field field declaration
13294 somewhere in it. */
13297 contains_bitfld_component_ref_p (const_tree ref
)
13299 while (handled_component_p (ref
))
13301 if (TREE_CODE (ref
) == COMPONENT_REF
13302 && DECL_BIT_FIELD (TREE_OPERAND (ref
, 1)))
13304 ref
= TREE_OPERAND (ref
, 0);
13310 /* Try to determine whether a TRY_CATCH expression can fall through.
13311 This is a subroutine of block_may_fallthru. */
13314 try_catch_may_fallthru (const_tree stmt
)
13316 tree_stmt_iterator i
;
13318 /* If the TRY block can fall through, the whole TRY_CATCH can
13320 if (block_may_fallthru (TREE_OPERAND (stmt
, 0)))
13323 i
= tsi_start (TREE_OPERAND (stmt
, 1));
13324 switch (TREE_CODE (tsi_stmt (i
)))
13327 /* We expect to see a sequence of CATCH_EXPR trees, each with a
13328 catch expression and a body. The whole TRY_CATCH may fall
13329 through iff any of the catch bodies falls through. */
13330 for (; !tsi_end_p (i
); tsi_next (&i
))
13332 if (block_may_fallthru (CATCH_BODY (tsi_stmt (i
))))
13337 case EH_FILTER_EXPR
:
13338 /* The exception filter expression only matters if there is an
13339 exception. If the exception does not match EH_FILTER_TYPES,
13340 we will execute EH_FILTER_FAILURE, and we will fall through
13341 if that falls through. If the exception does match
13342 EH_FILTER_TYPES, the stack unwinder will continue up the
13343 stack, so we will not fall through. We don't know whether we
13344 will throw an exception which matches EH_FILTER_TYPES or not,
13345 so we just ignore EH_FILTER_TYPES and assume that we might
13346 throw an exception which doesn't match. */
13347 return block_may_fallthru (EH_FILTER_FAILURE (tsi_stmt (i
)));
13350 /* This case represents statements to be executed when an
13351 exception occurs. Those statements are implicitly followed
13352 by a RESX statement to resume execution after the exception.
13353 So in this case the TRY_CATCH never falls through. */
13358 /* Try to determine if we can fall out of the bottom of BLOCK. This guess
13359 need not be 100% accurate; simply be conservative and return true if we
13360 don't know. This is used only to avoid stupidly generating extra code.
13361 If we're wrong, we'll just delete the extra code later. */
13364 block_may_fallthru (const_tree block
)
13366 /* This CONST_CAST is okay because expr_last returns its argument
13367 unmodified and we assign it to a const_tree. */
13368 const_tree stmt
= expr_last (CONST_CAST_TREE (block
));
13370 switch (stmt
? TREE_CODE (stmt
) : ERROR_MARK
)
13374 /* Easy cases. If the last statement of the block implies
13375 control transfer, then we can't fall through. */
13379 /* If there is a default: label or case labels cover all possible
13380 SWITCH_COND values, then the SWITCH_EXPR will transfer control
13381 to some case label in all cases and all we care is whether the
13382 SWITCH_BODY falls through. */
13383 if (SWITCH_ALL_CASES_P (stmt
))
13384 return block_may_fallthru (SWITCH_BODY (stmt
));
13388 if (block_may_fallthru (COND_EXPR_THEN (stmt
)))
13390 return block_may_fallthru (COND_EXPR_ELSE (stmt
));
13393 return block_may_fallthru (BIND_EXPR_BODY (stmt
));
13395 case TRY_CATCH_EXPR
:
13396 return try_catch_may_fallthru (stmt
);
13398 case TRY_FINALLY_EXPR
:
13399 /* The finally clause is always executed after the try clause,
13400 so if it does not fall through, then the try-finally will not
13401 fall through. Otherwise, if the try clause does not fall
13402 through, then when the finally clause falls through it will
13403 resume execution wherever the try clause was going. So the
13404 whole try-finally will only fall through if both the try
13405 clause and the finally clause fall through. */
13406 return (block_may_fallthru (TREE_OPERAND (stmt
, 0))
13407 && block_may_fallthru (TREE_OPERAND (stmt
, 1)));
13410 if (TREE_CODE (TREE_OPERAND (stmt
, 1)) == CALL_EXPR
)
13411 stmt
= TREE_OPERAND (stmt
, 1);
13417 /* Functions that do not return do not fall through. */
13418 return (call_expr_flags (stmt
) & ECF_NORETURN
) == 0;
13420 case CLEANUP_POINT_EXPR
:
13421 return block_may_fallthru (TREE_OPERAND (stmt
, 0));
13424 return block_may_fallthru (TREE_OPERAND (stmt
, 1));
13430 return lang_hooks
.block_may_fallthru (stmt
);
13434 /* True if we are using EH to handle cleanups. */
13435 static bool using_eh_for_cleanups_flag
= false;
13437 /* This routine is called from front ends to indicate eh should be used for
13440 using_eh_for_cleanups (void)
13442 using_eh_for_cleanups_flag
= true;
13445 /* Query whether EH is used for cleanups. */
13447 using_eh_for_cleanups_p (void)
13449 return using_eh_for_cleanups_flag
;
13452 /* Wrapper for tree_code_name to ensure that tree code is valid */
13454 get_tree_code_name (enum tree_code code
)
13456 const char *invalid
= "<invalid tree code>";
13458 if (code
>= MAX_TREE_CODES
)
13460 if (code
== 0xa5a5)
13461 return "ggc_freed";
13465 return tree_code_name
[code
];
13468 /* Drops the TREE_OVERFLOW flag from T. */
13471 drop_tree_overflow (tree t
)
13473 gcc_checking_assert (TREE_OVERFLOW (t
));
13475 /* For tree codes with a sharing machinery re-build the result. */
13476 if (poly_int_tree_p (t
))
13477 return wide_int_to_tree (TREE_TYPE (t
), wi::to_poly_wide (t
));
13479 /* For VECTOR_CST, remove the overflow bits from the encoded elements
13480 and canonicalize the result. */
13481 if (TREE_CODE (t
) == VECTOR_CST
)
13483 tree_vector_builder builder
;
13484 builder
.new_unary_operation (TREE_TYPE (t
), t
, true);
13485 unsigned int count
= builder
.encoded_nelts ();
13486 for (unsigned int i
= 0; i
< count
; ++i
)
13488 tree elt
= VECTOR_CST_ELT (t
, i
);
13489 if (TREE_OVERFLOW (elt
))
13490 elt
= drop_tree_overflow (elt
);
13491 builder
.quick_push (elt
);
13493 return builder
.build ();
13496 /* Otherwise, as all tcc_constants are possibly shared, copy the node
13497 and drop the flag. */
13499 TREE_OVERFLOW (t
) = 0;
13501 /* For constants that contain nested constants, drop the flag
13502 from those as well. */
13503 if (TREE_CODE (t
) == COMPLEX_CST
)
13505 if (TREE_OVERFLOW (TREE_REALPART (t
)))
13506 TREE_REALPART (t
) = drop_tree_overflow (TREE_REALPART (t
));
13507 if (TREE_OVERFLOW (TREE_IMAGPART (t
)))
13508 TREE_IMAGPART (t
) = drop_tree_overflow (TREE_IMAGPART (t
));
13514 /* Given a memory reference expression T, return its base address.
13515 The base address of a memory reference expression is the main
13516 object being referenced. For instance, the base address for
13517 'array[i].fld[j]' is 'array'. You can think of this as stripping
13518 away the offset part from a memory address.
13520 This function calls handled_component_p to strip away all the inner
13521 parts of the memory reference until it reaches the base object. */
13524 get_base_address (tree t
)
13526 while (handled_component_p (t
))
13527 t
= TREE_OPERAND (t
, 0);
13529 if ((TREE_CODE (t
) == MEM_REF
13530 || TREE_CODE (t
) == TARGET_MEM_REF
)
13531 && TREE_CODE (TREE_OPERAND (t
, 0)) == ADDR_EXPR
)
13532 t
= TREE_OPERAND (TREE_OPERAND (t
, 0), 0);
13534 /* ??? Either the alias oracle or all callers need to properly deal
13535 with WITH_SIZE_EXPRs before we can look through those. */
13536 if (TREE_CODE (t
) == WITH_SIZE_EXPR
)
13542 /* Return a tree of sizetype representing the size, in bytes, of the element
13543 of EXP, an ARRAY_REF or an ARRAY_RANGE_REF. */
13546 array_ref_element_size (tree exp
)
13548 tree aligned_size
= TREE_OPERAND (exp
, 3);
13549 tree elmt_type
= TREE_TYPE (TREE_TYPE (TREE_OPERAND (exp
, 0)));
13550 location_t loc
= EXPR_LOCATION (exp
);
13552 /* If a size was specified in the ARRAY_REF, it's the size measured
13553 in alignment units of the element type. So multiply by that value. */
13556 /* ??? tree_ssa_useless_type_conversion will eliminate casts to
13557 sizetype from another type of the same width and signedness. */
13558 if (TREE_TYPE (aligned_size
) != sizetype
)
13559 aligned_size
= fold_convert_loc (loc
, sizetype
, aligned_size
);
13560 return size_binop_loc (loc
, MULT_EXPR
, aligned_size
,
13561 size_int (TYPE_ALIGN_UNIT (elmt_type
)));
13564 /* Otherwise, take the size from that of the element type. Substitute
13565 any PLACEHOLDER_EXPR that we have. */
13567 return SUBSTITUTE_PLACEHOLDER_IN_EXPR (TYPE_SIZE_UNIT (elmt_type
), exp
);
13570 /* Return a tree representing the lower bound of the array mentioned in
13571 EXP, an ARRAY_REF or an ARRAY_RANGE_REF. */
13574 array_ref_low_bound (tree exp
)
13576 tree domain_type
= TYPE_DOMAIN (TREE_TYPE (TREE_OPERAND (exp
, 0)));
13578 /* If a lower bound is specified in EXP, use it. */
13579 if (TREE_OPERAND (exp
, 2))
13580 return TREE_OPERAND (exp
, 2);
13582 /* Otherwise, if there is a domain type and it has a lower bound, use it,
13583 substituting for a PLACEHOLDER_EXPR as needed. */
13584 if (domain_type
&& TYPE_MIN_VALUE (domain_type
))
13585 return SUBSTITUTE_PLACEHOLDER_IN_EXPR (TYPE_MIN_VALUE (domain_type
), exp
);
13587 /* Otherwise, return a zero of the appropriate type. */
13588 return build_int_cst (TREE_TYPE (TREE_OPERAND (exp
, 1)), 0);
13591 /* Return a tree representing the upper bound of the array mentioned in
13592 EXP, an ARRAY_REF or an ARRAY_RANGE_REF. */
13595 array_ref_up_bound (tree exp
)
13597 tree domain_type
= TYPE_DOMAIN (TREE_TYPE (TREE_OPERAND (exp
, 0)));
13599 /* If there is a domain type and it has an upper bound, use it, substituting
13600 for a PLACEHOLDER_EXPR as needed. */
13601 if (domain_type
&& TYPE_MAX_VALUE (domain_type
))
13602 return SUBSTITUTE_PLACEHOLDER_IN_EXPR (TYPE_MAX_VALUE (domain_type
), exp
);
13604 /* Otherwise fail. */
13608 /* Returns true if REF is an array reference or a component reference
13609 to an array at the end of a structure.
13610 If this is the case, the array may be allocated larger
13611 than its upper bound implies. */
13614 array_at_struct_end_p (tree ref
)
13618 if (TREE_CODE (ref
) == ARRAY_REF
13619 || TREE_CODE (ref
) == ARRAY_RANGE_REF
)
13621 atype
= TREE_TYPE (TREE_OPERAND (ref
, 0));
13622 ref
= TREE_OPERAND (ref
, 0);
13624 else if (TREE_CODE (ref
) == COMPONENT_REF
13625 && TREE_CODE (TREE_TYPE (TREE_OPERAND (ref
, 1))) == ARRAY_TYPE
)
13626 atype
= TREE_TYPE (TREE_OPERAND (ref
, 1));
13630 if (TREE_CODE (ref
) == STRING_CST
)
13633 tree ref_to_array
= ref
;
13634 while (handled_component_p (ref
))
13636 /* If the reference chain contains a component reference to a
13637 non-union type and there follows another field the reference
13638 is not at the end of a structure. */
13639 if (TREE_CODE (ref
) == COMPONENT_REF
)
13641 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (ref
, 0))) == RECORD_TYPE
)
13643 tree nextf
= DECL_CHAIN (TREE_OPERAND (ref
, 1));
13644 while (nextf
&& TREE_CODE (nextf
) != FIELD_DECL
)
13645 nextf
= DECL_CHAIN (nextf
);
13650 /* If we have a multi-dimensional array we do not consider
13651 a non-innermost dimension as flex array if the whole
13652 multi-dimensional array is at struct end.
13653 Same for an array of aggregates with a trailing array
13655 else if (TREE_CODE (ref
) == ARRAY_REF
)
13657 else if (TREE_CODE (ref
) == ARRAY_RANGE_REF
)
13659 /* If we view an underlying object as sth else then what we
13660 gathered up to now is what we have to rely on. */
13661 else if (TREE_CODE (ref
) == VIEW_CONVERT_EXPR
)
13664 gcc_unreachable ();
13666 ref
= TREE_OPERAND (ref
, 0);
13669 /* The array now is at struct end. Treat flexible arrays as
13670 always subject to extend, even into just padding constrained by
13671 an underlying decl. */
13672 if (! TYPE_SIZE (atype
)
13673 || ! TYPE_DOMAIN (atype
)
13674 || ! TYPE_MAX_VALUE (TYPE_DOMAIN (atype
)))
13677 if (TREE_CODE (ref
) == MEM_REF
13678 && TREE_CODE (TREE_OPERAND (ref
, 0)) == ADDR_EXPR
)
13679 ref
= TREE_OPERAND (TREE_OPERAND (ref
, 0), 0);
13681 /* If the reference is based on a declared entity, the size of the array
13682 is constrained by its given domain. (Do not trust commons PR/69368). */
13684 && !(flag_unconstrained_commons
13685 && VAR_P (ref
) && DECL_COMMON (ref
))
13686 && DECL_SIZE_UNIT (ref
)
13687 && TREE_CODE (DECL_SIZE_UNIT (ref
)) == INTEGER_CST
)
13689 /* Check whether the array domain covers all of the available
13692 if (TREE_CODE (TYPE_SIZE_UNIT (TREE_TYPE (atype
))) != INTEGER_CST
13693 || TREE_CODE (TYPE_MAX_VALUE (TYPE_DOMAIN (atype
))) != INTEGER_CST
13694 || TREE_CODE (TYPE_MIN_VALUE (TYPE_DOMAIN (atype
))) != INTEGER_CST
)
13696 if (! get_addr_base_and_unit_offset (ref_to_array
, &offset
))
13699 /* If at least one extra element fits it is a flexarray. */
13700 if (known_le ((wi::to_offset (TYPE_MAX_VALUE (TYPE_DOMAIN (atype
)))
13701 - wi::to_offset (TYPE_MIN_VALUE (TYPE_DOMAIN (atype
)))
13703 * wi::to_offset (TYPE_SIZE_UNIT (TREE_TYPE (atype
))),
13704 wi::to_offset (DECL_SIZE_UNIT (ref
)) - offset
))
13713 /* Return a tree representing the offset, in bytes, of the field referenced
13714 by EXP. This does not include any offset in DECL_FIELD_BIT_OFFSET. */
13717 component_ref_field_offset (tree exp
)
13719 tree aligned_offset
= TREE_OPERAND (exp
, 2);
13720 tree field
= TREE_OPERAND (exp
, 1);
13721 location_t loc
= EXPR_LOCATION (exp
);
13723 /* If an offset was specified in the COMPONENT_REF, it's the offset measured
13724 in units of DECL_OFFSET_ALIGN / BITS_PER_UNIT. So multiply by that
13726 if (aligned_offset
)
13728 /* ??? tree_ssa_useless_type_conversion will eliminate casts to
13729 sizetype from another type of the same width and signedness. */
13730 if (TREE_TYPE (aligned_offset
) != sizetype
)
13731 aligned_offset
= fold_convert_loc (loc
, sizetype
, aligned_offset
);
13732 return size_binop_loc (loc
, MULT_EXPR
, aligned_offset
,
13733 size_int (DECL_OFFSET_ALIGN (field
)
13737 /* Otherwise, take the offset from that of the field. Substitute
13738 any PLACEHOLDER_EXPR that we have. */
13740 return SUBSTITUTE_PLACEHOLDER_IN_EXPR (DECL_FIELD_OFFSET (field
), exp
);
13743 /* Return the machine mode of T. For vectors, returns the mode of the
13744 inner type. The main use case is to feed the result to HONOR_NANS,
13745 avoiding the BLKmode that a direct TYPE_MODE (T) might return. */
13748 element_mode (const_tree t
)
13752 if (VECTOR_TYPE_P (t
) || TREE_CODE (t
) == COMPLEX_TYPE
)
13754 return TYPE_MODE (t
);
13757 /* Vector types need to re-check the target flags each time we report
13758 the machine mode. We need to do this because attribute target can
13759 change the result of vector_mode_supported_p and have_regs_of_mode
13760 on a per-function basis. Thus the TYPE_MODE of a VECTOR_TYPE can
13761 change on a per-function basis. */
13762 /* ??? Possibly a better solution is to run through all the types
13763 referenced by a function and re-compute the TYPE_MODE once, rather
13764 than make the TYPE_MODE macro call a function. */
13767 vector_type_mode (const_tree t
)
13771 gcc_assert (TREE_CODE (t
) == VECTOR_TYPE
);
13773 mode
= t
->type_common
.mode
;
13774 if (VECTOR_MODE_P (mode
)
13775 && (!targetm
.vector_mode_supported_p (mode
)
13776 || !have_regs_of_mode
[mode
]))
13778 scalar_int_mode innermode
;
13780 /* For integers, try mapping it to a same-sized scalar mode. */
13781 if (is_int_mode (TREE_TYPE (t
)->type_common
.mode
, &innermode
))
13783 poly_int64 size
= (TYPE_VECTOR_SUBPARTS (t
)
13784 * GET_MODE_BITSIZE (innermode
));
13785 scalar_int_mode mode
;
13786 if (int_mode_for_size (size
, 0).exists (&mode
)
13787 && have_regs_of_mode
[mode
])
13797 /* Verify that basic properties of T match TV and thus T can be a variant of
13798 TV. TV should be the more specified variant (i.e. the main variant). */
13801 verify_type_variant (const_tree t
, tree tv
)
13803 /* Type variant can differ by:
13805 - TYPE_QUALS: TYPE_READONLY, TYPE_VOLATILE, TYPE_ATOMIC, TYPE_RESTRICT,
13806 ENCODE_QUAL_ADDR_SPACE.
13807 - main variant may be TYPE_COMPLETE_P and variant types !TYPE_COMPLETE_P
13808 in this case some values may not be set in the variant types
13809 (see TYPE_COMPLETE_P checks).
13810 - it is possible to have TYPE_ARTIFICIAL variant of non-artifical type
13811 - by TYPE_NAME and attributes (i.e. when variant originate by typedef)
13812 - TYPE_CANONICAL (TYPE_ALIAS_SET is the same among variants)
13813 - by the alignment: TYPE_ALIGN and TYPE_USER_ALIGN
13814 - during LTO by TYPE_CONTEXT if type is TYPE_FILE_SCOPE_P
13815 this is necessary to make it possible to merge types form different TUs
13816 - arrays, pointers and references may have TREE_TYPE that is a variant
13817 of TREE_TYPE of their main variants.
13818 - aggregates may have new TYPE_FIELDS list that list variants of
13819 the main variant TYPE_FIELDS.
13820 - vector types may differ by TYPE_VECTOR_OPAQUE
13823 /* Convenience macro for matching individual fields. */
13824 #define verify_variant_match(flag) \
13826 if (flag (tv) != flag (t)) \
13828 error ("type variant differs by %s", #flag); \
13834 /* tree_base checks. */
13836 verify_variant_match (TREE_CODE
);
13837 /* FIXME: Ada builds non-artificial variants of artificial types. */
13838 if (TYPE_ARTIFICIAL (tv
) && 0)
13839 verify_variant_match (TYPE_ARTIFICIAL
);
13840 if (POINTER_TYPE_P (tv
))
13841 verify_variant_match (TYPE_REF_CAN_ALIAS_ALL
);
13842 /* FIXME: TYPE_SIZES_GIMPLIFIED may differs for Ada build. */
13843 verify_variant_match (TYPE_UNSIGNED
);
13844 verify_variant_match (TYPE_PACKED
);
13845 if (TREE_CODE (t
) == REFERENCE_TYPE
)
13846 verify_variant_match (TYPE_REF_IS_RVALUE
);
13847 if (AGGREGATE_TYPE_P (t
))
13848 verify_variant_match (TYPE_REVERSE_STORAGE_ORDER
);
13850 verify_variant_match (TYPE_SATURATING
);
13851 /* FIXME: This check trigger during libstdc++ build. */
13852 if (RECORD_OR_UNION_TYPE_P (t
) && COMPLETE_TYPE_P (t
) && 0)
13853 verify_variant_match (TYPE_FINAL_P
);
13855 /* tree_type_common checks. */
13857 if (COMPLETE_TYPE_P (t
))
13859 verify_variant_match (TYPE_MODE
);
13860 if (TREE_CODE (TYPE_SIZE (t
)) != PLACEHOLDER_EXPR
13861 && TREE_CODE (TYPE_SIZE (tv
)) != PLACEHOLDER_EXPR
)
13862 verify_variant_match (TYPE_SIZE
);
13863 if (TREE_CODE (TYPE_SIZE_UNIT (t
)) != PLACEHOLDER_EXPR
13864 && TREE_CODE (TYPE_SIZE_UNIT (tv
)) != PLACEHOLDER_EXPR
13865 && TYPE_SIZE_UNIT (t
) != TYPE_SIZE_UNIT (tv
))
13867 gcc_assert (!operand_equal_p (TYPE_SIZE_UNIT (t
),
13868 TYPE_SIZE_UNIT (tv
), 0));
13869 error ("type variant has different %<TYPE_SIZE_UNIT%>");
13871 error ("type variant%'s %<TYPE_SIZE_UNIT%>");
13872 debug_tree (TYPE_SIZE_UNIT (tv
));
13873 error ("type%'s %<TYPE_SIZE_UNIT%>");
13874 debug_tree (TYPE_SIZE_UNIT (t
));
13878 verify_variant_match (TYPE_PRECISION
);
13879 verify_variant_match (TYPE_NEEDS_CONSTRUCTING
);
13880 if (RECORD_OR_UNION_TYPE_P (t
))
13881 verify_variant_match (TYPE_TRANSPARENT_AGGR
);
13882 else if (TREE_CODE (t
) == ARRAY_TYPE
)
13883 verify_variant_match (TYPE_NONALIASED_COMPONENT
);
13884 /* During LTO we merge variant lists from diferent translation units
13885 that may differ BY TYPE_CONTEXT that in turn may point
13886 to TRANSLATION_UNIT_DECL.
13887 Ada also builds variants of types with different TYPE_CONTEXT. */
13888 if ((!in_lto_p
|| !TYPE_FILE_SCOPE_P (t
)) && 0)
13889 verify_variant_match (TYPE_CONTEXT
);
13890 if (TREE_CODE (t
) == ARRAY_TYPE
|| TREE_CODE (t
) == INTEGER_TYPE
)
13891 verify_variant_match (TYPE_STRING_FLAG
);
13892 if (TREE_CODE (t
) == RECORD_TYPE
|| TREE_CODE (t
) == UNION_TYPE
)
13893 verify_variant_match (TYPE_CXX_ODR_P
);
13894 if (TYPE_ALIAS_SET_KNOWN_P (t
))
13896 error ("type variant with %<TYPE_ALIAS_SET_KNOWN_P%>");
13901 /* tree_type_non_common checks. */
13903 /* FIXME: C FE uses TYPE_VFIELD to record C_TYPE_INCOMPLETE_VARS
13904 and dangle the pointer from time to time. */
13905 if (RECORD_OR_UNION_TYPE_P (t
) && TYPE_VFIELD (t
) != TYPE_VFIELD (tv
)
13906 && (in_lto_p
|| !TYPE_VFIELD (tv
)
13907 || TREE_CODE (TYPE_VFIELD (tv
)) != TREE_LIST
))
13909 error ("type variant has different %<TYPE_VFIELD%>");
13913 if ((TREE_CODE (t
) == ENUMERAL_TYPE
&& COMPLETE_TYPE_P (t
))
13914 || TREE_CODE (t
) == INTEGER_TYPE
13915 || TREE_CODE (t
) == BOOLEAN_TYPE
13916 || TREE_CODE (t
) == REAL_TYPE
13917 || TREE_CODE (t
) == FIXED_POINT_TYPE
)
13919 verify_variant_match (TYPE_MAX_VALUE
);
13920 verify_variant_match (TYPE_MIN_VALUE
);
13922 if (TREE_CODE (t
) == METHOD_TYPE
)
13923 verify_variant_match (TYPE_METHOD_BASETYPE
);
13924 if (TREE_CODE (t
) == OFFSET_TYPE
)
13925 verify_variant_match (TYPE_OFFSET_BASETYPE
);
13926 if (TREE_CODE (t
) == ARRAY_TYPE
)
13927 verify_variant_match (TYPE_ARRAY_MAX_SIZE
);
13928 /* FIXME: Be lax and allow TYPE_BINFO to be missing in variant types
13929 or even type's main variant. This is needed to make bootstrap pass
13930 and the bug seems new in GCC 5.
13931 C++ FE should be updated to make this consistent and we should check
13932 that TYPE_BINFO is always NULL for !COMPLETE_TYPE_P and otherwise there
13933 is a match with main variant.
13935 Also disable the check for Java for now because of parser hack that builds
13936 first an dummy BINFO and then sometimes replace it by real BINFO in some
13938 if (RECORD_OR_UNION_TYPE_P (t
) && TYPE_BINFO (t
) && TYPE_BINFO (tv
)
13939 && TYPE_BINFO (t
) != TYPE_BINFO (tv
)
13940 /* FIXME: Java sometimes keep dump TYPE_BINFOs on variant types.
13941 Since there is no cheap way to tell C++/Java type w/o LTO, do checking
13942 at LTO time only. */
13943 && (in_lto_p
&& odr_type_p (t
)))
13945 error ("type variant has different %<TYPE_BINFO%>");
13947 error ("type variant%'s %<TYPE_BINFO%>");
13948 debug_tree (TYPE_BINFO (tv
));
13949 error ("type%'s %<TYPE_BINFO%>");
13950 debug_tree (TYPE_BINFO (t
));
13954 /* Check various uses of TYPE_VALUES_RAW. */
13955 if (TREE_CODE (t
) == ENUMERAL_TYPE
13956 && TYPE_VALUES (t
))
13957 verify_variant_match (TYPE_VALUES
);
13958 else if (TREE_CODE (t
) == ARRAY_TYPE
)
13959 verify_variant_match (TYPE_DOMAIN
);
13960 /* Permit incomplete variants of complete type. While FEs may complete
13961 all variants, this does not happen for C++ templates in all cases. */
13962 else if (RECORD_OR_UNION_TYPE_P (t
)
13963 && COMPLETE_TYPE_P (t
)
13964 && TYPE_FIELDS (t
) != TYPE_FIELDS (tv
))
13968 /* Fortran builds qualified variants as new records with items of
13969 qualified type. Verify that they looks same. */
13970 for (f1
= TYPE_FIELDS (t
), f2
= TYPE_FIELDS (tv
);
13972 f1
= TREE_CHAIN (f1
), f2
= TREE_CHAIN (f2
))
13973 if (TREE_CODE (f1
) != FIELD_DECL
|| TREE_CODE (f2
) != FIELD_DECL
13974 || (TYPE_MAIN_VARIANT (TREE_TYPE (f1
))
13975 != TYPE_MAIN_VARIANT (TREE_TYPE (f2
))
13976 /* FIXME: gfc_nonrestricted_type builds all types as variants
13977 with exception of pointer types. It deeply copies the type
13978 which means that we may end up with a variant type
13979 referring non-variant pointer. We may change it to
13980 produce types as variants, too, like
13981 objc_get_protocol_qualified_type does. */
13982 && !POINTER_TYPE_P (TREE_TYPE (f1
)))
13983 || DECL_FIELD_OFFSET (f1
) != DECL_FIELD_OFFSET (f2
)
13984 || DECL_FIELD_BIT_OFFSET (f1
) != DECL_FIELD_BIT_OFFSET (f2
))
13988 error ("type variant has different %<TYPE_FIELDS%>");
13990 error ("first mismatch is field");
13992 error ("and field");
13997 else if ((TREE_CODE (t
) == FUNCTION_TYPE
|| TREE_CODE (t
) == METHOD_TYPE
))
13998 verify_variant_match (TYPE_ARG_TYPES
);
13999 /* For C++ the qualified variant of array type is really an array type
14000 of qualified TREE_TYPE.
14001 objc builds variants of pointer where pointer to type is a variant, too
14002 in objc_get_protocol_qualified_type. */
14003 if (TREE_TYPE (t
) != TREE_TYPE (tv
)
14004 && ((TREE_CODE (t
) != ARRAY_TYPE
14005 && !POINTER_TYPE_P (t
))
14006 || TYPE_MAIN_VARIANT (TREE_TYPE (t
))
14007 != TYPE_MAIN_VARIANT (TREE_TYPE (tv
))))
14009 error ("type variant has different %<TREE_TYPE%>");
14011 error ("type variant%'s %<TREE_TYPE%>");
14012 debug_tree (TREE_TYPE (tv
));
14013 error ("type%'s %<TREE_TYPE%>");
14014 debug_tree (TREE_TYPE (t
));
14017 if (type_with_alias_set_p (t
)
14018 && !gimple_canonical_types_compatible_p (t
, tv
, false))
14020 error ("type is not compatible with its variant");
14022 error ("type variant%'s %<TREE_TYPE%>");
14023 debug_tree (TREE_TYPE (tv
));
14024 error ("type%'s %<TREE_TYPE%>");
14025 debug_tree (TREE_TYPE (t
));
14029 #undef verify_variant_match
14033 /* The TYPE_CANONICAL merging machinery. It should closely resemble
14034 the middle-end types_compatible_p function. It needs to avoid
14035 claiming types are different for types that should be treated
14036 the same with respect to TBAA. Canonical types are also used
14037 for IL consistency checks via the useless_type_conversion_p
14038 predicate which does not handle all type kinds itself but falls
14039 back to pointer-comparison of TYPE_CANONICAL for aggregates
14042 /* Return true if TYPE_UNSIGNED of TYPE should be ignored for canonical
14043 type calculation because we need to allow inter-operability between signed
14044 and unsigned variants. */
14047 type_with_interoperable_signedness (const_tree type
)
14049 /* Fortran standard require C_SIGNED_CHAR to be interoperable with both
14050 signed char and unsigned char. Similarly fortran FE builds
14051 C_SIZE_T as signed type, while C defines it unsigned. */
14053 return tree_code_for_canonical_type_merging (TREE_CODE (type
))
14055 && (TYPE_PRECISION (type
) == TYPE_PRECISION (signed_char_type_node
)
14056 || TYPE_PRECISION (type
) == TYPE_PRECISION (size_type_node
));
14059 /* Return true iff T1 and T2 are structurally identical for what
14061 This function is used both by lto.c canonical type merging and by the
14062 verifier. If TRUST_TYPE_CANONICAL we do not look into structure of types
14063 that have TYPE_CANONICAL defined and assume them equivalent. This is useful
14064 only for LTO because only in these cases TYPE_CANONICAL equivalence
14065 correspond to one defined by gimple_canonical_types_compatible_p. */
14068 gimple_canonical_types_compatible_p (const_tree t1
, const_tree t2
,
14069 bool trust_type_canonical
)
14071 /* Type variants should be same as the main variant. When not doing sanity
14072 checking to verify this fact, go to main variants and save some work. */
14073 if (trust_type_canonical
)
14075 t1
= TYPE_MAIN_VARIANT (t1
);
14076 t2
= TYPE_MAIN_VARIANT (t2
);
14079 /* Check first for the obvious case of pointer identity. */
14083 /* Check that we have two types to compare. */
14084 if (t1
== NULL_TREE
|| t2
== NULL_TREE
)
14087 /* We consider complete types always compatible with incomplete type.
14088 This does not make sense for canonical type calculation and thus we
14089 need to ensure that we are never called on it.
14091 FIXME: For more correctness the function probably should have three modes
14092 1) mode assuming that types are complete mathcing their structure
14093 2) mode allowing incomplete types but producing equivalence classes
14094 and thus ignoring all info from complete types
14095 3) mode allowing incomplete types to match complete but checking
14096 compatibility between complete types.
14098 1 and 2 can be used for canonical type calculation. 3 is the real
14099 definition of type compatibility that can be used i.e. for warnings during
14100 declaration merging. */
14102 gcc_assert (!trust_type_canonical
14103 || (type_with_alias_set_p (t1
) && type_with_alias_set_p (t2
)));
14105 /* If the types have been previously registered and found equal
14108 if (TYPE_CANONICAL (t1
) && TYPE_CANONICAL (t2
)
14109 && trust_type_canonical
)
14111 /* Do not use TYPE_CANONICAL of pointer types. For LTO streamed types
14112 they are always NULL, but they are set to non-NULL for types
14113 constructed by build_pointer_type and variants. In this case the
14114 TYPE_CANONICAL is more fine grained than the equivalnce we test (where
14115 all pointers are considered equal. Be sure to not return false
14117 gcc_checking_assert (canonical_type_used_p (t1
)
14118 && canonical_type_used_p (t2
));
14119 return TYPE_CANONICAL (t1
) == TYPE_CANONICAL (t2
);
14122 /* For types where we do ODR based TBAA the canonical type is always
14123 set correctly, so we know that types are different if their
14124 canonical types does not match. */
14125 if (trust_type_canonical
14126 && (odr_type_p (t1
) && odr_based_tbaa_p (t1
))
14127 != (odr_type_p (t2
) && odr_based_tbaa_p (t2
)))
14130 /* Can't be the same type if the types don't have the same code. */
14131 enum tree_code code
= tree_code_for_canonical_type_merging (TREE_CODE (t1
));
14132 if (code
!= tree_code_for_canonical_type_merging (TREE_CODE (t2
)))
14135 /* Qualifiers do not matter for canonical type comparison purposes. */
14137 /* Void types and nullptr types are always the same. */
14138 if (TREE_CODE (t1
) == VOID_TYPE
14139 || TREE_CODE (t1
) == NULLPTR_TYPE
)
14142 /* Can't be the same type if they have different mode. */
14143 if (TYPE_MODE (t1
) != TYPE_MODE (t2
))
14146 /* Non-aggregate types can be handled cheaply. */
14147 if (INTEGRAL_TYPE_P (t1
)
14148 || SCALAR_FLOAT_TYPE_P (t1
)
14149 || FIXED_POINT_TYPE_P (t1
)
14150 || TREE_CODE (t1
) == VECTOR_TYPE
14151 || TREE_CODE (t1
) == COMPLEX_TYPE
14152 || TREE_CODE (t1
) == OFFSET_TYPE
14153 || POINTER_TYPE_P (t1
))
14155 /* Can't be the same type if they have different recision. */
14156 if (TYPE_PRECISION (t1
) != TYPE_PRECISION (t2
))
14159 /* In some cases the signed and unsigned types are required to be
14161 if (TYPE_UNSIGNED (t1
) != TYPE_UNSIGNED (t2
)
14162 && !type_with_interoperable_signedness (t1
))
14165 /* Fortran's C_SIGNED_CHAR is !TYPE_STRING_FLAG but needs to be
14166 interoperable with "signed char". Unless all frontends are revisited
14167 to agree on these types, we must ignore the flag completely. */
14169 /* Fortran standard define C_PTR type that is compatible with every
14170 C pointer. For this reason we need to glob all pointers into one.
14171 Still pointers in different address spaces are not compatible. */
14172 if (POINTER_TYPE_P (t1
))
14174 if (TYPE_ADDR_SPACE (TREE_TYPE (t1
))
14175 != TYPE_ADDR_SPACE (TREE_TYPE (t2
)))
14179 /* Tail-recurse to components. */
14180 if (TREE_CODE (t1
) == VECTOR_TYPE
14181 || TREE_CODE (t1
) == COMPLEX_TYPE
)
14182 return gimple_canonical_types_compatible_p (TREE_TYPE (t1
),
14184 trust_type_canonical
);
14189 /* Do type-specific comparisons. */
14190 switch (TREE_CODE (t1
))
14193 /* Array types are the same if the element types are the same and
14194 the number of elements are the same. */
14195 if (!gimple_canonical_types_compatible_p (TREE_TYPE (t1
), TREE_TYPE (t2
),
14196 trust_type_canonical
)
14197 || TYPE_STRING_FLAG (t1
) != TYPE_STRING_FLAG (t2
)
14198 || TYPE_REVERSE_STORAGE_ORDER (t1
) != TYPE_REVERSE_STORAGE_ORDER (t2
)
14199 || TYPE_NONALIASED_COMPONENT (t1
) != TYPE_NONALIASED_COMPONENT (t2
))
14203 tree i1
= TYPE_DOMAIN (t1
);
14204 tree i2
= TYPE_DOMAIN (t2
);
14206 /* For an incomplete external array, the type domain can be
14207 NULL_TREE. Check this condition also. */
14208 if (i1
== NULL_TREE
&& i2
== NULL_TREE
)
14210 else if (i1
== NULL_TREE
|| i2
== NULL_TREE
)
14214 tree min1
= TYPE_MIN_VALUE (i1
);
14215 tree min2
= TYPE_MIN_VALUE (i2
);
14216 tree max1
= TYPE_MAX_VALUE (i1
);
14217 tree max2
= TYPE_MAX_VALUE (i2
);
14219 /* The minimum/maximum values have to be the same. */
14222 && ((TREE_CODE (min1
) == PLACEHOLDER_EXPR
14223 && TREE_CODE (min2
) == PLACEHOLDER_EXPR
)
14224 || operand_equal_p (min1
, min2
, 0))))
14227 && ((TREE_CODE (max1
) == PLACEHOLDER_EXPR
14228 && TREE_CODE (max2
) == PLACEHOLDER_EXPR
)
14229 || operand_equal_p (max1
, max2
, 0)))))
14237 case FUNCTION_TYPE
:
14238 /* Function types are the same if the return type and arguments types
14240 if (!gimple_canonical_types_compatible_p (TREE_TYPE (t1
), TREE_TYPE (t2
),
14241 trust_type_canonical
))
14244 if (TYPE_ARG_TYPES (t1
) == TYPE_ARG_TYPES (t2
))
14248 tree parms1
, parms2
;
14250 for (parms1
= TYPE_ARG_TYPES (t1
), parms2
= TYPE_ARG_TYPES (t2
);
14252 parms1
= TREE_CHAIN (parms1
), parms2
= TREE_CHAIN (parms2
))
14254 if (!gimple_canonical_types_compatible_p
14255 (TREE_VALUE (parms1
), TREE_VALUE (parms2
),
14256 trust_type_canonical
))
14260 if (parms1
|| parms2
)
14268 case QUAL_UNION_TYPE
:
14272 /* Don't try to compare variants of an incomplete type, before
14273 TYPE_FIELDS has been copied around. */
14274 if (!COMPLETE_TYPE_P (t1
) && !COMPLETE_TYPE_P (t2
))
14278 if (TYPE_REVERSE_STORAGE_ORDER (t1
) != TYPE_REVERSE_STORAGE_ORDER (t2
))
14281 /* For aggregate types, all the fields must be the same. */
14282 for (f1
= TYPE_FIELDS (t1
), f2
= TYPE_FIELDS (t2
);
14284 f1
= TREE_CHAIN (f1
), f2
= TREE_CHAIN (f2
))
14286 /* Skip non-fields and zero-sized fields. */
14287 while (f1
&& (TREE_CODE (f1
) != FIELD_DECL
14289 && integer_zerop (DECL_SIZE (f1
)))))
14290 f1
= TREE_CHAIN (f1
);
14291 while (f2
&& (TREE_CODE (f2
) != FIELD_DECL
14293 && integer_zerop (DECL_SIZE (f2
)))))
14294 f2
= TREE_CHAIN (f2
);
14297 /* The fields must have the same name, offset and type. */
14298 if (DECL_NONADDRESSABLE_P (f1
) != DECL_NONADDRESSABLE_P (f2
)
14299 || !gimple_compare_field_offset (f1
, f2
)
14300 || !gimple_canonical_types_compatible_p
14301 (TREE_TYPE (f1
), TREE_TYPE (f2
),
14302 trust_type_canonical
))
14306 /* If one aggregate has more fields than the other, they
14307 are not the same. */
14315 /* Consider all types with language specific trees in them mutually
14316 compatible. This is executed only from verify_type and false
14317 positives can be tolerated. */
14318 gcc_assert (!in_lto_p
);
14323 /* Verify type T. */
14326 verify_type (const_tree t
)
14328 bool error_found
= false;
14329 tree mv
= TYPE_MAIN_VARIANT (t
);
14332 error ("main variant is not defined");
14333 error_found
= true;
14335 else if (mv
!= TYPE_MAIN_VARIANT (mv
))
14337 error ("%<TYPE_MAIN_VARIANT%> has different %<TYPE_MAIN_VARIANT%>");
14339 error_found
= true;
14341 else if (t
!= mv
&& !verify_type_variant (t
, mv
))
14342 error_found
= true;
14344 tree ct
= TYPE_CANONICAL (t
);
14347 else if (TYPE_CANONICAL (t
) != ct
)
14349 error ("%<TYPE_CANONICAL%> has different %<TYPE_CANONICAL%>");
14351 error_found
= true;
14353 /* Method and function types cannot be used to address memory and thus
14354 TYPE_CANONICAL really matters only for determining useless conversions.
14356 FIXME: C++ FE produce declarations of builtin functions that are not
14357 compatible with main variants. */
14358 else if (TREE_CODE (t
) == FUNCTION_TYPE
)
14361 /* FIXME: gimple_canonical_types_compatible_p cannot compare types
14362 with variably sized arrays because their sizes possibly
14363 gimplified to different variables. */
14364 && !variably_modified_type_p (ct
, NULL
)
14365 && !gimple_canonical_types_compatible_p (t
, ct
, false)
14366 && COMPLETE_TYPE_P (t
))
14368 error ("%<TYPE_CANONICAL%> is not compatible");
14370 error_found
= true;
14373 if (COMPLETE_TYPE_P (t
) && TYPE_CANONICAL (t
)
14374 && TYPE_MODE (t
) != TYPE_MODE (TYPE_CANONICAL (t
)))
14376 error ("%<TYPE_MODE%> of %<TYPE_CANONICAL%> is not compatible");
14378 error_found
= true;
14380 if (TYPE_MAIN_VARIANT (t
) == t
&& ct
&& TYPE_MAIN_VARIANT (ct
) != ct
)
14382 error ("%<TYPE_CANONICAL%> of main variant is not main variant");
14384 debug_tree (TYPE_MAIN_VARIANT (ct
));
14385 error_found
= true;
14389 /* Check various uses of TYPE_MIN_VALUE_RAW. */
14390 if (RECORD_OR_UNION_TYPE_P (t
))
14392 /* FIXME: C FE uses TYPE_VFIELD to record C_TYPE_INCOMPLETE_VARS
14393 and danagle the pointer from time to time. */
14394 if (TYPE_VFIELD (t
)
14395 && TREE_CODE (TYPE_VFIELD (t
)) != FIELD_DECL
14396 && TREE_CODE (TYPE_VFIELD (t
)) != TREE_LIST
)
14398 error ("%<TYPE_VFIELD%> is not %<FIELD_DECL%> nor %<TREE_LIST%>");
14399 debug_tree (TYPE_VFIELD (t
));
14400 error_found
= true;
14403 else if (TREE_CODE (t
) == POINTER_TYPE
)
14405 if (TYPE_NEXT_PTR_TO (t
)
14406 && TREE_CODE (TYPE_NEXT_PTR_TO (t
)) != POINTER_TYPE
)
14408 error ("%<TYPE_NEXT_PTR_TO%> is not %<POINTER_TYPE%>");
14409 debug_tree (TYPE_NEXT_PTR_TO (t
));
14410 error_found
= true;
14413 else if (TREE_CODE (t
) == REFERENCE_TYPE
)
14415 if (TYPE_NEXT_REF_TO (t
)
14416 && TREE_CODE (TYPE_NEXT_REF_TO (t
)) != REFERENCE_TYPE
)
14418 error ("%<TYPE_NEXT_REF_TO%> is not %<REFERENCE_TYPE%>");
14419 debug_tree (TYPE_NEXT_REF_TO (t
));
14420 error_found
= true;
14423 else if (INTEGRAL_TYPE_P (t
) || TREE_CODE (t
) == REAL_TYPE
14424 || TREE_CODE (t
) == FIXED_POINT_TYPE
)
14426 /* FIXME: The following check should pass:
14427 useless_type_conversion_p (const_cast <tree> (t),
14428 TREE_TYPE (TYPE_MIN_VALUE (t))
14429 but does not for C sizetypes in LTO. */
14432 /* Check various uses of TYPE_MAXVAL_RAW. */
14433 if (RECORD_OR_UNION_TYPE_P (t
))
14435 if (!TYPE_BINFO (t
))
14437 else if (TREE_CODE (TYPE_BINFO (t
)) != TREE_BINFO
)
14439 error ("%<TYPE_BINFO%> is not %<TREE_BINFO%>");
14440 debug_tree (TYPE_BINFO (t
));
14441 error_found
= true;
14443 else if (TREE_TYPE (TYPE_BINFO (t
)) != TYPE_MAIN_VARIANT (t
))
14445 error ("%<TYPE_BINFO%> type is not %<TYPE_MAIN_VARIANT%>");
14446 debug_tree (TREE_TYPE (TYPE_BINFO (t
)));
14447 error_found
= true;
14450 else if (TREE_CODE (t
) == FUNCTION_TYPE
|| TREE_CODE (t
) == METHOD_TYPE
)
14452 if (TYPE_METHOD_BASETYPE (t
)
14453 && TREE_CODE (TYPE_METHOD_BASETYPE (t
)) != RECORD_TYPE
14454 && TREE_CODE (TYPE_METHOD_BASETYPE (t
)) != UNION_TYPE
)
14456 error ("%<TYPE_METHOD_BASETYPE%> is not record nor union");
14457 debug_tree (TYPE_METHOD_BASETYPE (t
));
14458 error_found
= true;
14461 else if (TREE_CODE (t
) == OFFSET_TYPE
)
14463 if (TYPE_OFFSET_BASETYPE (t
)
14464 && TREE_CODE (TYPE_OFFSET_BASETYPE (t
)) != RECORD_TYPE
14465 && TREE_CODE (TYPE_OFFSET_BASETYPE (t
)) != UNION_TYPE
)
14467 error ("%<TYPE_OFFSET_BASETYPE%> is not record nor union");
14468 debug_tree (TYPE_OFFSET_BASETYPE (t
));
14469 error_found
= true;
14472 else if (INTEGRAL_TYPE_P (t
) || TREE_CODE (t
) == REAL_TYPE
14473 || TREE_CODE (t
) == FIXED_POINT_TYPE
)
14475 /* FIXME: The following check should pass:
14476 useless_type_conversion_p (const_cast <tree> (t),
14477 TREE_TYPE (TYPE_MAX_VALUE (t))
14478 but does not for C sizetypes in LTO. */
14480 else if (TREE_CODE (t
) == ARRAY_TYPE
)
14482 if (TYPE_ARRAY_MAX_SIZE (t
)
14483 && TREE_CODE (TYPE_ARRAY_MAX_SIZE (t
)) != INTEGER_CST
)
14485 error ("%<TYPE_ARRAY_MAX_SIZE%> not %<INTEGER_CST%>");
14486 debug_tree (TYPE_ARRAY_MAX_SIZE (t
));
14487 error_found
= true;
14490 else if (TYPE_MAX_VALUE_RAW (t
))
14492 error ("%<TYPE_MAX_VALUE_RAW%> non-NULL");
14493 debug_tree (TYPE_MAX_VALUE_RAW (t
));
14494 error_found
= true;
14497 if (TYPE_LANG_SLOT_1 (t
) && in_lto_p
)
14499 error ("%<TYPE_LANG_SLOT_1 (binfo)%> field is non-NULL");
14500 debug_tree (TYPE_LANG_SLOT_1 (t
));
14501 error_found
= true;
14504 /* Check various uses of TYPE_VALUES_RAW. */
14505 if (TREE_CODE (t
) == ENUMERAL_TYPE
)
14506 for (tree l
= TYPE_VALUES (t
); l
; l
= TREE_CHAIN (l
))
14508 tree value
= TREE_VALUE (l
);
14509 tree name
= TREE_PURPOSE (l
);
14511 /* C FE porduce INTEGER_CST of INTEGER_TYPE, while C++ FE uses
14512 CONST_DECL of ENUMERAL TYPE. */
14513 if (TREE_CODE (value
) != INTEGER_CST
&& TREE_CODE (value
) != CONST_DECL
)
14515 error ("enum value is not %<CONST_DECL%> or %<INTEGER_CST%>");
14516 debug_tree (value
);
14518 error_found
= true;
14520 if (TREE_CODE (TREE_TYPE (value
)) != INTEGER_TYPE
14521 && !useless_type_conversion_p (const_cast <tree
> (t
), TREE_TYPE (value
)))
14523 error ("enum value type is not %<INTEGER_TYPE%> nor convertible "
14525 debug_tree (value
);
14527 error_found
= true;
14529 if (TREE_CODE (name
) != IDENTIFIER_NODE
)
14531 error ("enum value name is not %<IDENTIFIER_NODE%>");
14532 debug_tree (value
);
14534 error_found
= true;
14537 else if (TREE_CODE (t
) == ARRAY_TYPE
)
14539 if (TYPE_DOMAIN (t
) && TREE_CODE (TYPE_DOMAIN (t
)) != INTEGER_TYPE
)
14541 error ("array %<TYPE_DOMAIN%> is not integer type");
14542 debug_tree (TYPE_DOMAIN (t
));
14543 error_found
= true;
14546 else if (RECORD_OR_UNION_TYPE_P (t
))
14548 if (TYPE_FIELDS (t
) && !COMPLETE_TYPE_P (t
) && in_lto_p
)
14550 error ("%<TYPE_FIELDS%> defined in incomplete type");
14551 error_found
= true;
14553 for (tree fld
= TYPE_FIELDS (t
); fld
; fld
= TREE_CHAIN (fld
))
14555 /* TODO: verify properties of decls. */
14556 if (TREE_CODE (fld
) == FIELD_DECL
)
14558 else if (TREE_CODE (fld
) == TYPE_DECL
)
14560 else if (TREE_CODE (fld
) == CONST_DECL
)
14562 else if (VAR_P (fld
))
14564 else if (TREE_CODE (fld
) == TEMPLATE_DECL
)
14566 else if (TREE_CODE (fld
) == USING_DECL
)
14568 else if (TREE_CODE (fld
) == FUNCTION_DECL
)
14572 error ("wrong tree in %<TYPE_FIELDS%> list");
14574 error_found
= true;
14578 else if (TREE_CODE (t
) == INTEGER_TYPE
14579 || TREE_CODE (t
) == BOOLEAN_TYPE
14580 || TREE_CODE (t
) == OFFSET_TYPE
14581 || TREE_CODE (t
) == REFERENCE_TYPE
14582 || TREE_CODE (t
) == NULLPTR_TYPE
14583 || TREE_CODE (t
) == POINTER_TYPE
)
14585 if (TYPE_CACHED_VALUES_P (t
) != (TYPE_CACHED_VALUES (t
) != NULL
))
14587 error ("%<TYPE_CACHED_VALUES_P%> is %i while %<TYPE_CACHED_VALUES%> "
14589 TYPE_CACHED_VALUES_P (t
), (void *)TYPE_CACHED_VALUES (t
));
14590 error_found
= true;
14592 else if (TYPE_CACHED_VALUES_P (t
) && TREE_CODE (TYPE_CACHED_VALUES (t
)) != TREE_VEC
)
14594 error ("%<TYPE_CACHED_VALUES%> is not %<TREE_VEC%>");
14595 debug_tree (TYPE_CACHED_VALUES (t
));
14596 error_found
= true;
14598 /* Verify just enough of cache to ensure that no one copied it to new type.
14599 All copying should go by copy_node that should clear it. */
14600 else if (TYPE_CACHED_VALUES_P (t
))
14603 for (i
= 0; i
< TREE_VEC_LENGTH (TYPE_CACHED_VALUES (t
)); i
++)
14604 if (TREE_VEC_ELT (TYPE_CACHED_VALUES (t
), i
)
14605 && TREE_TYPE (TREE_VEC_ELT (TYPE_CACHED_VALUES (t
), i
)) != t
)
14607 error ("wrong %<TYPE_CACHED_VALUES%> entry");
14608 debug_tree (TREE_VEC_ELT (TYPE_CACHED_VALUES (t
), i
));
14609 error_found
= true;
14614 else if (TREE_CODE (t
) == FUNCTION_TYPE
|| TREE_CODE (t
) == METHOD_TYPE
)
14615 for (tree l
= TYPE_ARG_TYPES (t
); l
; l
= TREE_CHAIN (l
))
14617 /* C++ FE uses TREE_PURPOSE to store initial values. */
14618 if (TREE_PURPOSE (l
) && in_lto_p
)
14620 error ("%<TREE_PURPOSE%> is non-NULL in %<TYPE_ARG_TYPES%> list");
14622 error_found
= true;
14624 if (!TYPE_P (TREE_VALUE (l
)))
14626 error ("wrong entry in %<TYPE_ARG_TYPES%> list");
14628 error_found
= true;
14631 else if (!is_lang_specific (t
) && TYPE_VALUES_RAW (t
))
14633 error ("%<TYPE_VALUES_RAW%> field is non-NULL");
14634 debug_tree (TYPE_VALUES_RAW (t
));
14635 error_found
= true;
14637 if (TREE_CODE (t
) != INTEGER_TYPE
14638 && TREE_CODE (t
) != BOOLEAN_TYPE
14639 && TREE_CODE (t
) != OFFSET_TYPE
14640 && TREE_CODE (t
) != REFERENCE_TYPE
14641 && TREE_CODE (t
) != NULLPTR_TYPE
14642 && TREE_CODE (t
) != POINTER_TYPE
14643 && TYPE_CACHED_VALUES_P (t
))
14645 error ("%<TYPE_CACHED_VALUES_P%> is set while it should not be");
14646 error_found
= true;
14649 /* ipa-devirt makes an assumption that TYPE_METHOD_BASETYPE is always
14650 TYPE_MAIN_VARIANT and it would be odd to add methods only to variatns
14652 if (TREE_CODE (t
) == METHOD_TYPE
14653 && TYPE_MAIN_VARIANT (TYPE_METHOD_BASETYPE (t
)) != TYPE_METHOD_BASETYPE (t
))
14655 error ("%<TYPE_METHOD_BASETYPE%> is not main variant");
14656 error_found
= true;
14661 debug_tree (const_cast <tree
> (t
));
14662 internal_error ("%qs failed", __func__
);
14667 /* Return 1 if ARG interpreted as signed in its precision is known to be
14668 always positive or 2 if ARG is known to be always negative, or 3 if
14669 ARG may be positive or negative. */
14672 get_range_pos_neg (tree arg
)
14674 if (arg
== error_mark_node
)
14677 int prec
= TYPE_PRECISION (TREE_TYPE (arg
));
14679 if (TREE_CODE (arg
) == INTEGER_CST
)
14681 wide_int w
= wi::sext (wi::to_wide (arg
), prec
);
14687 while (CONVERT_EXPR_P (arg
)
14688 && INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (arg
, 0)))
14689 && TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (arg
, 0))) <= prec
)
14691 arg
= TREE_OPERAND (arg
, 0);
14692 /* Narrower value zero extended into wider type
14693 will always result in positive values. */
14694 if (TYPE_UNSIGNED (TREE_TYPE (arg
))
14695 && TYPE_PRECISION (TREE_TYPE (arg
)) < prec
)
14697 prec
= TYPE_PRECISION (TREE_TYPE (arg
));
14702 if (TREE_CODE (arg
) != SSA_NAME
)
14704 wide_int arg_min
, arg_max
;
14705 while (get_range_info (arg
, &arg_min
, &arg_max
) != VR_RANGE
)
14707 gimple
*g
= SSA_NAME_DEF_STMT (arg
);
14708 if (is_gimple_assign (g
)
14709 && CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (g
)))
14711 tree t
= gimple_assign_rhs1 (g
);
14712 if (INTEGRAL_TYPE_P (TREE_TYPE (t
))
14713 && TYPE_PRECISION (TREE_TYPE (t
)) <= prec
)
14715 if (TYPE_UNSIGNED (TREE_TYPE (t
))
14716 && TYPE_PRECISION (TREE_TYPE (t
)) < prec
)
14718 prec
= TYPE_PRECISION (TREE_TYPE (t
));
14727 if (TYPE_UNSIGNED (TREE_TYPE (arg
)))
14729 /* For unsigned values, the "positive" range comes
14730 below the "negative" range. */
14731 if (!wi::neg_p (wi::sext (arg_max
, prec
), SIGNED
))
14733 if (wi::neg_p (wi::sext (arg_min
, prec
), SIGNED
))
14738 if (!wi::neg_p (wi::sext (arg_min
, prec
), SIGNED
))
14740 if (wi::neg_p (wi::sext (arg_max
, prec
), SIGNED
))
14749 /* Return true if ARG is marked with the nonnull attribute in the
14750 current function signature. */
14753 nonnull_arg_p (const_tree arg
)
14755 tree t
, attrs
, fntype
;
14756 unsigned HOST_WIDE_INT arg_num
;
14758 gcc_assert (TREE_CODE (arg
) == PARM_DECL
14759 && (POINTER_TYPE_P (TREE_TYPE (arg
))
14760 || TREE_CODE (TREE_TYPE (arg
)) == OFFSET_TYPE
));
14762 /* The static chain decl is always non null. */
14763 if (arg
== cfun
->static_chain_decl
)
14766 /* THIS argument of method is always non-NULL. */
14767 if (TREE_CODE (TREE_TYPE (cfun
->decl
)) == METHOD_TYPE
14768 && arg
== DECL_ARGUMENTS (cfun
->decl
)
14769 && flag_delete_null_pointer_checks
)
14772 /* Values passed by reference are always non-NULL. */
14773 if (TREE_CODE (TREE_TYPE (arg
)) == REFERENCE_TYPE
14774 && flag_delete_null_pointer_checks
)
14777 fntype
= TREE_TYPE (cfun
->decl
);
14778 for (attrs
= TYPE_ATTRIBUTES (fntype
); attrs
; attrs
= TREE_CHAIN (attrs
))
14780 attrs
= lookup_attribute ("nonnull", attrs
);
14782 /* If "nonnull" wasn't specified, we know nothing about the argument. */
14783 if (attrs
== NULL_TREE
)
14786 /* If "nonnull" applies to all the arguments, then ARG is non-null. */
14787 if (TREE_VALUE (attrs
) == NULL_TREE
)
14790 /* Get the position number for ARG in the function signature. */
14791 for (arg_num
= 1, t
= DECL_ARGUMENTS (cfun
->decl
);
14793 t
= DECL_CHAIN (t
), arg_num
++)
14799 gcc_assert (t
== arg
);
14801 /* Now see if ARG_NUM is mentioned in the nonnull list. */
14802 for (t
= TREE_VALUE (attrs
); t
; t
= TREE_CHAIN (t
))
14804 if (compare_tree_int (TREE_VALUE (t
), arg_num
) == 0)
14812 /* Combine LOC and BLOCK to a combined adhoc loc, retaining any range
14816 set_block (location_t loc
, tree block
)
14818 location_t pure_loc
= get_pure_location (loc
);
14819 source_range src_range
= get_range_from_loc (line_table
, loc
);
14820 return COMBINE_LOCATION_DATA (line_table
, pure_loc
, src_range
, block
);
14824 set_source_range (tree expr
, location_t start
, location_t finish
)
14826 source_range src_range
;
14827 src_range
.m_start
= start
;
14828 src_range
.m_finish
= finish
;
14829 return set_source_range (expr
, src_range
);
14833 set_source_range (tree expr
, source_range src_range
)
14835 if (!EXPR_P (expr
))
14836 return UNKNOWN_LOCATION
;
14838 location_t pure_loc
= get_pure_location (EXPR_LOCATION (expr
));
14839 location_t adhoc
= COMBINE_LOCATION_DATA (line_table
,
14843 SET_EXPR_LOCATION (expr
, adhoc
);
14847 /* Return EXPR, potentially wrapped with a node expression LOC,
14848 if !CAN_HAVE_LOCATION_P (expr).
14850 NON_LVALUE_EXPR is used for wrapping constants, apart from STRING_CST.
14851 VIEW_CONVERT_EXPR is used for wrapping non-constants and STRING_CST.
14853 Wrapper nodes can be identified using location_wrapper_p. */
14856 maybe_wrap_with_location (tree expr
, location_t loc
)
14860 if (loc
== UNKNOWN_LOCATION
)
14862 if (CAN_HAVE_LOCATION_P (expr
))
14864 /* We should only be adding wrappers for constants and for decls,
14865 or for some exceptional tree nodes (e.g. BASELINK in the C++ FE). */
14866 gcc_assert (CONSTANT_CLASS_P (expr
)
14868 || EXCEPTIONAL_CLASS_P (expr
));
14870 /* For now, don't add wrappers to exceptional tree nodes, to minimize
14871 any impact of the wrapper nodes. */
14872 if (EXCEPTIONAL_CLASS_P (expr
))
14875 /* If any auto_suppress_location_wrappers are active, don't create
14877 if (suppress_location_wrappers
> 0)
14881 = (((CONSTANT_CLASS_P (expr
) && TREE_CODE (expr
) != STRING_CST
)
14882 || (TREE_CODE (expr
) == CONST_DECL
&& !TREE_STATIC (expr
)))
14883 ? NON_LVALUE_EXPR
: VIEW_CONVERT_EXPR
);
14884 tree wrapper
= build1_loc (loc
, code
, TREE_TYPE (expr
), expr
);
14885 /* Mark this node as being a wrapper. */
14886 EXPR_LOCATION_WRAPPER_P (wrapper
) = 1;
14890 int suppress_location_wrappers
;
14892 /* Return the name of combined function FN, for debugging purposes. */
14895 combined_fn_name (combined_fn fn
)
14897 if (builtin_fn_p (fn
))
14899 tree fndecl
= builtin_decl_explicit (as_builtin_fn (fn
));
14900 return IDENTIFIER_POINTER (DECL_NAME (fndecl
));
14903 return internal_fn_name (as_internal_fn (fn
));
14906 /* Return a bitmap with a bit set corresponding to each argument in
14907 a function call type FNTYPE declared with attribute nonnull,
14908 or null if none of the function's argument are nonnull. The caller
14909 must free the bitmap. */
14912 get_nonnull_args (const_tree fntype
)
14914 if (fntype
== NULL_TREE
)
14917 tree attrs
= TYPE_ATTRIBUTES (fntype
);
14921 bitmap argmap
= NULL
;
14923 /* A function declaration can specify multiple attribute nonnull,
14924 each with zero or more arguments. The loop below creates a bitmap
14925 representing a union of all the arguments. An empty (but non-null)
14926 bitmap means that all arguments have been declaraed nonnull. */
14927 for ( ; attrs
; attrs
= TREE_CHAIN (attrs
))
14929 attrs
= lookup_attribute ("nonnull", attrs
);
14934 argmap
= BITMAP_ALLOC (NULL
);
14936 if (!TREE_VALUE (attrs
))
14938 /* Clear the bitmap in case a previous attribute nonnull
14939 set it and this one overrides it for all arguments. */
14940 bitmap_clear (argmap
);
14944 /* Iterate over the indices of the format arguments declared nonnull
14945 and set a bit for each. */
14946 for (tree idx
= TREE_VALUE (attrs
); idx
; idx
= TREE_CHAIN (idx
))
14948 unsigned int val
= TREE_INT_CST_LOW (TREE_VALUE (idx
)) - 1;
14949 bitmap_set_bit (argmap
, val
);
14956 /* Returns true if TYPE is a type where it and all of its subobjects
14957 (recursively) are of structure, union, or array type. */
14960 default_is_empty_type (tree type
)
14962 if (RECORD_OR_UNION_TYPE_P (type
))
14964 for (tree field
= TYPE_FIELDS (type
); field
; field
= DECL_CHAIN (field
))
14965 if (TREE_CODE (field
) == FIELD_DECL
14966 && !DECL_PADDING_P (field
)
14967 && !default_is_empty_type (TREE_TYPE (field
)))
14971 else if (TREE_CODE (type
) == ARRAY_TYPE
)
14972 return (integer_minus_onep (array_type_nelts (type
))
14973 || TYPE_DOMAIN (type
) == NULL_TREE
14974 || default_is_empty_type (TREE_TYPE (type
)));
14978 /* Implement TARGET_EMPTY_RECORD_P. Return true if TYPE is an empty type
14979 that shouldn't be passed via stack. */
14982 default_is_empty_record (const_tree type
)
14984 if (!abi_version_at_least (12))
14987 if (type
== error_mark_node
)
14990 if (TREE_ADDRESSABLE (type
))
14993 return default_is_empty_type (TYPE_MAIN_VARIANT (type
));
14996 /* Like int_size_in_bytes, but handle empty records specially. */
14999 arg_int_size_in_bytes (const_tree type
)
15001 return TYPE_EMPTY_P (type
) ? 0 : int_size_in_bytes (type
);
15004 /* Like size_in_bytes, but handle empty records specially. */
15007 arg_size_in_bytes (const_tree type
)
15009 return TYPE_EMPTY_P (type
) ? size_zero_node
: size_in_bytes (type
);
15012 /* Return true if an expression with CODE has to have the same result type as
15013 its first operand. */
15016 expr_type_first_operand_type_p (tree_code code
)
15029 case TRUNC_DIV_EXPR
:
15030 case CEIL_DIV_EXPR
:
15031 case FLOOR_DIV_EXPR
:
15032 case ROUND_DIV_EXPR
:
15033 case TRUNC_MOD_EXPR
:
15034 case CEIL_MOD_EXPR
:
15035 case FLOOR_MOD_EXPR
:
15036 case ROUND_MOD_EXPR
:
15038 case EXACT_DIV_EXPR
:
15056 /* Return a typenode for the "standard" C type with a given name. */
15058 get_typenode_from_name (const char *name
)
15060 if (name
== NULL
|| *name
== '\0')
15063 if (strcmp (name
, "char") == 0)
15064 return char_type_node
;
15065 if (strcmp (name
, "unsigned char") == 0)
15066 return unsigned_char_type_node
;
15067 if (strcmp (name
, "signed char") == 0)
15068 return signed_char_type_node
;
15070 if (strcmp (name
, "short int") == 0)
15071 return short_integer_type_node
;
15072 if (strcmp (name
, "short unsigned int") == 0)
15073 return short_unsigned_type_node
;
15075 if (strcmp (name
, "int") == 0)
15076 return integer_type_node
;
15077 if (strcmp (name
, "unsigned int") == 0)
15078 return unsigned_type_node
;
15080 if (strcmp (name
, "long int") == 0)
15081 return long_integer_type_node
;
15082 if (strcmp (name
, "long unsigned int") == 0)
15083 return long_unsigned_type_node
;
15085 if (strcmp (name
, "long long int") == 0)
15086 return long_long_integer_type_node
;
15087 if (strcmp (name
, "long long unsigned int") == 0)
15088 return long_long_unsigned_type_node
;
15090 gcc_unreachable ();
15093 /* List of pointer types used to declare builtins before we have seen their
15096 Keep the size up to date in tree.h ! */
15097 const builtin_structptr_type builtin_structptr_types
[6] =
15099 { fileptr_type_node
, ptr_type_node
, "FILE" },
15100 { const_tm_ptr_type_node
, const_ptr_type_node
, "tm" },
15101 { fenv_t_ptr_type_node
, ptr_type_node
, "fenv_t" },
15102 { const_fenv_t_ptr_type_node
, const_ptr_type_node
, "fenv_t" },
15103 { fexcept_t_ptr_type_node
, ptr_type_node
, "fexcept_t" },
15104 { const_fexcept_t_ptr_type_node
, const_ptr_type_node
, "fexcept_t" }
15107 /* Return the maximum object size. */
15110 max_object_size (void)
15112 /* To do: Make this a configurable parameter. */
15113 return TYPE_MAX_VALUE (ptrdiff_type_node
);
15118 namespace selftest
{
15120 /* Selftests for tree. */
15122 /* Verify that integer constants are sane. */
15125 test_integer_constants ()
15127 ASSERT_TRUE (integer_type_node
!= NULL
);
15128 ASSERT_TRUE (build_int_cst (integer_type_node
, 0) != NULL
);
15130 tree type
= integer_type_node
;
15132 tree zero
= build_zero_cst (type
);
15133 ASSERT_EQ (INTEGER_CST
, TREE_CODE (zero
));
15134 ASSERT_EQ (type
, TREE_TYPE (zero
));
15136 tree one
= build_int_cst (type
, 1);
15137 ASSERT_EQ (INTEGER_CST
, TREE_CODE (one
));
15138 ASSERT_EQ (type
, TREE_TYPE (zero
));
15141 /* Verify identifiers. */
15144 test_identifiers ()
15146 tree identifier
= get_identifier ("foo");
15147 ASSERT_EQ (3, IDENTIFIER_LENGTH (identifier
));
15148 ASSERT_STREQ ("foo", IDENTIFIER_POINTER (identifier
));
15151 /* Verify LABEL_DECL. */
15156 tree identifier
= get_identifier ("err");
15157 tree label_decl
= build_decl (UNKNOWN_LOCATION
, LABEL_DECL
,
15158 identifier
, void_type_node
);
15159 ASSERT_EQ (-1, LABEL_DECL_UID (label_decl
));
15160 ASSERT_FALSE (FORCED_LABEL (label_decl
));
15163 /* Return a new VECTOR_CST node whose type is TYPE and whose values
15164 are given by VALS. */
15167 build_vector (tree type
, vec
<tree
> vals MEM_STAT_DECL
)
15169 gcc_assert (known_eq (vals
.length (), TYPE_VECTOR_SUBPARTS (type
)));
15170 tree_vector_builder
builder (type
, vals
.length (), 1);
15171 builder
.splice (vals
);
15172 return builder
.build ();
15175 /* Check that VECTOR_CST ACTUAL contains the elements in EXPECTED. */
15178 check_vector_cst (vec
<tree
> expected
, tree actual
)
15180 ASSERT_KNOWN_EQ (expected
.length (),
15181 TYPE_VECTOR_SUBPARTS (TREE_TYPE (actual
)));
15182 for (unsigned int i
= 0; i
< expected
.length (); ++i
)
15183 ASSERT_EQ (wi::to_wide (expected
[i
]),
15184 wi::to_wide (vector_cst_elt (actual
, i
)));
15187 /* Check that VECTOR_CST ACTUAL contains NPATTERNS duplicated elements,
15188 and that its elements match EXPECTED. */
15191 check_vector_cst_duplicate (vec
<tree
> expected
, tree actual
,
15192 unsigned int npatterns
)
15194 ASSERT_EQ (npatterns
, VECTOR_CST_NPATTERNS (actual
));
15195 ASSERT_EQ (1, VECTOR_CST_NELTS_PER_PATTERN (actual
));
15196 ASSERT_EQ (npatterns
, vector_cst_encoded_nelts (actual
));
15197 ASSERT_TRUE (VECTOR_CST_DUPLICATE_P (actual
));
15198 ASSERT_FALSE (VECTOR_CST_STEPPED_P (actual
));
15199 check_vector_cst (expected
, actual
);
15202 /* Check that VECTOR_CST ACTUAL contains NPATTERNS foreground elements
15203 and NPATTERNS background elements, and that its elements match
15207 check_vector_cst_fill (vec
<tree
> expected
, tree actual
,
15208 unsigned int npatterns
)
15210 ASSERT_EQ (npatterns
, VECTOR_CST_NPATTERNS (actual
));
15211 ASSERT_EQ (2, VECTOR_CST_NELTS_PER_PATTERN (actual
));
15212 ASSERT_EQ (2 * npatterns
, vector_cst_encoded_nelts (actual
));
15213 ASSERT_FALSE (VECTOR_CST_DUPLICATE_P (actual
));
15214 ASSERT_FALSE (VECTOR_CST_STEPPED_P (actual
));
15215 check_vector_cst (expected
, actual
);
15218 /* Check that VECTOR_CST ACTUAL contains NPATTERNS stepped patterns,
15219 and that its elements match EXPECTED. */
15222 check_vector_cst_stepped (vec
<tree
> expected
, tree actual
,
15223 unsigned int npatterns
)
15225 ASSERT_EQ (npatterns
, VECTOR_CST_NPATTERNS (actual
));
15226 ASSERT_EQ (3, VECTOR_CST_NELTS_PER_PATTERN (actual
));
15227 ASSERT_EQ (3 * npatterns
, vector_cst_encoded_nelts (actual
));
15228 ASSERT_FALSE (VECTOR_CST_DUPLICATE_P (actual
));
15229 ASSERT_TRUE (VECTOR_CST_STEPPED_P (actual
));
15230 check_vector_cst (expected
, actual
);
15233 /* Test the creation of VECTOR_CSTs. */
15236 test_vector_cst_patterns (ALONE_CXX_MEM_STAT_INFO
)
15238 auto_vec
<tree
, 8> elements (8);
15239 elements
.quick_grow (8);
15240 tree element_type
= build_nonstandard_integer_type (16, true);
15241 tree vector_type
= build_vector_type (element_type
, 8);
15243 /* Test a simple linear series with a base of 0 and a step of 1:
15244 { 0, 1, 2, 3, 4, 5, 6, 7 }. */
15245 for (unsigned int i
= 0; i
< 8; ++i
)
15246 elements
[i
] = build_int_cst (element_type
, i
);
15247 tree vector
= build_vector (vector_type
, elements PASS_MEM_STAT
);
15248 check_vector_cst_stepped (elements
, vector
, 1);
15250 /* Try the same with the first element replaced by 100:
15251 { 100, 1, 2, 3, 4, 5, 6, 7 }. */
15252 elements
[0] = build_int_cst (element_type
, 100);
15253 vector
= build_vector (vector_type
, elements PASS_MEM_STAT
);
15254 check_vector_cst_stepped (elements
, vector
, 1);
15256 /* Try a series that wraps around.
15257 { 100, 65531, 65532, 65533, 65534, 65535, 0, 1 }. */
15258 for (unsigned int i
= 1; i
< 8; ++i
)
15259 elements
[i
] = build_int_cst (element_type
, (65530 + i
) & 0xffff);
15260 vector
= build_vector (vector_type
, elements PASS_MEM_STAT
);
15261 check_vector_cst_stepped (elements
, vector
, 1);
15263 /* Try a downward series:
15264 { 100, 79, 78, 77, 76, 75, 75, 73 }. */
15265 for (unsigned int i
= 1; i
< 8; ++i
)
15266 elements
[i
] = build_int_cst (element_type
, 80 - i
);
15267 vector
= build_vector (vector_type
, elements PASS_MEM_STAT
);
15268 check_vector_cst_stepped (elements
, vector
, 1);
15270 /* Try two interleaved series with different bases and steps:
15271 { 100, 53, 66, 206, 62, 212, 58, 218 }. */
15272 elements
[1] = build_int_cst (element_type
, 53);
15273 for (unsigned int i
= 2; i
< 8; i
+= 2)
15275 elements
[i
] = build_int_cst (element_type
, 70 - i
* 2);
15276 elements
[i
+ 1] = build_int_cst (element_type
, 200 + i
* 3);
15278 vector
= build_vector (vector_type
, elements PASS_MEM_STAT
);
15279 check_vector_cst_stepped (elements
, vector
, 2);
15281 /* Try a duplicated value:
15282 { 100, 100, 100, 100, 100, 100, 100, 100 }. */
15283 for (unsigned int i
= 1; i
< 8; ++i
)
15284 elements
[i
] = elements
[0];
15285 vector
= build_vector (vector_type
, elements PASS_MEM_STAT
);
15286 check_vector_cst_duplicate (elements
, vector
, 1);
15288 /* Try an interleaved duplicated value:
15289 { 100, 55, 100, 55, 100, 55, 100, 55 }. */
15290 elements
[1] = build_int_cst (element_type
, 55);
15291 for (unsigned int i
= 2; i
< 8; ++i
)
15292 elements
[i
] = elements
[i
- 2];
15293 vector
= build_vector (vector_type
, elements PASS_MEM_STAT
);
15294 check_vector_cst_duplicate (elements
, vector
, 2);
15296 /* Try a duplicated value with 2 exceptions
15297 { 41, 97, 100, 55, 100, 55, 100, 55 }. */
15298 elements
[0] = build_int_cst (element_type
, 41);
15299 elements
[1] = build_int_cst (element_type
, 97);
15300 vector
= build_vector (vector_type
, elements PASS_MEM_STAT
);
15301 check_vector_cst_fill (elements
, vector
, 2);
15303 /* Try with and without a step
15304 { 41, 97, 100, 21, 100, 35, 100, 49 }. */
15305 for (unsigned int i
= 3; i
< 8; i
+= 2)
15306 elements
[i
] = build_int_cst (element_type
, i
* 7);
15307 vector
= build_vector (vector_type
, elements PASS_MEM_STAT
);
15308 check_vector_cst_stepped (elements
, vector
, 2);
15310 /* Try a fully-general constant:
15311 { 41, 97, 100, 21, 100, 9990, 100, 49 }. */
15312 elements
[5] = build_int_cst (element_type
, 9990);
15313 vector
= build_vector (vector_type
, elements PASS_MEM_STAT
);
15314 check_vector_cst_fill (elements
, vector
, 4);
15317 /* Verify that STRIP_NOPS (NODE) is EXPECTED.
15318 Helper function for test_location_wrappers, to deal with STRIP_NOPS
15319 modifying its argument in-place. */
15322 check_strip_nops (tree node
, tree expected
)
15325 ASSERT_EQ (expected
, node
);
15328 /* Verify location wrappers. */
15331 test_location_wrappers ()
15333 location_t loc
= BUILTINS_LOCATION
;
15335 ASSERT_EQ (NULL_TREE
, maybe_wrap_with_location (NULL_TREE
, loc
));
15337 /* Wrapping a constant. */
15338 tree int_cst
= build_int_cst (integer_type_node
, 42);
15339 ASSERT_FALSE (CAN_HAVE_LOCATION_P (int_cst
));
15340 ASSERT_FALSE (location_wrapper_p (int_cst
));
15342 tree wrapped_int_cst
= maybe_wrap_with_location (int_cst
, loc
);
15343 ASSERT_TRUE (location_wrapper_p (wrapped_int_cst
));
15344 ASSERT_EQ (loc
, EXPR_LOCATION (wrapped_int_cst
));
15345 ASSERT_EQ (int_cst
, tree_strip_any_location_wrapper (wrapped_int_cst
));
15347 /* We shouldn't add wrapper nodes for UNKNOWN_LOCATION. */
15348 ASSERT_EQ (int_cst
, maybe_wrap_with_location (int_cst
, UNKNOWN_LOCATION
));
15350 /* We shouldn't add wrapper nodes for nodes that CAN_HAVE_LOCATION_P. */
15351 tree cast
= build1 (NOP_EXPR
, char_type_node
, int_cst
);
15352 ASSERT_TRUE (CAN_HAVE_LOCATION_P (cast
));
15353 ASSERT_EQ (cast
, maybe_wrap_with_location (cast
, loc
));
15355 /* Wrapping a STRING_CST. */
15356 tree string_cst
= build_string (4, "foo");
15357 ASSERT_FALSE (CAN_HAVE_LOCATION_P (string_cst
));
15358 ASSERT_FALSE (location_wrapper_p (string_cst
));
15360 tree wrapped_string_cst
= maybe_wrap_with_location (string_cst
, loc
);
15361 ASSERT_TRUE (location_wrapper_p (wrapped_string_cst
));
15362 ASSERT_EQ (VIEW_CONVERT_EXPR
, TREE_CODE (wrapped_string_cst
));
15363 ASSERT_EQ (loc
, EXPR_LOCATION (wrapped_string_cst
));
15364 ASSERT_EQ (string_cst
, tree_strip_any_location_wrapper (wrapped_string_cst
));
15367 /* Wrapping a variable. */
15368 tree int_var
= build_decl (UNKNOWN_LOCATION
, VAR_DECL
,
15369 get_identifier ("some_int_var"),
15370 integer_type_node
);
15371 ASSERT_FALSE (CAN_HAVE_LOCATION_P (int_var
));
15372 ASSERT_FALSE (location_wrapper_p (int_var
));
15374 tree wrapped_int_var
= maybe_wrap_with_location (int_var
, loc
);
15375 ASSERT_TRUE (location_wrapper_p (wrapped_int_var
));
15376 ASSERT_EQ (loc
, EXPR_LOCATION (wrapped_int_var
));
15377 ASSERT_EQ (int_var
, tree_strip_any_location_wrapper (wrapped_int_var
));
15379 /* Verify that "reinterpret_cast<int>(some_int_var)" is not a location
15381 tree r_cast
= build1 (NON_LVALUE_EXPR
, integer_type_node
, int_var
);
15382 ASSERT_FALSE (location_wrapper_p (r_cast
));
15383 ASSERT_EQ (r_cast
, tree_strip_any_location_wrapper (r_cast
));
15385 /* Verify that STRIP_NOPS removes wrappers. */
15386 check_strip_nops (wrapped_int_cst
, int_cst
);
15387 check_strip_nops (wrapped_string_cst
, string_cst
);
15388 check_strip_nops (wrapped_int_var
, int_var
);
15391 /* Test various tree predicates. Verify that location wrappers don't
15392 affect the results. */
15397 /* Build various constants and wrappers around them. */
15399 location_t loc
= BUILTINS_LOCATION
;
15401 tree i_0
= build_int_cst (integer_type_node
, 0);
15402 tree wr_i_0
= maybe_wrap_with_location (i_0
, loc
);
15404 tree i_1
= build_int_cst (integer_type_node
, 1);
15405 tree wr_i_1
= maybe_wrap_with_location (i_1
, loc
);
15407 tree i_m1
= build_int_cst (integer_type_node
, -1);
15408 tree wr_i_m1
= maybe_wrap_with_location (i_m1
, loc
);
15410 tree f_0
= build_real_from_int_cst (float_type_node
, i_0
);
15411 tree wr_f_0
= maybe_wrap_with_location (f_0
, loc
);
15412 tree f_1
= build_real_from_int_cst (float_type_node
, i_1
);
15413 tree wr_f_1
= maybe_wrap_with_location (f_1
, loc
);
15414 tree f_m1
= build_real_from_int_cst (float_type_node
, i_m1
);
15415 tree wr_f_m1
= maybe_wrap_with_location (f_m1
, loc
);
15417 tree c_i_0
= build_complex (NULL_TREE
, i_0
, i_0
);
15418 tree c_i_1
= build_complex (NULL_TREE
, i_1
, i_0
);
15419 tree c_i_m1
= build_complex (NULL_TREE
, i_m1
, i_0
);
15421 tree c_f_0
= build_complex (NULL_TREE
, f_0
, f_0
);
15422 tree c_f_1
= build_complex (NULL_TREE
, f_1
, f_0
);
15423 tree c_f_m1
= build_complex (NULL_TREE
, f_m1
, f_0
);
15425 /* TODO: vector constants. */
15427 /* Test integer_onep. */
15428 ASSERT_FALSE (integer_onep (i_0
));
15429 ASSERT_FALSE (integer_onep (wr_i_0
));
15430 ASSERT_TRUE (integer_onep (i_1
));
15431 ASSERT_TRUE (integer_onep (wr_i_1
));
15432 ASSERT_FALSE (integer_onep (i_m1
));
15433 ASSERT_FALSE (integer_onep (wr_i_m1
));
15434 ASSERT_FALSE (integer_onep (f_0
));
15435 ASSERT_FALSE (integer_onep (wr_f_0
));
15436 ASSERT_FALSE (integer_onep (f_1
));
15437 ASSERT_FALSE (integer_onep (wr_f_1
));
15438 ASSERT_FALSE (integer_onep (f_m1
));
15439 ASSERT_FALSE (integer_onep (wr_f_m1
));
15440 ASSERT_FALSE (integer_onep (c_i_0
));
15441 ASSERT_TRUE (integer_onep (c_i_1
));
15442 ASSERT_FALSE (integer_onep (c_i_m1
));
15443 ASSERT_FALSE (integer_onep (c_f_0
));
15444 ASSERT_FALSE (integer_onep (c_f_1
));
15445 ASSERT_FALSE (integer_onep (c_f_m1
));
15447 /* Test integer_zerop. */
15448 ASSERT_TRUE (integer_zerop (i_0
));
15449 ASSERT_TRUE (integer_zerop (wr_i_0
));
15450 ASSERT_FALSE (integer_zerop (i_1
));
15451 ASSERT_FALSE (integer_zerop (wr_i_1
));
15452 ASSERT_FALSE (integer_zerop (i_m1
));
15453 ASSERT_FALSE (integer_zerop (wr_i_m1
));
15454 ASSERT_FALSE (integer_zerop (f_0
));
15455 ASSERT_FALSE (integer_zerop (wr_f_0
));
15456 ASSERT_FALSE (integer_zerop (f_1
));
15457 ASSERT_FALSE (integer_zerop (wr_f_1
));
15458 ASSERT_FALSE (integer_zerop (f_m1
));
15459 ASSERT_FALSE (integer_zerop (wr_f_m1
));
15460 ASSERT_TRUE (integer_zerop (c_i_0
));
15461 ASSERT_FALSE (integer_zerop (c_i_1
));
15462 ASSERT_FALSE (integer_zerop (c_i_m1
));
15463 ASSERT_FALSE (integer_zerop (c_f_0
));
15464 ASSERT_FALSE (integer_zerop (c_f_1
));
15465 ASSERT_FALSE (integer_zerop (c_f_m1
));
15467 /* Test integer_all_onesp. */
15468 ASSERT_FALSE (integer_all_onesp (i_0
));
15469 ASSERT_FALSE (integer_all_onesp (wr_i_0
));
15470 ASSERT_FALSE (integer_all_onesp (i_1
));
15471 ASSERT_FALSE (integer_all_onesp (wr_i_1
));
15472 ASSERT_TRUE (integer_all_onesp (i_m1
));
15473 ASSERT_TRUE (integer_all_onesp (wr_i_m1
));
15474 ASSERT_FALSE (integer_all_onesp (f_0
));
15475 ASSERT_FALSE (integer_all_onesp (wr_f_0
));
15476 ASSERT_FALSE (integer_all_onesp (f_1
));
15477 ASSERT_FALSE (integer_all_onesp (wr_f_1
));
15478 ASSERT_FALSE (integer_all_onesp (f_m1
));
15479 ASSERT_FALSE (integer_all_onesp (wr_f_m1
));
15480 ASSERT_FALSE (integer_all_onesp (c_i_0
));
15481 ASSERT_FALSE (integer_all_onesp (c_i_1
));
15482 ASSERT_FALSE (integer_all_onesp (c_i_m1
));
15483 ASSERT_FALSE (integer_all_onesp (c_f_0
));
15484 ASSERT_FALSE (integer_all_onesp (c_f_1
));
15485 ASSERT_FALSE (integer_all_onesp (c_f_m1
));
15487 /* Test integer_minus_onep. */
15488 ASSERT_FALSE (integer_minus_onep (i_0
));
15489 ASSERT_FALSE (integer_minus_onep (wr_i_0
));
15490 ASSERT_FALSE (integer_minus_onep (i_1
));
15491 ASSERT_FALSE (integer_minus_onep (wr_i_1
));
15492 ASSERT_TRUE (integer_minus_onep (i_m1
));
15493 ASSERT_TRUE (integer_minus_onep (wr_i_m1
));
15494 ASSERT_FALSE (integer_minus_onep (f_0
));
15495 ASSERT_FALSE (integer_minus_onep (wr_f_0
));
15496 ASSERT_FALSE (integer_minus_onep (f_1
));
15497 ASSERT_FALSE (integer_minus_onep (wr_f_1
));
15498 ASSERT_FALSE (integer_minus_onep (f_m1
));
15499 ASSERT_FALSE (integer_minus_onep (wr_f_m1
));
15500 ASSERT_FALSE (integer_minus_onep (c_i_0
));
15501 ASSERT_FALSE (integer_minus_onep (c_i_1
));
15502 ASSERT_TRUE (integer_minus_onep (c_i_m1
));
15503 ASSERT_FALSE (integer_minus_onep (c_f_0
));
15504 ASSERT_FALSE (integer_minus_onep (c_f_1
));
15505 ASSERT_FALSE (integer_minus_onep (c_f_m1
));
15507 /* Test integer_each_onep. */
15508 ASSERT_FALSE (integer_each_onep (i_0
));
15509 ASSERT_FALSE (integer_each_onep (wr_i_0
));
15510 ASSERT_TRUE (integer_each_onep (i_1
));
15511 ASSERT_TRUE (integer_each_onep (wr_i_1
));
15512 ASSERT_FALSE (integer_each_onep (i_m1
));
15513 ASSERT_FALSE (integer_each_onep (wr_i_m1
));
15514 ASSERT_FALSE (integer_each_onep (f_0
));
15515 ASSERT_FALSE (integer_each_onep (wr_f_0
));
15516 ASSERT_FALSE (integer_each_onep (f_1
));
15517 ASSERT_FALSE (integer_each_onep (wr_f_1
));
15518 ASSERT_FALSE (integer_each_onep (f_m1
));
15519 ASSERT_FALSE (integer_each_onep (wr_f_m1
));
15520 ASSERT_FALSE (integer_each_onep (c_i_0
));
15521 ASSERT_FALSE (integer_each_onep (c_i_1
));
15522 ASSERT_FALSE (integer_each_onep (c_i_m1
));
15523 ASSERT_FALSE (integer_each_onep (c_f_0
));
15524 ASSERT_FALSE (integer_each_onep (c_f_1
));
15525 ASSERT_FALSE (integer_each_onep (c_f_m1
));
15527 /* Test integer_truep. */
15528 ASSERT_FALSE (integer_truep (i_0
));
15529 ASSERT_FALSE (integer_truep (wr_i_0
));
15530 ASSERT_TRUE (integer_truep (i_1
));
15531 ASSERT_TRUE (integer_truep (wr_i_1
));
15532 ASSERT_FALSE (integer_truep (i_m1
));
15533 ASSERT_FALSE (integer_truep (wr_i_m1
));
15534 ASSERT_FALSE (integer_truep (f_0
));
15535 ASSERT_FALSE (integer_truep (wr_f_0
));
15536 ASSERT_FALSE (integer_truep (f_1
));
15537 ASSERT_FALSE (integer_truep (wr_f_1
));
15538 ASSERT_FALSE (integer_truep (f_m1
));
15539 ASSERT_FALSE (integer_truep (wr_f_m1
));
15540 ASSERT_FALSE (integer_truep (c_i_0
));
15541 ASSERT_TRUE (integer_truep (c_i_1
));
15542 ASSERT_FALSE (integer_truep (c_i_m1
));
15543 ASSERT_FALSE (integer_truep (c_f_0
));
15544 ASSERT_FALSE (integer_truep (c_f_1
));
15545 ASSERT_FALSE (integer_truep (c_f_m1
));
15547 /* Test integer_nonzerop. */
15548 ASSERT_FALSE (integer_nonzerop (i_0
));
15549 ASSERT_FALSE (integer_nonzerop (wr_i_0
));
15550 ASSERT_TRUE (integer_nonzerop (i_1
));
15551 ASSERT_TRUE (integer_nonzerop (wr_i_1
));
15552 ASSERT_TRUE (integer_nonzerop (i_m1
));
15553 ASSERT_TRUE (integer_nonzerop (wr_i_m1
));
15554 ASSERT_FALSE (integer_nonzerop (f_0
));
15555 ASSERT_FALSE (integer_nonzerop (wr_f_0
));
15556 ASSERT_FALSE (integer_nonzerop (f_1
));
15557 ASSERT_FALSE (integer_nonzerop (wr_f_1
));
15558 ASSERT_FALSE (integer_nonzerop (f_m1
));
15559 ASSERT_FALSE (integer_nonzerop (wr_f_m1
));
15560 ASSERT_FALSE (integer_nonzerop (c_i_0
));
15561 ASSERT_TRUE (integer_nonzerop (c_i_1
));
15562 ASSERT_TRUE (integer_nonzerop (c_i_m1
));
15563 ASSERT_FALSE (integer_nonzerop (c_f_0
));
15564 ASSERT_FALSE (integer_nonzerop (c_f_1
));
15565 ASSERT_FALSE (integer_nonzerop (c_f_m1
));
15567 /* Test real_zerop. */
15568 ASSERT_FALSE (real_zerop (i_0
));
15569 ASSERT_FALSE (real_zerop (wr_i_0
));
15570 ASSERT_FALSE (real_zerop (i_1
));
15571 ASSERT_FALSE (real_zerop (wr_i_1
));
15572 ASSERT_FALSE (real_zerop (i_m1
));
15573 ASSERT_FALSE (real_zerop (wr_i_m1
));
15574 ASSERT_TRUE (real_zerop (f_0
));
15575 ASSERT_TRUE (real_zerop (wr_f_0
));
15576 ASSERT_FALSE (real_zerop (f_1
));
15577 ASSERT_FALSE (real_zerop (wr_f_1
));
15578 ASSERT_FALSE (real_zerop (f_m1
));
15579 ASSERT_FALSE (real_zerop (wr_f_m1
));
15580 ASSERT_FALSE (real_zerop (c_i_0
));
15581 ASSERT_FALSE (real_zerop (c_i_1
));
15582 ASSERT_FALSE (real_zerop (c_i_m1
));
15583 ASSERT_TRUE (real_zerop (c_f_0
));
15584 ASSERT_FALSE (real_zerop (c_f_1
));
15585 ASSERT_FALSE (real_zerop (c_f_m1
));
15587 /* Test real_onep. */
15588 ASSERT_FALSE (real_onep (i_0
));
15589 ASSERT_FALSE (real_onep (wr_i_0
));
15590 ASSERT_FALSE (real_onep (i_1
));
15591 ASSERT_FALSE (real_onep (wr_i_1
));
15592 ASSERT_FALSE (real_onep (i_m1
));
15593 ASSERT_FALSE (real_onep (wr_i_m1
));
15594 ASSERT_FALSE (real_onep (f_0
));
15595 ASSERT_FALSE (real_onep (wr_f_0
));
15596 ASSERT_TRUE (real_onep (f_1
));
15597 ASSERT_TRUE (real_onep (wr_f_1
));
15598 ASSERT_FALSE (real_onep (f_m1
));
15599 ASSERT_FALSE (real_onep (wr_f_m1
));
15600 ASSERT_FALSE (real_onep (c_i_0
));
15601 ASSERT_FALSE (real_onep (c_i_1
));
15602 ASSERT_FALSE (real_onep (c_i_m1
));
15603 ASSERT_FALSE (real_onep (c_f_0
));
15604 ASSERT_TRUE (real_onep (c_f_1
));
15605 ASSERT_FALSE (real_onep (c_f_m1
));
15607 /* Test real_minus_onep. */
15608 ASSERT_FALSE (real_minus_onep (i_0
));
15609 ASSERT_FALSE (real_minus_onep (wr_i_0
));
15610 ASSERT_FALSE (real_minus_onep (i_1
));
15611 ASSERT_FALSE (real_minus_onep (wr_i_1
));
15612 ASSERT_FALSE (real_minus_onep (i_m1
));
15613 ASSERT_FALSE (real_minus_onep (wr_i_m1
));
15614 ASSERT_FALSE (real_minus_onep (f_0
));
15615 ASSERT_FALSE (real_minus_onep (wr_f_0
));
15616 ASSERT_FALSE (real_minus_onep (f_1
));
15617 ASSERT_FALSE (real_minus_onep (wr_f_1
));
15618 ASSERT_TRUE (real_minus_onep (f_m1
));
15619 ASSERT_TRUE (real_minus_onep (wr_f_m1
));
15620 ASSERT_FALSE (real_minus_onep (c_i_0
));
15621 ASSERT_FALSE (real_minus_onep (c_i_1
));
15622 ASSERT_FALSE (real_minus_onep (c_i_m1
));
15623 ASSERT_FALSE (real_minus_onep (c_f_0
));
15624 ASSERT_FALSE (real_minus_onep (c_f_1
));
15625 ASSERT_TRUE (real_minus_onep (c_f_m1
));
15628 ASSERT_TRUE (zerop (i_0
));
15629 ASSERT_TRUE (zerop (wr_i_0
));
15630 ASSERT_FALSE (zerop (i_1
));
15631 ASSERT_FALSE (zerop (wr_i_1
));
15632 ASSERT_FALSE (zerop (i_m1
));
15633 ASSERT_FALSE (zerop (wr_i_m1
));
15634 ASSERT_TRUE (zerop (f_0
));
15635 ASSERT_TRUE (zerop (wr_f_0
));
15636 ASSERT_FALSE (zerop (f_1
));
15637 ASSERT_FALSE (zerop (wr_f_1
));
15638 ASSERT_FALSE (zerop (f_m1
));
15639 ASSERT_FALSE (zerop (wr_f_m1
));
15640 ASSERT_TRUE (zerop (c_i_0
));
15641 ASSERT_FALSE (zerop (c_i_1
));
15642 ASSERT_FALSE (zerop (c_i_m1
));
15643 ASSERT_TRUE (zerop (c_f_0
));
15644 ASSERT_FALSE (zerop (c_f_1
));
15645 ASSERT_FALSE (zerop (c_f_m1
));
15647 /* Test tree_expr_nonnegative_p. */
15648 ASSERT_TRUE (tree_expr_nonnegative_p (i_0
));
15649 ASSERT_TRUE (tree_expr_nonnegative_p (wr_i_0
));
15650 ASSERT_TRUE (tree_expr_nonnegative_p (i_1
));
15651 ASSERT_TRUE (tree_expr_nonnegative_p (wr_i_1
));
15652 ASSERT_FALSE (tree_expr_nonnegative_p (i_m1
));
15653 ASSERT_FALSE (tree_expr_nonnegative_p (wr_i_m1
));
15654 ASSERT_TRUE (tree_expr_nonnegative_p (f_0
));
15655 ASSERT_TRUE (tree_expr_nonnegative_p (wr_f_0
));
15656 ASSERT_TRUE (tree_expr_nonnegative_p (f_1
));
15657 ASSERT_TRUE (tree_expr_nonnegative_p (wr_f_1
));
15658 ASSERT_FALSE (tree_expr_nonnegative_p (f_m1
));
15659 ASSERT_FALSE (tree_expr_nonnegative_p (wr_f_m1
));
15660 ASSERT_FALSE (tree_expr_nonnegative_p (c_i_0
));
15661 ASSERT_FALSE (tree_expr_nonnegative_p (c_i_1
));
15662 ASSERT_FALSE (tree_expr_nonnegative_p (c_i_m1
));
15663 ASSERT_FALSE (tree_expr_nonnegative_p (c_f_0
));
15664 ASSERT_FALSE (tree_expr_nonnegative_p (c_f_1
));
15665 ASSERT_FALSE (tree_expr_nonnegative_p (c_f_m1
));
15667 /* Test tree_expr_nonzero_p. */
15668 ASSERT_FALSE (tree_expr_nonzero_p (i_0
));
15669 ASSERT_FALSE (tree_expr_nonzero_p (wr_i_0
));
15670 ASSERT_TRUE (tree_expr_nonzero_p (i_1
));
15671 ASSERT_TRUE (tree_expr_nonzero_p (wr_i_1
));
15672 ASSERT_TRUE (tree_expr_nonzero_p (i_m1
));
15673 ASSERT_TRUE (tree_expr_nonzero_p (wr_i_m1
));
15675 /* Test integer_valued_real_p. */
15676 ASSERT_FALSE (integer_valued_real_p (i_0
));
15677 ASSERT_TRUE (integer_valued_real_p (f_0
));
15678 ASSERT_TRUE (integer_valued_real_p (wr_f_0
));
15679 ASSERT_TRUE (integer_valued_real_p (f_1
));
15680 ASSERT_TRUE (integer_valued_real_p (wr_f_1
));
15682 /* Test integer_pow2p. */
15683 ASSERT_FALSE (integer_pow2p (i_0
));
15684 ASSERT_TRUE (integer_pow2p (i_1
));
15685 ASSERT_TRUE (integer_pow2p (wr_i_1
));
15687 /* Test uniform_integer_cst_p. */
15688 ASSERT_TRUE (uniform_integer_cst_p (i_0
));
15689 ASSERT_TRUE (uniform_integer_cst_p (wr_i_0
));
15690 ASSERT_TRUE (uniform_integer_cst_p (i_1
));
15691 ASSERT_TRUE (uniform_integer_cst_p (wr_i_1
));
15692 ASSERT_TRUE (uniform_integer_cst_p (i_m1
));
15693 ASSERT_TRUE (uniform_integer_cst_p (wr_i_m1
));
15694 ASSERT_FALSE (uniform_integer_cst_p (f_0
));
15695 ASSERT_FALSE (uniform_integer_cst_p (wr_f_0
));
15696 ASSERT_FALSE (uniform_integer_cst_p (f_1
));
15697 ASSERT_FALSE (uniform_integer_cst_p (wr_f_1
));
15698 ASSERT_FALSE (uniform_integer_cst_p (f_m1
));
15699 ASSERT_FALSE (uniform_integer_cst_p (wr_f_m1
));
15700 ASSERT_FALSE (uniform_integer_cst_p (c_i_0
));
15701 ASSERT_FALSE (uniform_integer_cst_p (c_i_1
));
15702 ASSERT_FALSE (uniform_integer_cst_p (c_i_m1
));
15703 ASSERT_FALSE (uniform_integer_cst_p (c_f_0
));
15704 ASSERT_FALSE (uniform_integer_cst_p (c_f_1
));
15705 ASSERT_FALSE (uniform_integer_cst_p (c_f_m1
));
15708 /* Check that string escaping works correctly. */
15711 test_escaped_strings (void)
15714 escaped_string msg
;
15717 /* ASSERT_STREQ does not accept NULL as a valid test
15718 result, so we have to use ASSERT_EQ instead. */
15719 ASSERT_EQ (NULL
, (const char *) msg
);
15722 ASSERT_STREQ ("", (const char *) msg
);
15724 msg
.escape ("foobar");
15725 ASSERT_STREQ ("foobar", (const char *) msg
);
15727 /* Ensure that we have -fmessage-length set to 0. */
15728 saved_cutoff
= pp_line_cutoff (global_dc
->printer
);
15729 pp_line_cutoff (global_dc
->printer
) = 0;
15731 msg
.escape ("foo\nbar");
15732 ASSERT_STREQ ("foo\\nbar", (const char *) msg
);
15734 msg
.escape ("\a\b\f\n\r\t\v");
15735 ASSERT_STREQ ("\\a\\b\\f\\n\\r\\t\\v", (const char *) msg
);
15737 /* Now repeat the tests with -fmessage-length set to 5. */
15738 pp_line_cutoff (global_dc
->printer
) = 5;
15740 /* Note that the newline is not translated into an escape. */
15741 msg
.escape ("foo\nbar");
15742 ASSERT_STREQ ("foo\nbar", (const char *) msg
);
15744 msg
.escape ("\a\b\f\n\r\t\v");
15745 ASSERT_STREQ ("\\a\\b\\f\n\\r\\t\\v", (const char *) msg
);
15747 /* Restore the original message length setting. */
15748 pp_line_cutoff (global_dc
->printer
) = saved_cutoff
;
15751 /* Run all of the selftests within this file. */
15756 test_integer_constants ();
15757 test_identifiers ();
15759 test_vector_cst_patterns ();
15760 test_location_wrappers ();
15761 test_predicates ();
15762 test_escaped_strings ();
15765 } // namespace selftest
15767 #endif /* CHECKING_P */
15769 #include "gt-tree.h"