1 /* Language-independent node constructors for parse phase of GNU compiler.
2 Copyright (C) 1987-2014 Free Software Foundation, Inc.
4 This file is part of GCC.
6 GCC is free software; you can redistribute it and/or modify it under
7 the terms of the GNU General Public License as published by the Free
8 Software Foundation; either version 3, or (at your option) any later
11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING3. If not see
18 <http://www.gnu.org/licenses/>. */
20 /* This file contains the low level primitives for operating on tree nodes,
21 including allocation, list operations, interning of identifiers,
22 construction of data type nodes and statement nodes,
23 and construction of type conversion nodes. It also contains
24 tables index by tree code that describe how to take apart
27 It is intended to be language-independent, but occasionally
28 calls language-dependent routines defined (for C) in typecheck.c. */
32 #include "coretypes.h"
36 #include "stor-layout.h"
45 #include "hard-reg-set.h"
49 #include "toplev.h" /* get_random_seed */
51 #include "filenames.h"
54 #include "common/common-target.h"
55 #include "langhooks.h"
56 #include "tree-inline.h"
57 #include "tree-iterator.h"
59 #include "dominance.h"
61 #include "basic-block.h"
63 #include "tree-ssa-alias.h"
64 #include "internal-fn.h"
65 #include "gimple-expr.h"
68 #include "gimple-iterator.h"
70 #include "gimple-ssa.h"
72 #include "plugin-api.h"
75 #include "tree-phinodes.h"
76 #include "stringpool.h"
77 #include "tree-ssanames.h"
81 #include "tree-pass.h"
82 #include "langhooks-def.h"
83 #include "diagnostic.h"
84 #include "tree-diagnostic.h"
85 #include "tree-pretty-print.h"
92 /* Tree code classes. */
94 #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) TYPE,
95 #define END_OF_BASE_TREE_CODES tcc_exceptional,
97 const enum tree_code_class tree_code_type
[] = {
98 #include "all-tree.def"
102 #undef END_OF_BASE_TREE_CODES
104 /* Table indexed by tree code giving number of expression
105 operands beyond the fixed part of the node structure.
106 Not used for types or decls. */
108 #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) LENGTH,
109 #define END_OF_BASE_TREE_CODES 0,
111 const unsigned char tree_code_length
[] = {
112 #include "all-tree.def"
116 #undef END_OF_BASE_TREE_CODES
118 /* Names of tree components.
119 Used for printing out the tree and error messages. */
120 #define DEFTREECODE(SYM, NAME, TYPE, LEN) NAME,
121 #define END_OF_BASE_TREE_CODES "@dummy",
123 static const char *const tree_code_name
[] = {
124 #include "all-tree.def"
128 #undef END_OF_BASE_TREE_CODES
130 /* Each tree code class has an associated string representation.
131 These must correspond to the tree_code_class entries. */
133 const char *const tree_code_class_strings
[] =
148 /* obstack.[ch] explicitly declined to prototype this. */
149 extern int _obstack_allocated_p (struct obstack
*h
, void *obj
);
151 /* Statistics-gathering stuff. */
153 static int tree_code_counts
[MAX_TREE_CODES
];
154 int tree_node_counts
[(int) all_kinds
];
155 int tree_node_sizes
[(int) all_kinds
];
157 /* Keep in sync with tree.h:enum tree_node_kind. */
158 static const char * const tree_node_kind_names
[] = {
177 /* Unique id for next decl created. */
178 static GTY(()) int next_decl_uid
;
179 /* Unique id for next type created. */
180 static GTY(()) int next_type_uid
= 1;
181 /* Unique id for next debug decl created. Use negative numbers,
182 to catch erroneous uses. */
183 static GTY(()) int next_debug_decl_uid
;
185 /* Since we cannot rehash a type after it is in the table, we have to
186 keep the hash code. */
188 struct GTY((for_user
)) type_hash
{
193 /* Initial size of the hash table (rounded to next prime). */
194 #define TYPE_HASH_INITIAL_SIZE 1000
196 struct type_cache_hasher
: ggc_cache_hasher
<type_hash
*>
198 static hashval_t
hash (type_hash
*t
) { return t
->hash
; }
199 static bool equal (type_hash
*a
, type_hash
*b
);
202 handle_cache_entry (type_hash
*&t
)
204 extern void gt_ggc_mx (type_hash
*&);
205 if (t
== HTAB_DELETED_ENTRY
|| t
== HTAB_EMPTY_ENTRY
)
207 else if (ggc_marked_p (t
->type
))
210 t
= static_cast<type_hash
*> (HTAB_DELETED_ENTRY
);
214 /* Now here is the hash table. When recording a type, it is added to
215 the slot whose index is the hash code. Note that the hash table is
216 used for several kinds of types (function types, array types and
217 array index range types, for now). While all these live in the
218 same table, they are completely independent, and the hash code is
219 computed differently for each of these. */
221 static GTY ((cache
)) hash_table
<type_cache_hasher
> *type_hash_table
;
223 /* Hash table and temporary node for larger integer const values. */
224 static GTY (()) tree int_cst_node
;
226 struct int_cst_hasher
: ggc_cache_hasher
<tree
>
228 static hashval_t
hash (tree t
);
229 static bool equal (tree x
, tree y
);
232 static GTY ((cache
)) hash_table
<int_cst_hasher
> *int_cst_hash_table
;
234 /* Hash table for optimization flags and target option flags. Use the same
235 hash table for both sets of options. Nodes for building the current
236 optimization and target option nodes. The assumption is most of the time
237 the options created will already be in the hash table, so we avoid
238 allocating and freeing up a node repeatably. */
239 static GTY (()) tree cl_optimization_node
;
240 static GTY (()) tree cl_target_option_node
;
242 struct cl_option_hasher
: ggc_cache_hasher
<tree
>
244 static hashval_t
hash (tree t
);
245 static bool equal (tree x
, tree y
);
248 static GTY ((cache
)) hash_table
<cl_option_hasher
> *cl_option_hash_table
;
250 /* General tree->tree mapping structure for use in hash tables. */
254 hash_table
<tree_decl_map_cache_hasher
> *debug_expr_for_decl
;
257 hash_table
<tree_decl_map_cache_hasher
> *value_expr_for_decl
;
259 struct tree_vec_map_cache_hasher
: ggc_cache_hasher
<tree_vec_map
*>
261 static hashval_t
hash (tree_vec_map
*m
) { return DECL_UID (m
->base
.from
); }
264 equal (tree_vec_map
*a
, tree_vec_map
*b
)
266 return a
->base
.from
== b
->base
.from
;
270 handle_cache_entry (tree_vec_map
*&m
)
272 extern void gt_ggc_mx (tree_vec_map
*&);
273 if (m
== HTAB_EMPTY_ENTRY
|| m
== HTAB_DELETED_ENTRY
)
275 else if (ggc_marked_p (m
->base
.from
))
278 m
= static_cast<tree_vec_map
*> (HTAB_DELETED_ENTRY
);
283 hash_table
<tree_vec_map_cache_hasher
> *debug_args_for_decl
;
285 static void set_type_quals (tree
, int);
286 static void print_type_hash_statistics (void);
287 static void print_debug_expr_statistics (void);
288 static void print_value_expr_statistics (void);
289 static void type_hash_list (const_tree
, inchash::hash
&);
290 static void attribute_hash_list (const_tree
, inchash::hash
&);
292 tree global_trees
[TI_MAX
];
293 tree integer_types
[itk_none
];
295 bool int_n_enabled_p
[NUM_INT_N_ENTS
];
296 struct int_n_trees_t int_n_trees
[NUM_INT_N_ENTS
];
298 unsigned char tree_contains_struct
[MAX_TREE_CODES
][64];
300 /* Number of operands for each OpenMP clause. */
301 unsigned const char omp_clause_num_ops
[] =
303 0, /* OMP_CLAUSE_ERROR */
304 1, /* OMP_CLAUSE_PRIVATE */
305 1, /* OMP_CLAUSE_SHARED */
306 1, /* OMP_CLAUSE_FIRSTPRIVATE */
307 2, /* OMP_CLAUSE_LASTPRIVATE */
308 4, /* OMP_CLAUSE_REDUCTION */
309 1, /* OMP_CLAUSE_COPYIN */
310 1, /* OMP_CLAUSE_COPYPRIVATE */
311 3, /* OMP_CLAUSE_LINEAR */
312 2, /* OMP_CLAUSE_ALIGNED */
313 1, /* OMP_CLAUSE_DEPEND */
314 1, /* OMP_CLAUSE_UNIFORM */
315 2, /* OMP_CLAUSE_FROM */
316 2, /* OMP_CLAUSE_TO */
317 2, /* OMP_CLAUSE_MAP */
318 1, /* OMP_CLAUSE__LOOPTEMP_ */
319 1, /* OMP_CLAUSE_IF */
320 1, /* OMP_CLAUSE_NUM_THREADS */
321 1, /* OMP_CLAUSE_SCHEDULE */
322 0, /* OMP_CLAUSE_NOWAIT */
323 0, /* OMP_CLAUSE_ORDERED */
324 0, /* OMP_CLAUSE_DEFAULT */
325 3, /* OMP_CLAUSE_COLLAPSE */
326 0, /* OMP_CLAUSE_UNTIED */
327 1, /* OMP_CLAUSE_FINAL */
328 0, /* OMP_CLAUSE_MERGEABLE */
329 1, /* OMP_CLAUSE_DEVICE */
330 1, /* OMP_CLAUSE_DIST_SCHEDULE */
331 0, /* OMP_CLAUSE_INBRANCH */
332 0, /* OMP_CLAUSE_NOTINBRANCH */
333 1, /* OMP_CLAUSE_NUM_TEAMS */
334 1, /* OMP_CLAUSE_THREAD_LIMIT */
335 0, /* OMP_CLAUSE_PROC_BIND */
336 1, /* OMP_CLAUSE_SAFELEN */
337 1, /* OMP_CLAUSE_SIMDLEN */
338 0, /* OMP_CLAUSE_FOR */
339 0, /* OMP_CLAUSE_PARALLEL */
340 0, /* OMP_CLAUSE_SECTIONS */
341 0, /* OMP_CLAUSE_TASKGROUP */
342 1, /* OMP_CLAUSE__SIMDUID_ */
343 1, /* OMP_CLAUSE__CILK_FOR_COUNT_ */
346 const char * const omp_clause_code_name
[] =
392 /* Return the tree node structure used by tree code CODE. */
394 static inline enum tree_node_structure_enum
395 tree_node_structure_for_code (enum tree_code code
)
397 switch (TREE_CODE_CLASS (code
))
399 case tcc_declaration
:
404 return TS_FIELD_DECL
;
410 return TS_LABEL_DECL
;
412 return TS_RESULT_DECL
;
413 case DEBUG_EXPR_DECL
:
416 return TS_CONST_DECL
;
420 return TS_FUNCTION_DECL
;
421 case TRANSLATION_UNIT_DECL
:
422 return TS_TRANSLATION_UNIT_DECL
;
424 return TS_DECL_NON_COMMON
;
428 return TS_TYPE_NON_COMMON
;
437 default: /* tcc_constant and tcc_exceptional */
442 /* tcc_constant cases. */
443 case VOID_CST
: return TS_TYPED
;
444 case INTEGER_CST
: return TS_INT_CST
;
445 case REAL_CST
: return TS_REAL_CST
;
446 case FIXED_CST
: return TS_FIXED_CST
;
447 case COMPLEX_CST
: return TS_COMPLEX
;
448 case VECTOR_CST
: return TS_VECTOR
;
449 case STRING_CST
: return TS_STRING
;
450 /* tcc_exceptional cases. */
451 case ERROR_MARK
: return TS_COMMON
;
452 case IDENTIFIER_NODE
: return TS_IDENTIFIER
;
453 case TREE_LIST
: return TS_LIST
;
454 case TREE_VEC
: return TS_VEC
;
455 case SSA_NAME
: return TS_SSA_NAME
;
456 case PLACEHOLDER_EXPR
: return TS_COMMON
;
457 case STATEMENT_LIST
: return TS_STATEMENT_LIST
;
458 case BLOCK
: return TS_BLOCK
;
459 case CONSTRUCTOR
: return TS_CONSTRUCTOR
;
460 case TREE_BINFO
: return TS_BINFO
;
461 case OMP_CLAUSE
: return TS_OMP_CLAUSE
;
462 case OPTIMIZATION_NODE
: return TS_OPTIMIZATION
;
463 case TARGET_OPTION_NODE
: return TS_TARGET_OPTION
;
471 /* Initialize tree_contains_struct to describe the hierarchy of tree
475 initialize_tree_contains_struct (void)
479 for (i
= ERROR_MARK
; i
< LAST_AND_UNUSED_TREE_CODE
; i
++)
482 enum tree_node_structure_enum ts_code
;
484 code
= (enum tree_code
) i
;
485 ts_code
= tree_node_structure_for_code (code
);
487 /* Mark the TS structure itself. */
488 tree_contains_struct
[code
][ts_code
] = 1;
490 /* Mark all the structures that TS is derived from. */
508 case TS_STATEMENT_LIST
:
509 MARK_TS_TYPED (code
);
513 case TS_DECL_MINIMAL
:
519 case TS_OPTIMIZATION
:
520 case TS_TARGET_OPTION
:
521 MARK_TS_COMMON (code
);
524 case TS_TYPE_WITH_LANG_SPECIFIC
:
525 MARK_TS_TYPE_COMMON (code
);
528 case TS_TYPE_NON_COMMON
:
529 MARK_TS_TYPE_WITH_LANG_SPECIFIC (code
);
533 MARK_TS_DECL_MINIMAL (code
);
538 MARK_TS_DECL_COMMON (code
);
541 case TS_DECL_NON_COMMON
:
542 MARK_TS_DECL_WITH_VIS (code
);
545 case TS_DECL_WITH_VIS
:
549 MARK_TS_DECL_WRTL (code
);
553 MARK_TS_DECL_COMMON (code
);
557 MARK_TS_DECL_WITH_VIS (code
);
561 case TS_FUNCTION_DECL
:
562 MARK_TS_DECL_NON_COMMON (code
);
565 case TS_TRANSLATION_UNIT_DECL
:
566 MARK_TS_DECL_COMMON (code
);
574 /* Basic consistency checks for attributes used in fold. */
575 gcc_assert (tree_contains_struct
[FUNCTION_DECL
][TS_DECL_NON_COMMON
]);
576 gcc_assert (tree_contains_struct
[TYPE_DECL
][TS_DECL_NON_COMMON
]);
577 gcc_assert (tree_contains_struct
[CONST_DECL
][TS_DECL_COMMON
]);
578 gcc_assert (tree_contains_struct
[VAR_DECL
][TS_DECL_COMMON
]);
579 gcc_assert (tree_contains_struct
[PARM_DECL
][TS_DECL_COMMON
]);
580 gcc_assert (tree_contains_struct
[RESULT_DECL
][TS_DECL_COMMON
]);
581 gcc_assert (tree_contains_struct
[FUNCTION_DECL
][TS_DECL_COMMON
]);
582 gcc_assert (tree_contains_struct
[TYPE_DECL
][TS_DECL_COMMON
]);
583 gcc_assert (tree_contains_struct
[TRANSLATION_UNIT_DECL
][TS_DECL_COMMON
]);
584 gcc_assert (tree_contains_struct
[LABEL_DECL
][TS_DECL_COMMON
]);
585 gcc_assert (tree_contains_struct
[FIELD_DECL
][TS_DECL_COMMON
]);
586 gcc_assert (tree_contains_struct
[VAR_DECL
][TS_DECL_WRTL
]);
587 gcc_assert (tree_contains_struct
[PARM_DECL
][TS_DECL_WRTL
]);
588 gcc_assert (tree_contains_struct
[RESULT_DECL
][TS_DECL_WRTL
]);
589 gcc_assert (tree_contains_struct
[FUNCTION_DECL
][TS_DECL_WRTL
]);
590 gcc_assert (tree_contains_struct
[LABEL_DECL
][TS_DECL_WRTL
]);
591 gcc_assert (tree_contains_struct
[CONST_DECL
][TS_DECL_MINIMAL
]);
592 gcc_assert (tree_contains_struct
[VAR_DECL
][TS_DECL_MINIMAL
]);
593 gcc_assert (tree_contains_struct
[PARM_DECL
][TS_DECL_MINIMAL
]);
594 gcc_assert (tree_contains_struct
[RESULT_DECL
][TS_DECL_MINIMAL
]);
595 gcc_assert (tree_contains_struct
[FUNCTION_DECL
][TS_DECL_MINIMAL
]);
596 gcc_assert (tree_contains_struct
[TYPE_DECL
][TS_DECL_MINIMAL
]);
597 gcc_assert (tree_contains_struct
[TRANSLATION_UNIT_DECL
][TS_DECL_MINIMAL
]);
598 gcc_assert (tree_contains_struct
[LABEL_DECL
][TS_DECL_MINIMAL
]);
599 gcc_assert (tree_contains_struct
[FIELD_DECL
][TS_DECL_MINIMAL
]);
600 gcc_assert (tree_contains_struct
[VAR_DECL
][TS_DECL_WITH_VIS
]);
601 gcc_assert (tree_contains_struct
[FUNCTION_DECL
][TS_DECL_WITH_VIS
]);
602 gcc_assert (tree_contains_struct
[TYPE_DECL
][TS_DECL_WITH_VIS
]);
603 gcc_assert (tree_contains_struct
[VAR_DECL
][TS_VAR_DECL
]);
604 gcc_assert (tree_contains_struct
[FIELD_DECL
][TS_FIELD_DECL
]);
605 gcc_assert (tree_contains_struct
[PARM_DECL
][TS_PARM_DECL
]);
606 gcc_assert (tree_contains_struct
[LABEL_DECL
][TS_LABEL_DECL
]);
607 gcc_assert (tree_contains_struct
[RESULT_DECL
][TS_RESULT_DECL
]);
608 gcc_assert (tree_contains_struct
[CONST_DECL
][TS_CONST_DECL
]);
609 gcc_assert (tree_contains_struct
[TYPE_DECL
][TS_TYPE_DECL
]);
610 gcc_assert (tree_contains_struct
[FUNCTION_DECL
][TS_FUNCTION_DECL
]);
611 gcc_assert (tree_contains_struct
[IMPORTED_DECL
][TS_DECL_MINIMAL
]);
612 gcc_assert (tree_contains_struct
[IMPORTED_DECL
][TS_DECL_COMMON
]);
613 gcc_assert (tree_contains_struct
[NAMELIST_DECL
][TS_DECL_MINIMAL
]);
614 gcc_assert (tree_contains_struct
[NAMELIST_DECL
][TS_DECL_COMMON
]);
623 /* Initialize the hash table of types. */
625 = hash_table
<type_cache_hasher
>::create_ggc (TYPE_HASH_INITIAL_SIZE
);
628 = hash_table
<tree_decl_map_cache_hasher
>::create_ggc (512);
631 = hash_table
<tree_decl_map_cache_hasher
>::create_ggc (512);
633 int_cst_hash_table
= hash_table
<int_cst_hasher
>::create_ggc (1024);
635 int_cst_node
= make_int_cst (1, 1);
637 cl_option_hash_table
= hash_table
<cl_option_hasher
>::create_ggc (64);
639 cl_optimization_node
= make_node (OPTIMIZATION_NODE
);
640 cl_target_option_node
= make_node (TARGET_OPTION_NODE
);
642 /* Initialize the tree_contains_struct array. */
643 initialize_tree_contains_struct ();
644 lang_hooks
.init_ts ();
648 /* The name of the object as the assembler will see it (but before any
649 translations made by ASM_OUTPUT_LABELREF). Often this is the same
650 as DECL_NAME. It is an IDENTIFIER_NODE. */
652 decl_assembler_name (tree decl
)
654 if (!DECL_ASSEMBLER_NAME_SET_P (decl
))
655 lang_hooks
.set_decl_assembler_name (decl
);
656 return DECL_WITH_VIS_CHECK (decl
)->decl_with_vis
.assembler_name
;
659 /* When the target supports COMDAT groups, this indicates which group the
660 DECL is associated with. This can be either an IDENTIFIER_NODE or a
661 decl, in which case its DECL_ASSEMBLER_NAME identifies the group. */
663 decl_comdat_group (const_tree node
)
665 struct symtab_node
*snode
= symtab_node::get (node
);
668 return snode
->get_comdat_group ();
671 /* Likewise, but make sure it's been reduced to an IDENTIFIER_NODE. */
673 decl_comdat_group_id (const_tree node
)
675 struct symtab_node
*snode
= symtab_node::get (node
);
678 return snode
->get_comdat_group_id ();
681 /* When the target supports named section, return its name as IDENTIFIER_NODE
682 or NULL if it is in no section. */
684 decl_section_name (const_tree node
)
686 struct symtab_node
*snode
= symtab_node::get (node
);
689 return snode
->get_section ();
692 /* Set section section name of NODE to VALUE (that is expected to
693 be identifier node) */
695 set_decl_section_name (tree node
, const char *value
)
697 struct symtab_node
*snode
;
701 snode
= symtab_node::get (node
);
705 else if (TREE_CODE (node
) == VAR_DECL
)
706 snode
= varpool_node::get_create (node
);
708 snode
= cgraph_node::get_create (node
);
709 snode
->set_section (value
);
712 /* Return TLS model of a variable NODE. */
714 decl_tls_model (const_tree node
)
716 struct varpool_node
*snode
= varpool_node::get (node
);
718 return TLS_MODEL_NONE
;
719 return snode
->tls_model
;
722 /* Set TLS model of variable NODE to MODEL. */
724 set_decl_tls_model (tree node
, enum tls_model model
)
726 struct varpool_node
*vnode
;
728 if (model
== TLS_MODEL_NONE
)
730 vnode
= varpool_node::get (node
);
735 vnode
= varpool_node::get_create (node
);
736 vnode
->tls_model
= model
;
739 /* Compute the number of bytes occupied by a tree with code CODE.
740 This function cannot be used for nodes that have variable sizes,
741 including TREE_VEC, INTEGER_CST, STRING_CST, and CALL_EXPR. */
743 tree_code_size (enum tree_code code
)
745 switch (TREE_CODE_CLASS (code
))
747 case tcc_declaration
: /* A decl node */
752 return sizeof (struct tree_field_decl
);
754 return sizeof (struct tree_parm_decl
);
756 return sizeof (struct tree_var_decl
);
758 return sizeof (struct tree_label_decl
);
760 return sizeof (struct tree_result_decl
);
762 return sizeof (struct tree_const_decl
);
764 return sizeof (struct tree_type_decl
);
766 return sizeof (struct tree_function_decl
);
767 case DEBUG_EXPR_DECL
:
768 return sizeof (struct tree_decl_with_rtl
);
769 case TRANSLATION_UNIT_DECL
:
770 return sizeof (struct tree_translation_unit_decl
);
774 return sizeof (struct tree_decl_non_common
);
776 return lang_hooks
.tree_size (code
);
780 case tcc_type
: /* a type node */
781 return sizeof (struct tree_type_non_common
);
783 case tcc_reference
: /* a reference */
784 case tcc_expression
: /* an expression */
785 case tcc_statement
: /* an expression with side effects */
786 case tcc_comparison
: /* a comparison expression */
787 case tcc_unary
: /* a unary arithmetic expression */
788 case tcc_binary
: /* a binary arithmetic expression */
789 return (sizeof (struct tree_exp
)
790 + (TREE_CODE_LENGTH (code
) - 1) * sizeof (tree
));
792 case tcc_constant
: /* a constant */
795 case VOID_CST
: return sizeof (struct tree_typed
);
796 case INTEGER_CST
: gcc_unreachable ();
797 case REAL_CST
: return sizeof (struct tree_real_cst
);
798 case FIXED_CST
: return sizeof (struct tree_fixed_cst
);
799 case COMPLEX_CST
: return sizeof (struct tree_complex
);
800 case VECTOR_CST
: return sizeof (struct tree_vector
);
801 case STRING_CST
: gcc_unreachable ();
803 return lang_hooks
.tree_size (code
);
806 case tcc_exceptional
: /* something random, like an identifier. */
809 case IDENTIFIER_NODE
: return lang_hooks
.identifier_size
;
810 case TREE_LIST
: return sizeof (struct tree_list
);
813 case PLACEHOLDER_EXPR
: return sizeof (struct tree_common
);
816 case OMP_CLAUSE
: gcc_unreachable ();
818 case SSA_NAME
: return sizeof (struct tree_ssa_name
);
820 case STATEMENT_LIST
: return sizeof (struct tree_statement_list
);
821 case BLOCK
: return sizeof (struct tree_block
);
822 case CONSTRUCTOR
: return sizeof (struct tree_constructor
);
823 case OPTIMIZATION_NODE
: return sizeof (struct tree_optimization_option
);
824 case TARGET_OPTION_NODE
: return sizeof (struct tree_target_option
);
827 return lang_hooks
.tree_size (code
);
835 /* Compute the number of bytes occupied by NODE. This routine only
836 looks at TREE_CODE, except for those nodes that have variable sizes. */
838 tree_size (const_tree node
)
840 const enum tree_code code
= TREE_CODE (node
);
844 return (sizeof (struct tree_int_cst
)
845 + (TREE_INT_CST_EXT_NUNITS (node
) - 1) * sizeof (HOST_WIDE_INT
));
848 return (offsetof (struct tree_binfo
, base_binfos
)
850 ::embedded_size (BINFO_N_BASE_BINFOS (node
)));
853 return (sizeof (struct tree_vec
)
854 + (TREE_VEC_LENGTH (node
) - 1) * sizeof (tree
));
857 return (sizeof (struct tree_vector
)
858 + (TYPE_VECTOR_SUBPARTS (TREE_TYPE (node
)) - 1) * sizeof (tree
));
861 return TREE_STRING_LENGTH (node
) + offsetof (struct tree_string
, str
) + 1;
864 return (sizeof (struct tree_omp_clause
)
865 + (omp_clause_num_ops
[OMP_CLAUSE_CODE (node
)] - 1)
869 if (TREE_CODE_CLASS (code
) == tcc_vl_exp
)
870 return (sizeof (struct tree_exp
)
871 + (VL_EXP_OPERAND_LENGTH (node
) - 1) * sizeof (tree
));
873 return tree_code_size (code
);
877 /* Record interesting allocation statistics for a tree node with CODE
881 record_node_allocation_statistics (enum tree_code code ATTRIBUTE_UNUSED
,
882 size_t length ATTRIBUTE_UNUSED
)
884 enum tree_code_class type
= TREE_CODE_CLASS (code
);
887 if (!GATHER_STATISTICS
)
892 case tcc_declaration
: /* A decl node */
896 case tcc_type
: /* a type node */
900 case tcc_statement
: /* an expression with side effects */
904 case tcc_reference
: /* a reference */
908 case tcc_expression
: /* an expression */
909 case tcc_comparison
: /* a comparison expression */
910 case tcc_unary
: /* a unary arithmetic expression */
911 case tcc_binary
: /* a binary arithmetic expression */
915 case tcc_constant
: /* a constant */
919 case tcc_exceptional
: /* something random, like an identifier. */
922 case IDENTIFIER_NODE
:
935 kind
= ssa_name_kind
;
947 kind
= omp_clause_kind
;
964 tree_code_counts
[(int) code
]++;
965 tree_node_counts
[(int) kind
]++;
966 tree_node_sizes
[(int) kind
] += length
;
969 /* Allocate and return a new UID from the DECL_UID namespace. */
972 allocate_decl_uid (void)
974 return next_decl_uid
++;
977 /* Return a newly allocated node of code CODE. For decl and type
978 nodes, some other fields are initialized. The rest of the node is
979 initialized to zero. This function cannot be used for TREE_VEC,
980 INTEGER_CST or OMP_CLAUSE nodes, which is enforced by asserts in
983 Achoo! I got a code in the node. */
986 make_node_stat (enum tree_code code MEM_STAT_DECL
)
989 enum tree_code_class type
= TREE_CODE_CLASS (code
);
990 size_t length
= tree_code_size (code
);
992 record_node_allocation_statistics (code
, length
);
994 t
= ggc_alloc_cleared_tree_node_stat (length PASS_MEM_STAT
);
995 TREE_SET_CODE (t
, code
);
1000 TREE_SIDE_EFFECTS (t
) = 1;
1003 case tcc_declaration
:
1004 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_COMMON
))
1006 if (code
== FUNCTION_DECL
)
1008 DECL_ALIGN (t
) = FUNCTION_BOUNDARY
;
1009 DECL_MODE (t
) = FUNCTION_MODE
;
1014 DECL_SOURCE_LOCATION (t
) = input_location
;
1015 if (TREE_CODE (t
) == DEBUG_EXPR_DECL
)
1016 DECL_UID (t
) = --next_debug_decl_uid
;
1019 DECL_UID (t
) = allocate_decl_uid ();
1020 SET_DECL_PT_UID (t
, -1);
1022 if (TREE_CODE (t
) == LABEL_DECL
)
1023 LABEL_DECL_UID (t
) = -1;
1028 TYPE_UID (t
) = next_type_uid
++;
1029 TYPE_ALIGN (t
) = BITS_PER_UNIT
;
1030 TYPE_USER_ALIGN (t
) = 0;
1031 TYPE_MAIN_VARIANT (t
) = t
;
1032 TYPE_CANONICAL (t
) = t
;
1034 /* Default to no attributes for type, but let target change that. */
1035 TYPE_ATTRIBUTES (t
) = NULL_TREE
;
1036 targetm
.set_default_type_attributes (t
);
1038 /* We have not yet computed the alias set for this type. */
1039 TYPE_ALIAS_SET (t
) = -1;
1043 TREE_CONSTANT (t
) = 1;
1046 case tcc_expression
:
1052 case PREDECREMENT_EXPR
:
1053 case PREINCREMENT_EXPR
:
1054 case POSTDECREMENT_EXPR
:
1055 case POSTINCREMENT_EXPR
:
1056 /* All of these have side-effects, no matter what their
1058 TREE_SIDE_EFFECTS (t
) = 1;
1067 /* Other classes need no special treatment. */
1074 /* Return a new node with the same contents as NODE except that its
1075 TREE_CHAIN, if it has one, is zero and it has a fresh uid. */
1078 copy_node_stat (tree node MEM_STAT_DECL
)
1081 enum tree_code code
= TREE_CODE (node
);
1084 gcc_assert (code
!= STATEMENT_LIST
);
1086 length
= tree_size (node
);
1087 record_node_allocation_statistics (code
, length
);
1088 t
= ggc_alloc_tree_node_stat (length PASS_MEM_STAT
);
1089 memcpy (t
, node
, length
);
1091 if (CODE_CONTAINS_STRUCT (code
, TS_COMMON
))
1093 TREE_ASM_WRITTEN (t
) = 0;
1094 TREE_VISITED (t
) = 0;
1096 if (TREE_CODE_CLASS (code
) == tcc_declaration
)
1098 if (code
== DEBUG_EXPR_DECL
)
1099 DECL_UID (t
) = --next_debug_decl_uid
;
1102 DECL_UID (t
) = allocate_decl_uid ();
1103 if (DECL_PT_UID_SET_P (node
))
1104 SET_DECL_PT_UID (t
, DECL_PT_UID (node
));
1106 if ((TREE_CODE (node
) == PARM_DECL
|| TREE_CODE (node
) == VAR_DECL
)
1107 && DECL_HAS_VALUE_EXPR_P (node
))
1109 SET_DECL_VALUE_EXPR (t
, DECL_VALUE_EXPR (node
));
1110 DECL_HAS_VALUE_EXPR_P (t
) = 1;
1112 /* DECL_DEBUG_EXPR is copied explicitely by callers. */
1113 if (TREE_CODE (node
) == VAR_DECL
)
1115 DECL_HAS_DEBUG_EXPR_P (t
) = 0;
1116 t
->decl_with_vis
.symtab_node
= NULL
;
1118 if (TREE_CODE (node
) == VAR_DECL
&& DECL_HAS_INIT_PRIORITY_P (node
))
1120 SET_DECL_INIT_PRIORITY (t
, DECL_INIT_PRIORITY (node
));
1121 DECL_HAS_INIT_PRIORITY_P (t
) = 1;
1123 if (TREE_CODE (node
) == FUNCTION_DECL
)
1125 DECL_STRUCT_FUNCTION (t
) = NULL
;
1126 t
->decl_with_vis
.symtab_node
= NULL
;
1129 else if (TREE_CODE_CLASS (code
) == tcc_type
)
1131 TYPE_UID (t
) = next_type_uid
++;
1132 /* The following is so that the debug code for
1133 the copy is different from the original type.
1134 The two statements usually duplicate each other
1135 (because they clear fields of the same union),
1136 but the optimizer should catch that. */
1137 TYPE_SYMTAB_POINTER (t
) = 0;
1138 TYPE_SYMTAB_ADDRESS (t
) = 0;
1140 /* Do not copy the values cache. */
1141 if (TYPE_CACHED_VALUES_P (t
))
1143 TYPE_CACHED_VALUES_P (t
) = 0;
1144 TYPE_CACHED_VALUES (t
) = NULL_TREE
;
1151 /* Return a copy of a chain of nodes, chained through the TREE_CHAIN field.
1152 For example, this can copy a list made of TREE_LIST nodes. */
1155 copy_list (tree list
)
1163 head
= prev
= copy_node (list
);
1164 next
= TREE_CHAIN (list
);
1167 TREE_CHAIN (prev
) = copy_node (next
);
1168 prev
= TREE_CHAIN (prev
);
1169 next
= TREE_CHAIN (next
);
1175 /* Return the value that TREE_INT_CST_EXT_NUNITS should have for an
1176 INTEGER_CST with value CST and type TYPE. */
1179 get_int_cst_ext_nunits (tree type
, const wide_int
&cst
)
1181 gcc_checking_assert (cst
.get_precision () == TYPE_PRECISION (type
));
1182 /* We need an extra zero HWI if CST is an unsigned integer with its
1183 upper bit set, and if CST occupies a whole number of HWIs. */
1184 if (TYPE_UNSIGNED (type
)
1186 && (cst
.get_precision () % HOST_BITS_PER_WIDE_INT
) == 0)
1187 return cst
.get_precision () / HOST_BITS_PER_WIDE_INT
+ 1;
1188 return cst
.get_len ();
1191 /* Return a new INTEGER_CST with value CST and type TYPE. */
1194 build_new_int_cst (tree type
, const wide_int
&cst
)
1196 unsigned int len
= cst
.get_len ();
1197 unsigned int ext_len
= get_int_cst_ext_nunits (type
, cst
);
1198 tree nt
= make_int_cst (len
, ext_len
);
1203 TREE_INT_CST_ELT (nt
, ext_len
) = 0;
1204 for (unsigned int i
= len
; i
< ext_len
; ++i
)
1205 TREE_INT_CST_ELT (nt
, i
) = -1;
1207 else if (TYPE_UNSIGNED (type
)
1208 && cst
.get_precision () < len
* HOST_BITS_PER_WIDE_INT
)
1211 TREE_INT_CST_ELT (nt
, len
)
1212 = zext_hwi (cst
.elt (len
),
1213 cst
.get_precision () % HOST_BITS_PER_WIDE_INT
);
1216 for (unsigned int i
= 0; i
< len
; i
++)
1217 TREE_INT_CST_ELT (nt
, i
) = cst
.elt (i
);
1218 TREE_TYPE (nt
) = type
;
1222 /* Create an INT_CST node with a LOW value sign extended to TYPE. */
1225 build_int_cst (tree type
, HOST_WIDE_INT low
)
1227 /* Support legacy code. */
1229 type
= integer_type_node
;
1231 return wide_int_to_tree (type
, wi::shwi (low
, TYPE_PRECISION (type
)));
1235 build_int_cstu (tree type
, unsigned HOST_WIDE_INT cst
)
1237 return wide_int_to_tree (type
, wi::uhwi (cst
, TYPE_PRECISION (type
)));
1240 /* Create an INT_CST node with a LOW value sign extended to TYPE. */
1243 build_int_cst_type (tree type
, HOST_WIDE_INT low
)
1246 return wide_int_to_tree (type
, wi::shwi (low
, TYPE_PRECISION (type
)));
1249 /* Constructs tree in type TYPE from with value given by CST. Signedness
1250 of CST is assumed to be the same as the signedness of TYPE. */
1253 double_int_to_tree (tree type
, double_int cst
)
1255 return wide_int_to_tree (type
, widest_int::from (cst
, TYPE_SIGN (type
)));
1258 /* We force the wide_int CST to the range of the type TYPE by sign or
1259 zero extending it. OVERFLOWABLE indicates if we are interested in
1260 overflow of the value, when >0 we are only interested in signed
1261 overflow, for <0 we are interested in any overflow. OVERFLOWED
1262 indicates whether overflow has already occurred. CONST_OVERFLOWED
1263 indicates whether constant overflow has already occurred. We force
1264 T's value to be within range of T's type (by setting to 0 or 1 all
1265 the bits outside the type's range). We set TREE_OVERFLOWED if,
1266 OVERFLOWED is nonzero,
1267 or OVERFLOWABLE is >0 and signed overflow occurs
1268 or OVERFLOWABLE is <0 and any overflow occurs
1269 We return a new tree node for the extended wide_int. The node
1270 is shared if no overflow flags are set. */
1274 force_fit_type (tree type
, const wide_int_ref
&cst
,
1275 int overflowable
, bool overflowed
)
1277 signop sign
= TYPE_SIGN (type
);
1279 /* If we need to set overflow flags, return a new unshared node. */
1280 if (overflowed
|| !wi::fits_to_tree_p (cst
, type
))
1284 || (overflowable
> 0 && sign
== SIGNED
))
1286 wide_int tmp
= wide_int::from (cst
, TYPE_PRECISION (type
), sign
);
1287 tree t
= build_new_int_cst (type
, tmp
);
1288 TREE_OVERFLOW (t
) = 1;
1293 /* Else build a shared node. */
1294 return wide_int_to_tree (type
, cst
);
1297 /* These are the hash table functions for the hash table of INTEGER_CST
1298 nodes of a sizetype. */
1300 /* Return the hash code code X, an INTEGER_CST. */
1303 int_cst_hasher::hash (tree x
)
1305 const_tree
const t
= x
;
1306 hashval_t code
= htab_hash_pointer (TREE_TYPE (t
));
1309 for (i
= 0; i
< TREE_INT_CST_NUNITS (t
); i
++)
1310 code
^= TREE_INT_CST_ELT (t
, i
);
1315 /* Return nonzero if the value represented by *X (an INTEGER_CST tree node)
1316 is the same as that given by *Y, which is the same. */
1319 int_cst_hasher::equal (tree x
, tree y
)
1321 const_tree
const xt
= x
;
1322 const_tree
const yt
= y
;
1324 if (TREE_TYPE (xt
) != TREE_TYPE (yt
)
1325 || TREE_INT_CST_NUNITS (xt
) != TREE_INT_CST_NUNITS (yt
)
1326 || TREE_INT_CST_EXT_NUNITS (xt
) != TREE_INT_CST_EXT_NUNITS (yt
))
1329 for (int i
= 0; i
< TREE_INT_CST_NUNITS (xt
); i
++)
1330 if (TREE_INT_CST_ELT (xt
, i
) != TREE_INT_CST_ELT (yt
, i
))
1336 /* Create an INT_CST node of TYPE and value CST.
1337 The returned node is always shared. For small integers we use a
1338 per-type vector cache, for larger ones we use a single hash table.
1339 The value is extended from its precision according to the sign of
1340 the type to be a multiple of HOST_BITS_PER_WIDE_INT. This defines
1341 the upper bits and ensures that hashing and value equality based
1342 upon the underlying HOST_WIDE_INTs works without masking. */
1345 wide_int_to_tree (tree type
, const wide_int_ref
&pcst
)
1352 unsigned int prec
= TYPE_PRECISION (type
);
1353 signop sgn
= TYPE_SIGN (type
);
1355 /* Verify that everything is canonical. */
1356 int l
= pcst
.get_len ();
1359 if (pcst
.elt (l
- 1) == 0)
1360 gcc_checking_assert (pcst
.elt (l
- 2) < 0);
1361 if (pcst
.elt (l
- 1) == (HOST_WIDE_INT
) -1)
1362 gcc_checking_assert (pcst
.elt (l
- 2) >= 0);
1365 wide_int cst
= wide_int::from (pcst
, prec
, sgn
);
1366 unsigned int ext_len
= get_int_cst_ext_nunits (type
, cst
);
1370 /* We just need to store a single HOST_WIDE_INT. */
1372 if (TYPE_UNSIGNED (type
))
1373 hwi
= cst
.to_uhwi ();
1375 hwi
= cst
.to_shwi ();
1377 switch (TREE_CODE (type
))
1380 gcc_assert (hwi
== 0);
1384 case REFERENCE_TYPE
:
1385 case POINTER_BOUNDS_TYPE
:
1386 /* Cache NULL pointer and zero bounds. */
1395 /* Cache false or true. */
1403 if (TYPE_SIGN (type
) == UNSIGNED
)
1406 limit
= INTEGER_SHARE_LIMIT
;
1407 if (IN_RANGE (hwi
, 0, INTEGER_SHARE_LIMIT
- 1))
1412 /* Cache [-1, N). */
1413 limit
= INTEGER_SHARE_LIMIT
+ 1;
1414 if (IN_RANGE (hwi
, -1, INTEGER_SHARE_LIMIT
- 1))
1428 /* Look for it in the type's vector of small shared ints. */
1429 if (!TYPE_CACHED_VALUES_P (type
))
1431 TYPE_CACHED_VALUES_P (type
) = 1;
1432 TYPE_CACHED_VALUES (type
) = make_tree_vec (limit
);
1435 t
= TREE_VEC_ELT (TYPE_CACHED_VALUES (type
), ix
);
1437 /* Make sure no one is clobbering the shared constant. */
1438 gcc_checking_assert (TREE_TYPE (t
) == type
1439 && TREE_INT_CST_NUNITS (t
) == 1
1440 && TREE_INT_CST_OFFSET_NUNITS (t
) == 1
1441 && TREE_INT_CST_EXT_NUNITS (t
) == 1
1442 && TREE_INT_CST_ELT (t
, 0) == hwi
);
1445 /* Create a new shared int. */
1446 t
= build_new_int_cst (type
, cst
);
1447 TREE_VEC_ELT (TYPE_CACHED_VALUES (type
), ix
) = t
;
1452 /* Use the cache of larger shared ints, using int_cst_node as
1455 TREE_INT_CST_ELT (int_cst_node
, 0) = hwi
;
1456 TREE_TYPE (int_cst_node
) = type
;
1458 tree
*slot
= int_cst_hash_table
->find_slot (int_cst_node
, INSERT
);
1462 /* Insert this one into the hash table. */
1465 /* Make a new node for next time round. */
1466 int_cst_node
= make_int_cst (1, 1);
1472 /* The value either hashes properly or we drop it on the floor
1473 for the gc to take care of. There will not be enough of them
1476 tree nt
= build_new_int_cst (type
, cst
);
1477 tree
*slot
= int_cst_hash_table
->find_slot (nt
, INSERT
);
1481 /* Insert this one into the hash table. */
1491 cache_integer_cst (tree t
)
1493 tree type
= TREE_TYPE (t
);
1496 int prec
= TYPE_PRECISION (type
);
1498 gcc_assert (!TREE_OVERFLOW (t
));
1500 switch (TREE_CODE (type
))
1503 gcc_assert (integer_zerop (t
));
1507 case REFERENCE_TYPE
:
1508 /* Cache NULL pointer. */
1509 if (integer_zerop (t
))
1517 /* Cache false or true. */
1519 if (wi::ltu_p (t
, 2))
1520 ix
= TREE_INT_CST_ELT (t
, 0);
1525 if (TYPE_UNSIGNED (type
))
1528 limit
= INTEGER_SHARE_LIMIT
;
1530 /* This is a little hokie, but if the prec is smaller than
1531 what is necessary to hold INTEGER_SHARE_LIMIT, then the
1532 obvious test will not get the correct answer. */
1533 if (prec
< HOST_BITS_PER_WIDE_INT
)
1535 if (tree_to_uhwi (t
) < (unsigned HOST_WIDE_INT
) INTEGER_SHARE_LIMIT
)
1536 ix
= tree_to_uhwi (t
);
1538 else if (wi::ltu_p (t
, INTEGER_SHARE_LIMIT
))
1539 ix
= tree_to_uhwi (t
);
1544 limit
= INTEGER_SHARE_LIMIT
+ 1;
1546 if (integer_minus_onep (t
))
1548 else if (!wi::neg_p (t
))
1550 if (prec
< HOST_BITS_PER_WIDE_INT
)
1552 if (tree_to_shwi (t
) < INTEGER_SHARE_LIMIT
)
1553 ix
= tree_to_shwi (t
) + 1;
1555 else if (wi::ltu_p (t
, INTEGER_SHARE_LIMIT
))
1556 ix
= tree_to_shwi (t
) + 1;
1570 /* Look for it in the type's vector of small shared ints. */
1571 if (!TYPE_CACHED_VALUES_P (type
))
1573 TYPE_CACHED_VALUES_P (type
) = 1;
1574 TYPE_CACHED_VALUES (type
) = make_tree_vec (limit
);
1577 gcc_assert (TREE_VEC_ELT (TYPE_CACHED_VALUES (type
), ix
) == NULL_TREE
);
1578 TREE_VEC_ELT (TYPE_CACHED_VALUES (type
), ix
) = t
;
1582 /* Use the cache of larger shared ints. */
1583 tree
*slot
= int_cst_hash_table
->find_slot (t
, INSERT
);
1584 /* If there is already an entry for the number verify it's the
1587 gcc_assert (wi::eq_p (tree (*slot
), t
));
1589 /* Otherwise insert this one into the hash table. */
1595 /* Builds an integer constant in TYPE such that lowest BITS bits are ones
1596 and the rest are zeros. */
1599 build_low_bits_mask (tree type
, unsigned bits
)
1601 gcc_assert (bits
<= TYPE_PRECISION (type
));
1603 return wide_int_to_tree (type
, wi::mask (bits
, false,
1604 TYPE_PRECISION (type
)));
1607 /* Checks that X is integer constant that can be expressed in (unsigned)
1608 HOST_WIDE_INT without loss of precision. */
1611 cst_and_fits_in_hwi (const_tree x
)
1613 if (TREE_CODE (x
) != INTEGER_CST
)
1616 if (TYPE_PRECISION (TREE_TYPE (x
)) > HOST_BITS_PER_WIDE_INT
)
1619 return TREE_INT_CST_NUNITS (x
) == 1;
1622 /* Build a newly constructed TREE_VEC node of length LEN. */
1625 make_vector_stat (unsigned len MEM_STAT_DECL
)
1628 unsigned length
= (len
- 1) * sizeof (tree
) + sizeof (struct tree_vector
);
1630 record_node_allocation_statistics (VECTOR_CST
, length
);
1632 t
= ggc_alloc_cleared_tree_node_stat (length PASS_MEM_STAT
);
1634 TREE_SET_CODE (t
, VECTOR_CST
);
1635 TREE_CONSTANT (t
) = 1;
1640 /* Return a new VECTOR_CST node whose type is TYPE and whose values
1641 are in a list pointed to by VALS. */
1644 build_vector_stat (tree type
, tree
*vals MEM_STAT_DECL
)
1648 tree v
= make_vector (TYPE_VECTOR_SUBPARTS (type
));
1649 TREE_TYPE (v
) = type
;
1651 /* Iterate through elements and check for overflow. */
1652 for (cnt
= 0; cnt
< TYPE_VECTOR_SUBPARTS (type
); ++cnt
)
1654 tree value
= vals
[cnt
];
1656 VECTOR_CST_ELT (v
, cnt
) = value
;
1658 /* Don't crash if we get an address constant. */
1659 if (!CONSTANT_CLASS_P (value
))
1662 over
|= TREE_OVERFLOW (value
);
1665 TREE_OVERFLOW (v
) = over
;
1669 /* Return a new VECTOR_CST node whose type is TYPE and whose values
1670 are extracted from V, a vector of CONSTRUCTOR_ELT. */
1673 build_vector_from_ctor (tree type
, vec
<constructor_elt
, va_gc
> *v
)
1675 tree
*vec
= XALLOCAVEC (tree
, TYPE_VECTOR_SUBPARTS (type
));
1676 unsigned HOST_WIDE_INT idx
;
1679 FOR_EACH_CONSTRUCTOR_VALUE (v
, idx
, value
)
1681 for (; idx
< TYPE_VECTOR_SUBPARTS (type
); ++idx
)
1682 vec
[idx
] = build_zero_cst (TREE_TYPE (type
));
1684 return build_vector (type
, vec
);
1687 /* Build a vector of type VECTYPE where all the elements are SCs. */
1689 build_vector_from_val (tree vectype
, tree sc
)
1691 int i
, nunits
= TYPE_VECTOR_SUBPARTS (vectype
);
1693 if (sc
== error_mark_node
)
1696 /* Verify that the vector type is suitable for SC. Note that there
1697 is some inconsistency in the type-system with respect to restrict
1698 qualifications of pointers. Vector types always have a main-variant
1699 element type and the qualification is applied to the vector-type.
1700 So TREE_TYPE (vector-type) does not return a properly qualified
1701 vector element-type. */
1702 gcc_checking_assert (types_compatible_p (TYPE_MAIN_VARIANT (TREE_TYPE (sc
)),
1703 TREE_TYPE (vectype
)));
1705 if (CONSTANT_CLASS_P (sc
))
1707 tree
*v
= XALLOCAVEC (tree
, nunits
);
1708 for (i
= 0; i
< nunits
; ++i
)
1710 return build_vector (vectype
, v
);
1714 vec
<constructor_elt
, va_gc
> *v
;
1715 vec_alloc (v
, nunits
);
1716 for (i
= 0; i
< nunits
; ++i
)
1717 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, sc
);
1718 return build_constructor (vectype
, v
);
1722 /* Return a new CONSTRUCTOR node whose type is TYPE and whose values
1723 are in the vec pointed to by VALS. */
1725 build_constructor (tree type
, vec
<constructor_elt
, va_gc
> *vals
)
1727 tree c
= make_node (CONSTRUCTOR
);
1729 constructor_elt
*elt
;
1730 bool constant_p
= true;
1731 bool side_effects_p
= false;
1733 TREE_TYPE (c
) = type
;
1734 CONSTRUCTOR_ELTS (c
) = vals
;
1736 FOR_EACH_VEC_SAFE_ELT (vals
, i
, elt
)
1738 /* Mostly ctors will have elts that don't have side-effects, so
1739 the usual case is to scan all the elements. Hence a single
1740 loop for both const and side effects, rather than one loop
1741 each (with early outs). */
1742 if (!TREE_CONSTANT (elt
->value
))
1744 if (TREE_SIDE_EFFECTS (elt
->value
))
1745 side_effects_p
= true;
1748 TREE_SIDE_EFFECTS (c
) = side_effects_p
;
1749 TREE_CONSTANT (c
) = constant_p
;
1754 /* Build a CONSTRUCTOR node made of a single initializer, with the specified
1757 build_constructor_single (tree type
, tree index
, tree value
)
1759 vec
<constructor_elt
, va_gc
> *v
;
1760 constructor_elt elt
= {index
, value
};
1763 v
->quick_push (elt
);
1765 return build_constructor (type
, v
);
1769 /* Return a new CONSTRUCTOR node whose type is TYPE and whose values
1770 are in a list pointed to by VALS. */
1772 build_constructor_from_list (tree type
, tree vals
)
1775 vec
<constructor_elt
, va_gc
> *v
= NULL
;
1779 vec_alloc (v
, list_length (vals
));
1780 for (t
= vals
; t
; t
= TREE_CHAIN (t
))
1781 CONSTRUCTOR_APPEND_ELT (v
, TREE_PURPOSE (t
), TREE_VALUE (t
));
1784 return build_constructor (type
, v
);
1787 /* Return a new CONSTRUCTOR node whose type is TYPE. NELTS is the number
1788 of elements, provided as index/value pairs. */
1791 build_constructor_va (tree type
, int nelts
, ...)
1793 vec
<constructor_elt
, va_gc
> *v
= NULL
;
1796 va_start (p
, nelts
);
1797 vec_alloc (v
, nelts
);
1800 tree index
= va_arg (p
, tree
);
1801 tree value
= va_arg (p
, tree
);
1802 CONSTRUCTOR_APPEND_ELT (v
, index
, value
);
1805 return build_constructor (type
, v
);
1808 /* Return a new FIXED_CST node whose type is TYPE and value is F. */
1811 build_fixed (tree type
, FIXED_VALUE_TYPE f
)
1814 FIXED_VALUE_TYPE
*fp
;
1816 v
= make_node (FIXED_CST
);
1817 fp
= ggc_alloc
<fixed_value
> ();
1818 memcpy (fp
, &f
, sizeof (FIXED_VALUE_TYPE
));
1820 TREE_TYPE (v
) = type
;
1821 TREE_FIXED_CST_PTR (v
) = fp
;
1825 /* Return a new REAL_CST node whose type is TYPE and value is D. */
1828 build_real (tree type
, REAL_VALUE_TYPE d
)
1831 REAL_VALUE_TYPE
*dp
;
1834 /* ??? Used to check for overflow here via CHECK_FLOAT_TYPE.
1835 Consider doing it via real_convert now. */
1837 v
= make_node (REAL_CST
);
1838 dp
= ggc_alloc
<real_value
> ();
1839 memcpy (dp
, &d
, sizeof (REAL_VALUE_TYPE
));
1841 TREE_TYPE (v
) = type
;
1842 TREE_REAL_CST_PTR (v
) = dp
;
1843 TREE_OVERFLOW (v
) = overflow
;
1847 /* Return a new REAL_CST node whose type is TYPE
1848 and whose value is the integer value of the INTEGER_CST node I. */
1851 real_value_from_int_cst (const_tree type
, const_tree i
)
1855 /* Clear all bits of the real value type so that we can later do
1856 bitwise comparisons to see if two values are the same. */
1857 memset (&d
, 0, sizeof d
);
1859 real_from_integer (&d
, type
? TYPE_MODE (type
) : VOIDmode
, i
,
1860 TYPE_SIGN (TREE_TYPE (i
)));
1864 /* Given a tree representing an integer constant I, return a tree
1865 representing the same value as a floating-point constant of type TYPE. */
1868 build_real_from_int_cst (tree type
, const_tree i
)
1871 int overflow
= TREE_OVERFLOW (i
);
1873 v
= build_real (type
, real_value_from_int_cst (type
, i
));
1875 TREE_OVERFLOW (v
) |= overflow
;
1879 /* Return a newly constructed STRING_CST node whose value is
1880 the LEN characters at STR.
1881 Note that for a C string literal, LEN should include the trailing NUL.
1882 The TREE_TYPE is not initialized. */
1885 build_string (int len
, const char *str
)
1890 /* Do not waste bytes provided by padding of struct tree_string. */
1891 length
= len
+ offsetof (struct tree_string
, str
) + 1;
1893 record_node_allocation_statistics (STRING_CST
, length
);
1895 s
= (tree
) ggc_internal_alloc (length
);
1897 memset (s
, 0, sizeof (struct tree_typed
));
1898 TREE_SET_CODE (s
, STRING_CST
);
1899 TREE_CONSTANT (s
) = 1;
1900 TREE_STRING_LENGTH (s
) = len
;
1901 memcpy (s
->string
.str
, str
, len
);
1902 s
->string
.str
[len
] = '\0';
1907 /* Return a newly constructed COMPLEX_CST node whose value is
1908 specified by the real and imaginary parts REAL and IMAG.
1909 Both REAL and IMAG should be constant nodes. TYPE, if specified,
1910 will be the type of the COMPLEX_CST; otherwise a new type will be made. */
1913 build_complex (tree type
, tree real
, tree imag
)
1915 tree t
= make_node (COMPLEX_CST
);
1917 TREE_REALPART (t
) = real
;
1918 TREE_IMAGPART (t
) = imag
;
1919 TREE_TYPE (t
) = type
? type
: build_complex_type (TREE_TYPE (real
));
1920 TREE_OVERFLOW (t
) = TREE_OVERFLOW (real
) | TREE_OVERFLOW (imag
);
1924 /* Return a constant of arithmetic type TYPE which is the
1925 multiplicative identity of the set TYPE. */
1928 build_one_cst (tree type
)
1930 switch (TREE_CODE (type
))
1932 case INTEGER_TYPE
: case ENUMERAL_TYPE
: case BOOLEAN_TYPE
:
1933 case POINTER_TYPE
: case REFERENCE_TYPE
:
1935 return build_int_cst (type
, 1);
1938 return build_real (type
, dconst1
);
1940 case FIXED_POINT_TYPE
:
1941 /* We can only generate 1 for accum types. */
1942 gcc_assert (ALL_SCALAR_ACCUM_MODE_P (TYPE_MODE (type
)));
1943 return build_fixed (type
, FCONST1 (TYPE_MODE (type
)));
1947 tree scalar
= build_one_cst (TREE_TYPE (type
));
1949 return build_vector_from_val (type
, scalar
);
1953 return build_complex (type
,
1954 build_one_cst (TREE_TYPE (type
)),
1955 build_zero_cst (TREE_TYPE (type
)));
1962 /* Return an integer of type TYPE containing all 1's in as much precision as
1963 it contains, or a complex or vector whose subparts are such integers. */
1966 build_all_ones_cst (tree type
)
1968 if (TREE_CODE (type
) == COMPLEX_TYPE
)
1970 tree scalar
= build_all_ones_cst (TREE_TYPE (type
));
1971 return build_complex (type
, scalar
, scalar
);
1974 return build_minus_one_cst (type
);
1977 /* Return a constant of arithmetic type TYPE which is the
1978 opposite of the multiplicative identity of the set TYPE. */
1981 build_minus_one_cst (tree type
)
1983 switch (TREE_CODE (type
))
1985 case INTEGER_TYPE
: case ENUMERAL_TYPE
: case BOOLEAN_TYPE
:
1986 case POINTER_TYPE
: case REFERENCE_TYPE
:
1988 return build_int_cst (type
, -1);
1991 return build_real (type
, dconstm1
);
1993 case FIXED_POINT_TYPE
:
1994 /* We can only generate 1 for accum types. */
1995 gcc_assert (ALL_SCALAR_ACCUM_MODE_P (TYPE_MODE (type
)));
1996 return build_fixed (type
, fixed_from_double_int (double_int_minus_one
,
2001 tree scalar
= build_minus_one_cst (TREE_TYPE (type
));
2003 return build_vector_from_val (type
, scalar
);
2007 return build_complex (type
,
2008 build_minus_one_cst (TREE_TYPE (type
)),
2009 build_zero_cst (TREE_TYPE (type
)));
2016 /* Build 0 constant of type TYPE. This is used by constructor folding
2017 and thus the constant should be represented in memory by
2021 build_zero_cst (tree type
)
2023 switch (TREE_CODE (type
))
2025 case INTEGER_TYPE
: case ENUMERAL_TYPE
: case BOOLEAN_TYPE
:
2026 case POINTER_TYPE
: case REFERENCE_TYPE
:
2027 case OFFSET_TYPE
: case NULLPTR_TYPE
:
2028 return build_int_cst (type
, 0);
2031 return build_real (type
, dconst0
);
2033 case FIXED_POINT_TYPE
:
2034 return build_fixed (type
, FCONST0 (TYPE_MODE (type
)));
2038 tree scalar
= build_zero_cst (TREE_TYPE (type
));
2040 return build_vector_from_val (type
, scalar
);
2045 tree zero
= build_zero_cst (TREE_TYPE (type
));
2047 return build_complex (type
, zero
, zero
);
2051 if (!AGGREGATE_TYPE_P (type
))
2052 return fold_convert (type
, integer_zero_node
);
2053 return build_constructor (type
, NULL
);
2058 /* Build a BINFO with LEN language slots. */
2061 make_tree_binfo_stat (unsigned base_binfos MEM_STAT_DECL
)
2064 size_t length
= (offsetof (struct tree_binfo
, base_binfos
)
2065 + vec
<tree
, va_gc
>::embedded_size (base_binfos
));
2067 record_node_allocation_statistics (TREE_BINFO
, length
);
2069 t
= ggc_alloc_tree_node_stat (length PASS_MEM_STAT
);
2071 memset (t
, 0, offsetof (struct tree_binfo
, base_binfos
));
2073 TREE_SET_CODE (t
, TREE_BINFO
);
2075 BINFO_BASE_BINFOS (t
)->embedded_init (base_binfos
);
2080 /* Create a CASE_LABEL_EXPR tree node and return it. */
2083 build_case_label (tree low_value
, tree high_value
, tree label_decl
)
2085 tree t
= make_node (CASE_LABEL_EXPR
);
2087 TREE_TYPE (t
) = void_type_node
;
2088 SET_EXPR_LOCATION (t
, DECL_SOURCE_LOCATION (label_decl
));
2090 CASE_LOW (t
) = low_value
;
2091 CASE_HIGH (t
) = high_value
;
2092 CASE_LABEL (t
) = label_decl
;
2093 CASE_CHAIN (t
) = NULL_TREE
;
2098 /* Build a newly constructed INTEGER_CST node. LEN and EXT_LEN are the
2099 values of TREE_INT_CST_NUNITS and TREE_INT_CST_EXT_NUNITS respectively.
2100 The latter determines the length of the HOST_WIDE_INT vector. */
2103 make_int_cst_stat (int len
, int ext_len MEM_STAT_DECL
)
2106 int length
= ((ext_len
- 1) * sizeof (HOST_WIDE_INT
)
2107 + sizeof (struct tree_int_cst
));
2110 record_node_allocation_statistics (INTEGER_CST
, length
);
2112 t
= ggc_alloc_cleared_tree_node_stat (length PASS_MEM_STAT
);
2114 TREE_SET_CODE (t
, INTEGER_CST
);
2115 TREE_INT_CST_NUNITS (t
) = len
;
2116 TREE_INT_CST_EXT_NUNITS (t
) = ext_len
;
2117 /* to_offset can only be applied to trees that are offset_int-sized
2118 or smaller. EXT_LEN is correct if it fits, otherwise the constant
2119 must be exactly the precision of offset_int and so LEN is correct. */
2120 if (ext_len
<= OFFSET_INT_ELTS
)
2121 TREE_INT_CST_OFFSET_NUNITS (t
) = ext_len
;
2123 TREE_INT_CST_OFFSET_NUNITS (t
) = len
;
2125 TREE_CONSTANT (t
) = 1;
2130 /* Build a newly constructed TREE_VEC node of length LEN. */
2133 make_tree_vec_stat (int len MEM_STAT_DECL
)
2136 int length
= (len
- 1) * sizeof (tree
) + sizeof (struct tree_vec
);
2138 record_node_allocation_statistics (TREE_VEC
, length
);
2140 t
= ggc_alloc_cleared_tree_node_stat (length PASS_MEM_STAT
);
2142 TREE_SET_CODE (t
, TREE_VEC
);
2143 TREE_VEC_LENGTH (t
) = len
;
2148 /* Grow a TREE_VEC node to new length LEN. */
2151 grow_tree_vec_stat (tree v
, int len MEM_STAT_DECL
)
2153 gcc_assert (TREE_CODE (v
) == TREE_VEC
);
2155 int oldlen
= TREE_VEC_LENGTH (v
);
2156 gcc_assert (len
> oldlen
);
2158 int oldlength
= (oldlen
- 1) * sizeof (tree
) + sizeof (struct tree_vec
);
2159 int length
= (len
- 1) * sizeof (tree
) + sizeof (struct tree_vec
);
2161 record_node_allocation_statistics (TREE_VEC
, length
- oldlength
);
2163 v
= (tree
) ggc_realloc (v
, length PASS_MEM_STAT
);
2165 TREE_VEC_LENGTH (v
) = len
;
2170 /* Return 1 if EXPR is the integer constant zero or a complex constant
2174 integer_zerop (const_tree expr
)
2178 switch (TREE_CODE (expr
))
2181 return wi::eq_p (expr
, 0);
2183 return (integer_zerop (TREE_REALPART (expr
))
2184 && integer_zerop (TREE_IMAGPART (expr
)));
2188 for (i
= 0; i
< VECTOR_CST_NELTS (expr
); ++i
)
2189 if (!integer_zerop (VECTOR_CST_ELT (expr
, i
)))
2198 /* Return 1 if EXPR is the integer constant one or the corresponding
2199 complex constant. */
2202 integer_onep (const_tree expr
)
2206 switch (TREE_CODE (expr
))
2209 return wi::eq_p (wi::to_widest (expr
), 1);
2211 return (integer_onep (TREE_REALPART (expr
))
2212 && integer_zerop (TREE_IMAGPART (expr
)));
2216 for (i
= 0; i
< VECTOR_CST_NELTS (expr
); ++i
)
2217 if (!integer_onep (VECTOR_CST_ELT (expr
, i
)))
2226 /* Return 1 if EXPR is the integer constant one. For complex and vector,
2227 return 1 if every piece is the integer constant one. */
2230 integer_each_onep (const_tree expr
)
2234 if (TREE_CODE (expr
) == COMPLEX_CST
)
2235 return (integer_onep (TREE_REALPART (expr
))
2236 && integer_onep (TREE_IMAGPART (expr
)));
2238 return integer_onep (expr
);
2241 /* Return 1 if EXPR is an integer containing all 1's in as much precision as
2242 it contains, or a complex or vector whose subparts are such integers. */
2245 integer_all_onesp (const_tree expr
)
2249 if (TREE_CODE (expr
) == COMPLEX_CST
2250 && integer_all_onesp (TREE_REALPART (expr
))
2251 && integer_all_onesp (TREE_IMAGPART (expr
)))
2254 else if (TREE_CODE (expr
) == VECTOR_CST
)
2257 for (i
= 0; i
< VECTOR_CST_NELTS (expr
); ++i
)
2258 if (!integer_all_onesp (VECTOR_CST_ELT (expr
, i
)))
2263 else if (TREE_CODE (expr
) != INTEGER_CST
)
2266 return wi::max_value (TYPE_PRECISION (TREE_TYPE (expr
)), UNSIGNED
) == expr
;
2269 /* Return 1 if EXPR is the integer constant minus one. */
2272 integer_minus_onep (const_tree expr
)
2276 if (TREE_CODE (expr
) == COMPLEX_CST
)
2277 return (integer_all_onesp (TREE_REALPART (expr
))
2278 && integer_zerop (TREE_IMAGPART (expr
)));
2280 return integer_all_onesp (expr
);
2283 /* Return 1 if EXPR is an integer constant that is a power of 2 (i.e., has only
2287 integer_pow2p (const_tree expr
)
2291 if (TREE_CODE (expr
) == COMPLEX_CST
2292 && integer_pow2p (TREE_REALPART (expr
))
2293 && integer_zerop (TREE_IMAGPART (expr
)))
2296 if (TREE_CODE (expr
) != INTEGER_CST
)
2299 return wi::popcount (expr
) == 1;
2302 /* Return 1 if EXPR is an integer constant other than zero or a
2303 complex constant other than zero. */
2306 integer_nonzerop (const_tree expr
)
2310 return ((TREE_CODE (expr
) == INTEGER_CST
2311 && !wi::eq_p (expr
, 0))
2312 || (TREE_CODE (expr
) == COMPLEX_CST
2313 && (integer_nonzerop (TREE_REALPART (expr
))
2314 || integer_nonzerop (TREE_IMAGPART (expr
)))));
2317 /* Return 1 if EXPR is the integer constant one. For vector,
2318 return 1 if every piece is the integer constant minus one
2319 (representing the value TRUE). */
2322 integer_truep (const_tree expr
)
2326 if (TREE_CODE (expr
) == VECTOR_CST
)
2327 return integer_all_onesp (expr
);
2328 return integer_onep (expr
);
2331 /* Return 1 if EXPR is the fixed-point constant zero. */
2334 fixed_zerop (const_tree expr
)
2336 return (TREE_CODE (expr
) == FIXED_CST
2337 && TREE_FIXED_CST (expr
).data
.is_zero ());
2340 /* Return the power of two represented by a tree node known to be a
2344 tree_log2 (const_tree expr
)
2348 if (TREE_CODE (expr
) == COMPLEX_CST
)
2349 return tree_log2 (TREE_REALPART (expr
));
2351 return wi::exact_log2 (expr
);
2354 /* Similar, but return the largest integer Y such that 2 ** Y is less
2355 than or equal to EXPR. */
2358 tree_floor_log2 (const_tree expr
)
2362 if (TREE_CODE (expr
) == COMPLEX_CST
)
2363 return tree_log2 (TREE_REALPART (expr
));
2365 return wi::floor_log2 (expr
);
2368 /* Return number of known trailing zero bits in EXPR, or, if the value of
2369 EXPR is known to be zero, the precision of it's type. */
2372 tree_ctz (const_tree expr
)
2374 if (!INTEGRAL_TYPE_P (TREE_TYPE (expr
))
2375 && !POINTER_TYPE_P (TREE_TYPE (expr
)))
2378 unsigned int ret1
, ret2
, prec
= TYPE_PRECISION (TREE_TYPE (expr
));
2379 switch (TREE_CODE (expr
))
2382 ret1
= wi::ctz (expr
);
2383 return MIN (ret1
, prec
);
2385 ret1
= wi::ctz (get_nonzero_bits (expr
));
2386 return MIN (ret1
, prec
);
2393 ret1
= tree_ctz (TREE_OPERAND (expr
, 0));
2396 ret2
= tree_ctz (TREE_OPERAND (expr
, 1));
2397 return MIN (ret1
, ret2
);
2398 case POINTER_PLUS_EXPR
:
2399 ret1
= tree_ctz (TREE_OPERAND (expr
, 0));
2400 ret2
= tree_ctz (TREE_OPERAND (expr
, 1));
2401 /* Second operand is sizetype, which could be in theory
2402 wider than pointer's precision. Make sure we never
2403 return more than prec. */
2404 ret2
= MIN (ret2
, prec
);
2405 return MIN (ret1
, ret2
);
2407 ret1
= tree_ctz (TREE_OPERAND (expr
, 0));
2408 ret2
= tree_ctz (TREE_OPERAND (expr
, 1));
2409 return MAX (ret1
, ret2
);
2411 ret1
= tree_ctz (TREE_OPERAND (expr
, 0));
2412 ret2
= tree_ctz (TREE_OPERAND (expr
, 1));
2413 return MIN (ret1
+ ret2
, prec
);
2415 ret1
= tree_ctz (TREE_OPERAND (expr
, 0));
2416 if (tree_fits_uhwi_p (TREE_OPERAND (expr
, 1))
2417 && (tree_to_uhwi (TREE_OPERAND (expr
, 1)) < prec
))
2419 ret2
= tree_to_uhwi (TREE_OPERAND (expr
, 1));
2420 return MIN (ret1
+ ret2
, prec
);
2424 if (tree_fits_uhwi_p (TREE_OPERAND (expr
, 1))
2425 && (tree_to_uhwi (TREE_OPERAND (expr
, 1)) < prec
))
2427 ret1
= tree_ctz (TREE_OPERAND (expr
, 0));
2428 ret2
= tree_to_uhwi (TREE_OPERAND (expr
, 1));
2433 case TRUNC_DIV_EXPR
:
2435 case FLOOR_DIV_EXPR
:
2436 case ROUND_DIV_EXPR
:
2437 case EXACT_DIV_EXPR
:
2438 if (TREE_CODE (TREE_OPERAND (expr
, 1)) == INTEGER_CST
2439 && tree_int_cst_sgn (TREE_OPERAND (expr
, 1)) == 1)
2441 int l
= tree_log2 (TREE_OPERAND (expr
, 1));
2444 ret1
= tree_ctz (TREE_OPERAND (expr
, 0));
2452 ret1
= tree_ctz (TREE_OPERAND (expr
, 0));
2453 if (ret1
&& ret1
== TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (expr
, 0))))
2455 return MIN (ret1
, prec
);
2457 return tree_ctz (TREE_OPERAND (expr
, 0));
2459 ret1
= tree_ctz (TREE_OPERAND (expr
, 1));
2462 ret2
= tree_ctz (TREE_OPERAND (expr
, 2));
2463 return MIN (ret1
, ret2
);
2465 return tree_ctz (TREE_OPERAND (expr
, 1));
2467 ret1
= get_pointer_alignment (CONST_CAST_TREE (expr
));
2468 if (ret1
> BITS_PER_UNIT
)
2470 ret1
= ctz_hwi (ret1
/ BITS_PER_UNIT
);
2471 return MIN (ret1
, prec
);
2479 /* Return 1 if EXPR is the real constant zero. Trailing zeroes matter for
2480 decimal float constants, so don't return 1 for them. */
2483 real_zerop (const_tree expr
)
2487 switch (TREE_CODE (expr
))
2490 return REAL_VALUES_EQUAL (TREE_REAL_CST (expr
), dconst0
)
2491 && !(DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (expr
))));
2493 return real_zerop (TREE_REALPART (expr
))
2494 && real_zerop (TREE_IMAGPART (expr
));
2498 for (i
= 0; i
< VECTOR_CST_NELTS (expr
); ++i
)
2499 if (!real_zerop (VECTOR_CST_ELT (expr
, i
)))
2508 /* Return 1 if EXPR is the real constant one in real or complex form.
2509 Trailing zeroes matter for decimal float constants, so don't return
2513 real_onep (const_tree expr
)
2517 switch (TREE_CODE (expr
))
2520 return REAL_VALUES_EQUAL (TREE_REAL_CST (expr
), dconst1
)
2521 && !(DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (expr
))));
2523 return real_onep (TREE_REALPART (expr
))
2524 && real_zerop (TREE_IMAGPART (expr
));
2528 for (i
= 0; i
< VECTOR_CST_NELTS (expr
); ++i
)
2529 if (!real_onep (VECTOR_CST_ELT (expr
, i
)))
2538 /* Return 1 if EXPR is the real constant minus one. Trailing zeroes
2539 matter for decimal float constants, so don't return 1 for them. */
2542 real_minus_onep (const_tree expr
)
2546 switch (TREE_CODE (expr
))
2549 return REAL_VALUES_EQUAL (TREE_REAL_CST (expr
), dconstm1
)
2550 && !(DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (expr
))));
2552 return real_minus_onep (TREE_REALPART (expr
))
2553 && real_zerop (TREE_IMAGPART (expr
));
2557 for (i
= 0; i
< VECTOR_CST_NELTS (expr
); ++i
)
2558 if (!real_minus_onep (VECTOR_CST_ELT (expr
, i
)))
2567 /* Nonzero if EXP is a constant or a cast of a constant. */
2570 really_constant_p (const_tree exp
)
2572 /* This is not quite the same as STRIP_NOPS. It does more. */
2573 while (CONVERT_EXPR_P (exp
)
2574 || TREE_CODE (exp
) == NON_LVALUE_EXPR
)
2575 exp
= TREE_OPERAND (exp
, 0);
2576 return TREE_CONSTANT (exp
);
2579 /* Return first list element whose TREE_VALUE is ELEM.
2580 Return 0 if ELEM is not in LIST. */
2583 value_member (tree elem
, tree list
)
2587 if (elem
== TREE_VALUE (list
))
2589 list
= TREE_CHAIN (list
);
2594 /* Return first list element whose TREE_PURPOSE is ELEM.
2595 Return 0 if ELEM is not in LIST. */
2598 purpose_member (const_tree elem
, tree list
)
2602 if (elem
== TREE_PURPOSE (list
))
2604 list
= TREE_CHAIN (list
);
2609 /* Return true if ELEM is in V. */
2612 vec_member (const_tree elem
, vec
<tree
, va_gc
> *v
)
2616 FOR_EACH_VEC_SAFE_ELT (v
, ix
, t
)
2622 /* Returns element number IDX (zero-origin) of chain CHAIN, or
2626 chain_index (int idx
, tree chain
)
2628 for (; chain
&& idx
> 0; --idx
)
2629 chain
= TREE_CHAIN (chain
);
2633 /* Return nonzero if ELEM is part of the chain CHAIN. */
2636 chain_member (const_tree elem
, const_tree chain
)
2642 chain
= DECL_CHAIN (chain
);
2648 /* Return the length of a chain of nodes chained through TREE_CHAIN.
2649 We expect a null pointer to mark the end of the chain.
2650 This is the Lisp primitive `length'. */
2653 list_length (const_tree t
)
2656 #ifdef ENABLE_TREE_CHECKING
2664 #ifdef ENABLE_TREE_CHECKING
2667 gcc_assert (p
!= q
);
2675 /* Returns the first FIELD_DECL in the TYPE_FIELDS of the RECORD_TYPE or
2676 UNION_TYPE TYPE, or NULL_TREE if none. */
2679 first_field (const_tree type
)
2681 tree t
= TYPE_FIELDS (type
);
2682 while (t
&& TREE_CODE (t
) != FIELD_DECL
)
2687 /* Concatenate two chains of nodes (chained through TREE_CHAIN)
2688 by modifying the last node in chain 1 to point to chain 2.
2689 This is the Lisp primitive `nconc'. */
2692 chainon (tree op1
, tree op2
)
2701 for (t1
= op1
; TREE_CHAIN (t1
); t1
= TREE_CHAIN (t1
))
2703 TREE_CHAIN (t1
) = op2
;
2705 #ifdef ENABLE_TREE_CHECKING
2708 for (t2
= op2
; t2
; t2
= TREE_CHAIN (t2
))
2709 gcc_assert (t2
!= t1
);
2716 /* Return the last node in a chain of nodes (chained through TREE_CHAIN). */
2719 tree_last (tree chain
)
2723 while ((next
= TREE_CHAIN (chain
)))
2728 /* Reverse the order of elements in the chain T,
2729 and return the new head of the chain (old last element). */
2734 tree prev
= 0, decl
, next
;
2735 for (decl
= t
; decl
; decl
= next
)
2737 /* We shouldn't be using this function to reverse BLOCK chains; we
2738 have blocks_nreverse for that. */
2739 gcc_checking_assert (TREE_CODE (decl
) != BLOCK
);
2740 next
= TREE_CHAIN (decl
);
2741 TREE_CHAIN (decl
) = prev
;
2747 /* Return a newly created TREE_LIST node whose
2748 purpose and value fields are PARM and VALUE. */
2751 build_tree_list_stat (tree parm
, tree value MEM_STAT_DECL
)
2753 tree t
= make_node_stat (TREE_LIST PASS_MEM_STAT
);
2754 TREE_PURPOSE (t
) = parm
;
2755 TREE_VALUE (t
) = value
;
2759 /* Build a chain of TREE_LIST nodes from a vector. */
2762 build_tree_list_vec_stat (const vec
<tree
, va_gc
> *vec MEM_STAT_DECL
)
2764 tree ret
= NULL_TREE
;
2768 FOR_EACH_VEC_SAFE_ELT (vec
, i
, t
)
2770 *pp
= build_tree_list_stat (NULL
, t PASS_MEM_STAT
);
2771 pp
= &TREE_CHAIN (*pp
);
2776 /* Return a newly created TREE_LIST node whose
2777 purpose and value fields are PURPOSE and VALUE
2778 and whose TREE_CHAIN is CHAIN. */
2781 tree_cons_stat (tree purpose
, tree value
, tree chain MEM_STAT_DECL
)
2785 node
= ggc_alloc_tree_node_stat (sizeof (struct tree_list
) PASS_MEM_STAT
);
2786 memset (node
, 0, sizeof (struct tree_common
));
2788 record_node_allocation_statistics (TREE_LIST
, sizeof (struct tree_list
));
2790 TREE_SET_CODE (node
, TREE_LIST
);
2791 TREE_CHAIN (node
) = chain
;
2792 TREE_PURPOSE (node
) = purpose
;
2793 TREE_VALUE (node
) = value
;
2797 /* Return the values of the elements of a CONSTRUCTOR as a vector of
2801 ctor_to_vec (tree ctor
)
2803 vec
<tree
, va_gc
> *vec
;
2804 vec_alloc (vec
, CONSTRUCTOR_NELTS (ctor
));
2808 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (ctor
), ix
, val
)
2809 vec
->quick_push (val
);
2814 /* Return the size nominally occupied by an object of type TYPE
2815 when it resides in memory. The value is measured in units of bytes,
2816 and its data type is that normally used for type sizes
2817 (which is the first type created by make_signed_type or
2818 make_unsigned_type). */
2821 size_in_bytes (const_tree type
)
2825 if (type
== error_mark_node
)
2826 return integer_zero_node
;
2828 type
= TYPE_MAIN_VARIANT (type
);
2829 t
= TYPE_SIZE_UNIT (type
);
2833 lang_hooks
.types
.incomplete_type_error (NULL_TREE
, type
);
2834 return size_zero_node
;
2840 /* Return the size of TYPE (in bytes) as a wide integer
2841 or return -1 if the size can vary or is larger than an integer. */
2844 int_size_in_bytes (const_tree type
)
2848 if (type
== error_mark_node
)
2851 type
= TYPE_MAIN_VARIANT (type
);
2852 t
= TYPE_SIZE_UNIT (type
);
2854 if (t
&& tree_fits_uhwi_p (t
))
2855 return TREE_INT_CST_LOW (t
);
2860 /* Return the maximum size of TYPE (in bytes) as a wide integer
2861 or return -1 if the size can vary or is larger than an integer. */
2864 max_int_size_in_bytes (const_tree type
)
2866 HOST_WIDE_INT size
= -1;
2869 /* If this is an array type, check for a possible MAX_SIZE attached. */
2871 if (TREE_CODE (type
) == ARRAY_TYPE
)
2873 size_tree
= TYPE_ARRAY_MAX_SIZE (type
);
2875 if (size_tree
&& tree_fits_uhwi_p (size_tree
))
2876 size
= tree_to_uhwi (size_tree
);
2879 /* If we still haven't been able to get a size, see if the language
2880 can compute a maximum size. */
2884 size_tree
= lang_hooks
.types
.max_size (type
);
2886 if (size_tree
&& tree_fits_uhwi_p (size_tree
))
2887 size
= tree_to_uhwi (size_tree
);
2893 /* Return the bit position of FIELD, in bits from the start of the record.
2894 This is a tree of type bitsizetype. */
2897 bit_position (const_tree field
)
2899 return bit_from_pos (DECL_FIELD_OFFSET (field
),
2900 DECL_FIELD_BIT_OFFSET (field
));
2903 /* Return the byte position of FIELD, in bytes from the start of the record.
2904 This is a tree of type sizetype. */
2907 byte_position (const_tree field
)
2909 return byte_from_pos (DECL_FIELD_OFFSET (field
),
2910 DECL_FIELD_BIT_OFFSET (field
));
2913 /* Likewise, but return as an integer. It must be representable in
2914 that way (since it could be a signed value, we don't have the
2915 option of returning -1 like int_size_in_byte can. */
2918 int_byte_position (const_tree field
)
2920 return tree_to_shwi (byte_position (field
));
2923 /* Return the strictest alignment, in bits, that T is known to have. */
2926 expr_align (const_tree t
)
2928 unsigned int align0
, align1
;
2930 switch (TREE_CODE (t
))
2932 CASE_CONVERT
: case NON_LVALUE_EXPR
:
2933 /* If we have conversions, we know that the alignment of the
2934 object must meet each of the alignments of the types. */
2935 align0
= expr_align (TREE_OPERAND (t
, 0));
2936 align1
= TYPE_ALIGN (TREE_TYPE (t
));
2937 return MAX (align0
, align1
);
2939 case SAVE_EXPR
: case COMPOUND_EXPR
: case MODIFY_EXPR
:
2940 case INIT_EXPR
: case TARGET_EXPR
: case WITH_CLEANUP_EXPR
:
2941 case CLEANUP_POINT_EXPR
:
2942 /* These don't change the alignment of an object. */
2943 return expr_align (TREE_OPERAND (t
, 0));
2946 /* The best we can do is say that the alignment is the least aligned
2948 align0
= expr_align (TREE_OPERAND (t
, 1));
2949 align1
= expr_align (TREE_OPERAND (t
, 2));
2950 return MIN (align0
, align1
);
2952 /* FIXME: LABEL_DECL and CONST_DECL never have DECL_ALIGN set
2953 meaningfully, it's always 1. */
2954 case LABEL_DECL
: case CONST_DECL
:
2955 case VAR_DECL
: case PARM_DECL
: case RESULT_DECL
:
2957 gcc_assert (DECL_ALIGN (t
) != 0);
2958 return DECL_ALIGN (t
);
2964 /* Otherwise take the alignment from that of the type. */
2965 return TYPE_ALIGN (TREE_TYPE (t
));
2968 /* Return, as a tree node, the number of elements for TYPE (which is an
2969 ARRAY_TYPE) minus one. This counts only elements of the top array. */
2972 array_type_nelts (const_tree type
)
2974 tree index_type
, min
, max
;
2976 /* If they did it with unspecified bounds, then we should have already
2977 given an error about it before we got here. */
2978 if (! TYPE_DOMAIN (type
))
2979 return error_mark_node
;
2981 index_type
= TYPE_DOMAIN (type
);
2982 min
= TYPE_MIN_VALUE (index_type
);
2983 max
= TYPE_MAX_VALUE (index_type
);
2985 /* TYPE_MAX_VALUE may not be set if the array has unknown length. */
2987 return error_mark_node
;
2989 return (integer_zerop (min
)
2991 : fold_build2 (MINUS_EXPR
, TREE_TYPE (max
), max
, min
));
2994 /* If arg is static -- a reference to an object in static storage -- then
2995 return the object. This is not the same as the C meaning of `static'.
2996 If arg isn't static, return NULL. */
3001 switch (TREE_CODE (arg
))
3004 /* Nested functions are static, even though taking their address will
3005 involve a trampoline as we unnest the nested function and create
3006 the trampoline on the tree level. */
3010 return ((TREE_STATIC (arg
) || DECL_EXTERNAL (arg
))
3011 && ! DECL_THREAD_LOCAL_P (arg
)
3012 && ! DECL_DLLIMPORT_P (arg
)
3016 return ((TREE_STATIC (arg
) || DECL_EXTERNAL (arg
))
3020 return TREE_STATIC (arg
) ? arg
: NULL
;
3027 /* If the thing being referenced is not a field, then it is
3028 something language specific. */
3029 gcc_assert (TREE_CODE (TREE_OPERAND (arg
, 1)) == FIELD_DECL
);
3031 /* If we are referencing a bitfield, we can't evaluate an
3032 ADDR_EXPR at compile time and so it isn't a constant. */
3033 if (DECL_BIT_FIELD (TREE_OPERAND (arg
, 1)))
3036 return staticp (TREE_OPERAND (arg
, 0));
3042 return TREE_CONSTANT (TREE_OPERAND (arg
, 0)) ? arg
: NULL
;
3045 case ARRAY_RANGE_REF
:
3046 if (TREE_CODE (TYPE_SIZE (TREE_TYPE (arg
))) == INTEGER_CST
3047 && TREE_CODE (TREE_OPERAND (arg
, 1)) == INTEGER_CST
)
3048 return staticp (TREE_OPERAND (arg
, 0));
3052 case COMPOUND_LITERAL_EXPR
:
3053 return TREE_STATIC (COMPOUND_LITERAL_EXPR_DECL (arg
)) ? arg
: NULL
;
3063 /* Return whether OP is a DECL whose address is function-invariant. */
3066 decl_address_invariant_p (const_tree op
)
3068 /* The conditions below are slightly less strict than the one in
3071 switch (TREE_CODE (op
))
3080 if ((TREE_STATIC (op
) || DECL_EXTERNAL (op
))
3081 || DECL_THREAD_LOCAL_P (op
)
3082 || DECL_CONTEXT (op
) == current_function_decl
3083 || decl_function_context (op
) == current_function_decl
)
3088 if ((TREE_STATIC (op
) || DECL_EXTERNAL (op
))
3089 || decl_function_context (op
) == current_function_decl
)
3100 /* Return whether OP is a DECL whose address is interprocedural-invariant. */
3103 decl_address_ip_invariant_p (const_tree op
)
3105 /* The conditions below are slightly less strict than the one in
3108 switch (TREE_CODE (op
))
3116 if (((TREE_STATIC (op
) || DECL_EXTERNAL (op
))
3117 && !DECL_DLLIMPORT_P (op
))
3118 || DECL_THREAD_LOCAL_P (op
))
3123 if ((TREE_STATIC (op
) || DECL_EXTERNAL (op
)))
3135 /* Return true if T is function-invariant (internal function, does
3136 not handle arithmetic; that's handled in skip_simple_arithmetic and
3137 tree_invariant_p). */
3139 static bool tree_invariant_p (tree t
);
3142 tree_invariant_p_1 (tree t
)
3146 if (TREE_CONSTANT (t
)
3147 || (TREE_READONLY (t
) && !TREE_SIDE_EFFECTS (t
)))
3150 switch (TREE_CODE (t
))
3156 op
= TREE_OPERAND (t
, 0);
3157 while (handled_component_p (op
))
3159 switch (TREE_CODE (op
))
3162 case ARRAY_RANGE_REF
:
3163 if (!tree_invariant_p (TREE_OPERAND (op
, 1))
3164 || TREE_OPERAND (op
, 2) != NULL_TREE
3165 || TREE_OPERAND (op
, 3) != NULL_TREE
)
3170 if (TREE_OPERAND (op
, 2) != NULL_TREE
)
3176 op
= TREE_OPERAND (op
, 0);
3179 return CONSTANT_CLASS_P (op
) || decl_address_invariant_p (op
);
3188 /* Return true if T is function-invariant. */
3191 tree_invariant_p (tree t
)
3193 tree inner
= skip_simple_arithmetic (t
);
3194 return tree_invariant_p_1 (inner
);
3197 /* Wrap a SAVE_EXPR around EXPR, if appropriate.
3198 Do this to any expression which may be used in more than one place,
3199 but must be evaluated only once.
3201 Normally, expand_expr would reevaluate the expression each time.
3202 Calling save_expr produces something that is evaluated and recorded
3203 the first time expand_expr is called on it. Subsequent calls to
3204 expand_expr just reuse the recorded value.
3206 The call to expand_expr that generates code that actually computes
3207 the value is the first call *at compile time*. Subsequent calls
3208 *at compile time* generate code to use the saved value.
3209 This produces correct result provided that *at run time* control
3210 always flows through the insns made by the first expand_expr
3211 before reaching the other places where the save_expr was evaluated.
3212 You, the caller of save_expr, must make sure this is so.
3214 Constants, and certain read-only nodes, are returned with no
3215 SAVE_EXPR because that is safe. Expressions containing placeholders
3216 are not touched; see tree.def for an explanation of what these
3220 save_expr (tree expr
)
3222 tree t
= fold (expr
);
3225 /* If the tree evaluates to a constant, then we don't want to hide that
3226 fact (i.e. this allows further folding, and direct checks for constants).
3227 However, a read-only object that has side effects cannot be bypassed.
3228 Since it is no problem to reevaluate literals, we just return the
3230 inner
= skip_simple_arithmetic (t
);
3231 if (TREE_CODE (inner
) == ERROR_MARK
)
3234 if (tree_invariant_p_1 (inner
))
3237 /* If INNER contains a PLACEHOLDER_EXPR, we must evaluate it each time, since
3238 it means that the size or offset of some field of an object depends on
3239 the value within another field.
3241 Note that it must not be the case that T contains both a PLACEHOLDER_EXPR
3242 and some variable since it would then need to be both evaluated once and
3243 evaluated more than once. Front-ends must assure this case cannot
3244 happen by surrounding any such subexpressions in their own SAVE_EXPR
3245 and forcing evaluation at the proper time. */
3246 if (contains_placeholder_p (inner
))
3249 t
= build1 (SAVE_EXPR
, TREE_TYPE (expr
), t
);
3250 SET_EXPR_LOCATION (t
, EXPR_LOCATION (expr
));
3252 /* This expression might be placed ahead of a jump to ensure that the
3253 value was computed on both sides of the jump. So make sure it isn't
3254 eliminated as dead. */
3255 TREE_SIDE_EFFECTS (t
) = 1;
3259 /* Look inside EXPR into any simple arithmetic operations. Return the
3260 outermost non-arithmetic or non-invariant node. */
3263 skip_simple_arithmetic (tree expr
)
3265 /* We don't care about whether this can be used as an lvalue in this
3267 while (TREE_CODE (expr
) == NON_LVALUE_EXPR
)
3268 expr
= TREE_OPERAND (expr
, 0);
3270 /* If we have simple operations applied to a SAVE_EXPR or to a SAVE_EXPR and
3271 a constant, it will be more efficient to not make another SAVE_EXPR since
3272 it will allow better simplification and GCSE will be able to merge the
3273 computations if they actually occur. */
3276 if (UNARY_CLASS_P (expr
))
3277 expr
= TREE_OPERAND (expr
, 0);
3278 else if (BINARY_CLASS_P (expr
))
3280 if (tree_invariant_p (TREE_OPERAND (expr
, 1)))
3281 expr
= TREE_OPERAND (expr
, 0);
3282 else if (tree_invariant_p (TREE_OPERAND (expr
, 0)))
3283 expr
= TREE_OPERAND (expr
, 1);
3294 /* Look inside EXPR into simple arithmetic operations involving constants.
3295 Return the outermost non-arithmetic or non-constant node. */
3298 skip_simple_constant_arithmetic (tree expr
)
3300 while (TREE_CODE (expr
) == NON_LVALUE_EXPR
)
3301 expr
= TREE_OPERAND (expr
, 0);
3305 if (UNARY_CLASS_P (expr
))
3306 expr
= TREE_OPERAND (expr
, 0);
3307 else if (BINARY_CLASS_P (expr
))
3309 if (TREE_CONSTANT (TREE_OPERAND (expr
, 1)))
3310 expr
= TREE_OPERAND (expr
, 0);
3311 else if (TREE_CONSTANT (TREE_OPERAND (expr
, 0)))
3312 expr
= TREE_OPERAND (expr
, 1);
3323 /* Return which tree structure is used by T. */
3325 enum tree_node_structure_enum
3326 tree_node_structure (const_tree t
)
3328 const enum tree_code code
= TREE_CODE (t
);
3329 return tree_node_structure_for_code (code
);
3332 /* Set various status flags when building a CALL_EXPR object T. */
3335 process_call_operands (tree t
)
3337 bool side_effects
= TREE_SIDE_EFFECTS (t
);
3338 bool read_only
= false;
3339 int i
= call_expr_flags (t
);
3341 /* Calls have side-effects, except those to const or pure functions. */
3342 if ((i
& ECF_LOOPING_CONST_OR_PURE
) || !(i
& (ECF_CONST
| ECF_PURE
)))
3343 side_effects
= true;
3344 /* Propagate TREE_READONLY of arguments for const functions. */
3348 if (!side_effects
|| read_only
)
3349 for (i
= 1; i
< TREE_OPERAND_LENGTH (t
); i
++)
3351 tree op
= TREE_OPERAND (t
, i
);
3352 if (op
&& TREE_SIDE_EFFECTS (op
))
3353 side_effects
= true;
3354 if (op
&& !TREE_READONLY (op
) && !CONSTANT_CLASS_P (op
))
3358 TREE_SIDE_EFFECTS (t
) = side_effects
;
3359 TREE_READONLY (t
) = read_only
;
3362 /* Return true if EXP contains a PLACEHOLDER_EXPR, i.e. if it represents a
3363 size or offset that depends on a field within a record. */
3366 contains_placeholder_p (const_tree exp
)
3368 enum tree_code code
;
3373 code
= TREE_CODE (exp
);
3374 if (code
== PLACEHOLDER_EXPR
)
3377 switch (TREE_CODE_CLASS (code
))
3380 /* Don't look at any PLACEHOLDER_EXPRs that might be in index or bit
3381 position computations since they will be converted into a
3382 WITH_RECORD_EXPR involving the reference, which will assume
3383 here will be valid. */
3384 return CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp
, 0));
3386 case tcc_exceptional
:
3387 if (code
== TREE_LIST
)
3388 return (CONTAINS_PLACEHOLDER_P (TREE_VALUE (exp
))
3389 || CONTAINS_PLACEHOLDER_P (TREE_CHAIN (exp
)));
3394 case tcc_comparison
:
3395 case tcc_expression
:
3399 /* Ignoring the first operand isn't quite right, but works best. */
3400 return CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp
, 1));
3403 return (CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp
, 0))
3404 || CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp
, 1))
3405 || CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp
, 2)));
3408 /* The save_expr function never wraps anything containing
3409 a PLACEHOLDER_EXPR. */
3416 switch (TREE_CODE_LENGTH (code
))
3419 return CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp
, 0));
3421 return (CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp
, 0))
3422 || CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp
, 1)));
3433 const_call_expr_arg_iterator iter
;
3434 FOR_EACH_CONST_CALL_EXPR_ARG (arg
, iter
, exp
)
3435 if (CONTAINS_PLACEHOLDER_P (arg
))
3449 /* Return true if any part of the structure of TYPE involves a PLACEHOLDER_EXPR
3450 directly. This includes size, bounds, qualifiers (for QUAL_UNION_TYPE) and
3454 type_contains_placeholder_1 (const_tree type
)
3456 /* If the size contains a placeholder or the parent type (component type in
3457 the case of arrays) type involves a placeholder, this type does. */
3458 if (CONTAINS_PLACEHOLDER_P (TYPE_SIZE (type
))
3459 || CONTAINS_PLACEHOLDER_P (TYPE_SIZE_UNIT (type
))
3460 || (!POINTER_TYPE_P (type
)
3462 && type_contains_placeholder_p (TREE_TYPE (type
))))
3465 /* Now do type-specific checks. Note that the last part of the check above
3466 greatly limits what we have to do below. */
3467 switch (TREE_CODE (type
))
3470 case POINTER_BOUNDS_TYPE
:
3476 case REFERENCE_TYPE
:
3485 case FIXED_POINT_TYPE
:
3486 /* Here we just check the bounds. */
3487 return (CONTAINS_PLACEHOLDER_P (TYPE_MIN_VALUE (type
))
3488 || CONTAINS_PLACEHOLDER_P (TYPE_MAX_VALUE (type
)));
3491 /* We have already checked the component type above, so just check the
3493 return type_contains_placeholder_p (TYPE_DOMAIN (type
));
3497 case QUAL_UNION_TYPE
:
3501 for (field
= TYPE_FIELDS (type
); field
; field
= DECL_CHAIN (field
))
3502 if (TREE_CODE (field
) == FIELD_DECL
3503 && (CONTAINS_PLACEHOLDER_P (DECL_FIELD_OFFSET (field
))
3504 || (TREE_CODE (type
) == QUAL_UNION_TYPE
3505 && CONTAINS_PLACEHOLDER_P (DECL_QUALIFIER (field
)))
3506 || type_contains_placeholder_p (TREE_TYPE (field
))))
3517 /* Wrapper around above function used to cache its result. */
3520 type_contains_placeholder_p (tree type
)
3524 /* If the contains_placeholder_bits field has been initialized,
3525 then we know the answer. */
3526 if (TYPE_CONTAINS_PLACEHOLDER_INTERNAL (type
) > 0)
3527 return TYPE_CONTAINS_PLACEHOLDER_INTERNAL (type
) - 1;
3529 /* Indicate that we've seen this type node, and the answer is false.
3530 This is what we want to return if we run into recursion via fields. */
3531 TYPE_CONTAINS_PLACEHOLDER_INTERNAL (type
) = 1;
3533 /* Compute the real value. */
3534 result
= type_contains_placeholder_1 (type
);
3536 /* Store the real value. */
3537 TYPE_CONTAINS_PLACEHOLDER_INTERNAL (type
) = result
+ 1;
3542 /* Push tree EXP onto vector QUEUE if it is not already present. */
3545 push_without_duplicates (tree exp
, vec
<tree
> *queue
)
3550 FOR_EACH_VEC_ELT (*queue
, i
, iter
)
3551 if (simple_cst_equal (iter
, exp
) == 1)
3555 queue
->safe_push (exp
);
3558 /* Given a tree EXP, find all occurrences of references to fields
3559 in a PLACEHOLDER_EXPR and place them in vector REFS without
3560 duplicates. Also record VAR_DECLs and CONST_DECLs. Note that
3561 we assume here that EXP contains only arithmetic expressions
3562 or CALL_EXPRs with PLACEHOLDER_EXPRs occurring only in their
3566 find_placeholder_in_expr (tree exp
, vec
<tree
> *refs
)
3568 enum tree_code code
= TREE_CODE (exp
);
3572 /* We handle TREE_LIST and COMPONENT_REF separately. */
3573 if (code
== TREE_LIST
)
3575 FIND_PLACEHOLDER_IN_EXPR (TREE_CHAIN (exp
), refs
);
3576 FIND_PLACEHOLDER_IN_EXPR (TREE_VALUE (exp
), refs
);
3578 else if (code
== COMPONENT_REF
)
3580 for (inner
= TREE_OPERAND (exp
, 0);
3581 REFERENCE_CLASS_P (inner
);
3582 inner
= TREE_OPERAND (inner
, 0))
3585 if (TREE_CODE (inner
) == PLACEHOLDER_EXPR
)
3586 push_without_duplicates (exp
, refs
);
3588 FIND_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp
, 0), refs
);
3591 switch (TREE_CODE_CLASS (code
))
3596 case tcc_declaration
:
3597 /* Variables allocated to static storage can stay. */
3598 if (!TREE_STATIC (exp
))
3599 push_without_duplicates (exp
, refs
);
3602 case tcc_expression
:
3603 /* This is the pattern built in ada/make_aligning_type. */
3604 if (code
== ADDR_EXPR
3605 && TREE_CODE (TREE_OPERAND (exp
, 0)) == PLACEHOLDER_EXPR
)
3607 push_without_duplicates (exp
, refs
);
3611 /* Fall through... */
3613 case tcc_exceptional
:
3616 case tcc_comparison
:
3618 for (i
= 0; i
< TREE_CODE_LENGTH (code
); i
++)
3619 FIND_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp
, i
), refs
);
3623 for (i
= 1; i
< TREE_OPERAND_LENGTH (exp
); i
++)
3624 FIND_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp
, i
), refs
);
3632 /* Given a tree EXP, a FIELD_DECL F, and a replacement value R,
3633 return a tree with all occurrences of references to F in a
3634 PLACEHOLDER_EXPR replaced by R. Also handle VAR_DECLs and
3635 CONST_DECLs. Note that we assume here that EXP contains only
3636 arithmetic expressions or CALL_EXPRs with PLACEHOLDER_EXPRs
3637 occurring only in their argument list. */
3640 substitute_in_expr (tree exp
, tree f
, tree r
)
3642 enum tree_code code
= TREE_CODE (exp
);
3643 tree op0
, op1
, op2
, op3
;
3646 /* We handle TREE_LIST and COMPONENT_REF separately. */
3647 if (code
== TREE_LIST
)
3649 op0
= SUBSTITUTE_IN_EXPR (TREE_CHAIN (exp
), f
, r
);
3650 op1
= SUBSTITUTE_IN_EXPR (TREE_VALUE (exp
), f
, r
);
3651 if (op0
== TREE_CHAIN (exp
) && op1
== TREE_VALUE (exp
))
3654 return tree_cons (TREE_PURPOSE (exp
), op1
, op0
);
3656 else if (code
== COMPONENT_REF
)
3660 /* If this expression is getting a value from a PLACEHOLDER_EXPR
3661 and it is the right field, replace it with R. */
3662 for (inner
= TREE_OPERAND (exp
, 0);
3663 REFERENCE_CLASS_P (inner
);
3664 inner
= TREE_OPERAND (inner
, 0))
3668 op1
= TREE_OPERAND (exp
, 1);
3670 if (TREE_CODE (inner
) == PLACEHOLDER_EXPR
&& op1
== f
)
3673 /* If this expression hasn't been completed let, leave it alone. */
3674 if (TREE_CODE (inner
) == PLACEHOLDER_EXPR
&& !TREE_TYPE (inner
))
3677 op0
= SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp
, 0), f
, r
);
3678 if (op0
== TREE_OPERAND (exp
, 0))
3682 = fold_build3 (COMPONENT_REF
, TREE_TYPE (exp
), op0
, op1
, NULL_TREE
);
3685 switch (TREE_CODE_CLASS (code
))
3690 case tcc_declaration
:
3696 case tcc_expression
:
3700 /* Fall through... */
3702 case tcc_exceptional
:
3705 case tcc_comparison
:
3707 switch (TREE_CODE_LENGTH (code
))
3713 op0
= SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp
, 0), f
, r
);
3714 if (op0
== TREE_OPERAND (exp
, 0))
3717 new_tree
= fold_build1 (code
, TREE_TYPE (exp
), op0
);
3721 op0
= SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp
, 0), f
, r
);
3722 op1
= SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp
, 1), f
, r
);
3724 if (op0
== TREE_OPERAND (exp
, 0) && op1
== TREE_OPERAND (exp
, 1))
3727 new_tree
= fold_build2 (code
, TREE_TYPE (exp
), op0
, op1
);
3731 op0
= SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp
, 0), f
, r
);
3732 op1
= SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp
, 1), f
, r
);
3733 op2
= SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp
, 2), f
, r
);
3735 if (op0
== TREE_OPERAND (exp
, 0) && op1
== TREE_OPERAND (exp
, 1)
3736 && op2
== TREE_OPERAND (exp
, 2))
3739 new_tree
= fold_build3 (code
, TREE_TYPE (exp
), op0
, op1
, op2
);
3743 op0
= SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp
, 0), f
, r
);
3744 op1
= SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp
, 1), f
, r
);
3745 op2
= SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp
, 2), f
, r
);
3746 op3
= SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp
, 3), f
, r
);
3748 if (op0
== TREE_OPERAND (exp
, 0) && op1
== TREE_OPERAND (exp
, 1)
3749 && op2
== TREE_OPERAND (exp
, 2)
3750 && op3
== TREE_OPERAND (exp
, 3))
3754 = fold (build4 (code
, TREE_TYPE (exp
), op0
, op1
, op2
, op3
));
3766 new_tree
= NULL_TREE
;
3768 /* If we are trying to replace F with a constant, inline back
3769 functions which do nothing else than computing a value from
3770 the arguments they are passed. This makes it possible to
3771 fold partially or entirely the replacement expression. */
3772 if (CONSTANT_CLASS_P (r
) && code
== CALL_EXPR
)
3774 tree t
= maybe_inline_call_in_expr (exp
);
3776 return SUBSTITUTE_IN_EXPR (t
, f
, r
);
3779 for (i
= 1; i
< TREE_OPERAND_LENGTH (exp
); i
++)
3781 tree op
= TREE_OPERAND (exp
, i
);
3782 tree new_op
= SUBSTITUTE_IN_EXPR (op
, f
, r
);
3786 new_tree
= copy_node (exp
);
3787 TREE_OPERAND (new_tree
, i
) = new_op
;
3793 new_tree
= fold (new_tree
);
3794 if (TREE_CODE (new_tree
) == CALL_EXPR
)
3795 process_call_operands (new_tree
);
3806 TREE_READONLY (new_tree
) |= TREE_READONLY (exp
);
3808 if (code
== INDIRECT_REF
|| code
== ARRAY_REF
|| code
== ARRAY_RANGE_REF
)
3809 TREE_THIS_NOTRAP (new_tree
) |= TREE_THIS_NOTRAP (exp
);
3814 /* Similar, but look for a PLACEHOLDER_EXPR in EXP and find a replacement
3815 for it within OBJ, a tree that is an object or a chain of references. */
3818 substitute_placeholder_in_expr (tree exp
, tree obj
)
3820 enum tree_code code
= TREE_CODE (exp
);
3821 tree op0
, op1
, op2
, op3
;
3824 /* If this is a PLACEHOLDER_EXPR, see if we find a corresponding type
3825 in the chain of OBJ. */
3826 if (code
== PLACEHOLDER_EXPR
)
3828 tree need_type
= TYPE_MAIN_VARIANT (TREE_TYPE (exp
));
3831 for (elt
= obj
; elt
!= 0;
3832 elt
= ((TREE_CODE (elt
) == COMPOUND_EXPR
3833 || TREE_CODE (elt
) == COND_EXPR
)
3834 ? TREE_OPERAND (elt
, 1)
3835 : (REFERENCE_CLASS_P (elt
)
3836 || UNARY_CLASS_P (elt
)
3837 || BINARY_CLASS_P (elt
)
3838 || VL_EXP_CLASS_P (elt
)
3839 || EXPRESSION_CLASS_P (elt
))
3840 ? TREE_OPERAND (elt
, 0) : 0))
3841 if (TYPE_MAIN_VARIANT (TREE_TYPE (elt
)) == need_type
)
3844 for (elt
= obj
; elt
!= 0;
3845 elt
= ((TREE_CODE (elt
) == COMPOUND_EXPR
3846 || TREE_CODE (elt
) == COND_EXPR
)
3847 ? TREE_OPERAND (elt
, 1)
3848 : (REFERENCE_CLASS_P (elt
)
3849 || UNARY_CLASS_P (elt
)
3850 || BINARY_CLASS_P (elt
)
3851 || VL_EXP_CLASS_P (elt
)
3852 || EXPRESSION_CLASS_P (elt
))
3853 ? TREE_OPERAND (elt
, 0) : 0))
3854 if (POINTER_TYPE_P (TREE_TYPE (elt
))
3855 && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (elt
)))
3857 return fold_build1 (INDIRECT_REF
, need_type
, elt
);
3859 /* If we didn't find it, return the original PLACEHOLDER_EXPR. If it
3860 survives until RTL generation, there will be an error. */
3864 /* TREE_LIST is special because we need to look at TREE_VALUE
3865 and TREE_CHAIN, not TREE_OPERANDS. */
3866 else if (code
== TREE_LIST
)
3868 op0
= SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_CHAIN (exp
), obj
);
3869 op1
= SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_VALUE (exp
), obj
);
3870 if (op0
== TREE_CHAIN (exp
) && op1
== TREE_VALUE (exp
))
3873 return tree_cons (TREE_PURPOSE (exp
), op1
, op0
);
3876 switch (TREE_CODE_CLASS (code
))
3879 case tcc_declaration
:
3882 case tcc_exceptional
:
3885 case tcc_comparison
:
3886 case tcc_expression
:
3889 switch (TREE_CODE_LENGTH (code
))
3895 op0
= SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp
, 0), obj
);
3896 if (op0
== TREE_OPERAND (exp
, 0))
3899 new_tree
= fold_build1 (code
, TREE_TYPE (exp
), op0
);
3903 op0
= SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp
, 0), obj
);
3904 op1
= SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp
, 1), obj
);
3906 if (op0
== TREE_OPERAND (exp
, 0) && op1
== TREE_OPERAND (exp
, 1))
3909 new_tree
= fold_build2 (code
, TREE_TYPE (exp
), op0
, op1
);
3913 op0
= SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp
, 0), obj
);
3914 op1
= SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp
, 1), obj
);
3915 op2
= SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp
, 2), obj
);
3917 if (op0
== TREE_OPERAND (exp
, 0) && op1
== TREE_OPERAND (exp
, 1)
3918 && op2
== TREE_OPERAND (exp
, 2))
3921 new_tree
= fold_build3 (code
, TREE_TYPE (exp
), op0
, op1
, op2
);
3925 op0
= SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp
, 0), obj
);
3926 op1
= SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp
, 1), obj
);
3927 op2
= SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp
, 2), obj
);
3928 op3
= SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp
, 3), obj
);
3930 if (op0
== TREE_OPERAND (exp
, 0) && op1
== TREE_OPERAND (exp
, 1)
3931 && op2
== TREE_OPERAND (exp
, 2)
3932 && op3
== TREE_OPERAND (exp
, 3))
3936 = fold (build4 (code
, TREE_TYPE (exp
), op0
, op1
, op2
, op3
));
3948 new_tree
= NULL_TREE
;
3950 for (i
= 1; i
< TREE_OPERAND_LENGTH (exp
); i
++)
3952 tree op
= TREE_OPERAND (exp
, i
);
3953 tree new_op
= SUBSTITUTE_PLACEHOLDER_IN_EXPR (op
, obj
);
3957 new_tree
= copy_node (exp
);
3958 TREE_OPERAND (new_tree
, i
) = new_op
;
3964 new_tree
= fold (new_tree
);
3965 if (TREE_CODE (new_tree
) == CALL_EXPR
)
3966 process_call_operands (new_tree
);
3977 TREE_READONLY (new_tree
) |= TREE_READONLY (exp
);
3979 if (code
== INDIRECT_REF
|| code
== ARRAY_REF
|| code
== ARRAY_RANGE_REF
)
3980 TREE_THIS_NOTRAP (new_tree
) |= TREE_THIS_NOTRAP (exp
);
3986 /* Subroutine of stabilize_reference; this is called for subtrees of
3987 references. Any expression with side-effects must be put in a SAVE_EXPR
3988 to ensure that it is only evaluated once.
3990 We don't put SAVE_EXPR nodes around everything, because assigning very
3991 simple expressions to temporaries causes us to miss good opportunities
3992 for optimizations. Among other things, the opportunity to fold in the
3993 addition of a constant into an addressing mode often gets lost, e.g.
3994 "y[i+1] += x;". In general, we take the approach that we should not make
3995 an assignment unless we are forced into it - i.e., that any non-side effect
3996 operator should be allowed, and that cse should take care of coalescing
3997 multiple utterances of the same expression should that prove fruitful. */
4000 stabilize_reference_1 (tree e
)
4003 enum tree_code code
= TREE_CODE (e
);
4005 /* We cannot ignore const expressions because it might be a reference
4006 to a const array but whose index contains side-effects. But we can
4007 ignore things that are actual constant or that already have been
4008 handled by this function. */
4010 if (tree_invariant_p (e
))
4013 switch (TREE_CODE_CLASS (code
))
4015 case tcc_exceptional
:
4017 case tcc_declaration
:
4018 case tcc_comparison
:
4020 case tcc_expression
:
4023 /* If the expression has side-effects, then encase it in a SAVE_EXPR
4024 so that it will only be evaluated once. */
4025 /* The reference (r) and comparison (<) classes could be handled as
4026 below, but it is generally faster to only evaluate them once. */
4027 if (TREE_SIDE_EFFECTS (e
))
4028 return save_expr (e
);
4032 /* Constants need no processing. In fact, we should never reach
4037 /* Division is slow and tends to be compiled with jumps,
4038 especially the division by powers of 2 that is often
4039 found inside of an array reference. So do it just once. */
4040 if (code
== TRUNC_DIV_EXPR
|| code
== TRUNC_MOD_EXPR
4041 || code
== FLOOR_DIV_EXPR
|| code
== FLOOR_MOD_EXPR
4042 || code
== CEIL_DIV_EXPR
|| code
== CEIL_MOD_EXPR
4043 || code
== ROUND_DIV_EXPR
|| code
== ROUND_MOD_EXPR
)
4044 return save_expr (e
);
4045 /* Recursively stabilize each operand. */
4046 result
= build_nt (code
, stabilize_reference_1 (TREE_OPERAND (e
, 0)),
4047 stabilize_reference_1 (TREE_OPERAND (e
, 1)));
4051 /* Recursively stabilize each operand. */
4052 result
= build_nt (code
, stabilize_reference_1 (TREE_OPERAND (e
, 0)));
4059 TREE_TYPE (result
) = TREE_TYPE (e
);
4060 TREE_READONLY (result
) = TREE_READONLY (e
);
4061 TREE_SIDE_EFFECTS (result
) = TREE_SIDE_EFFECTS (e
);
4062 TREE_THIS_VOLATILE (result
) = TREE_THIS_VOLATILE (e
);
4067 /* Stabilize a reference so that we can use it any number of times
4068 without causing its operands to be evaluated more than once.
4069 Returns the stabilized reference. This works by means of save_expr,
4070 so see the caveats in the comments about save_expr.
4072 Also allows conversion expressions whose operands are references.
4073 Any other kind of expression is returned unchanged. */
4076 stabilize_reference (tree ref
)
4079 enum tree_code code
= TREE_CODE (ref
);
4086 /* No action is needed in this case. */
4091 case FIX_TRUNC_EXPR
:
4092 result
= build_nt (code
, stabilize_reference (TREE_OPERAND (ref
, 0)));
4096 result
= build_nt (INDIRECT_REF
,
4097 stabilize_reference_1 (TREE_OPERAND (ref
, 0)));
4101 result
= build_nt (COMPONENT_REF
,
4102 stabilize_reference (TREE_OPERAND (ref
, 0)),
4103 TREE_OPERAND (ref
, 1), NULL_TREE
);
4107 result
= build_nt (BIT_FIELD_REF
,
4108 stabilize_reference (TREE_OPERAND (ref
, 0)),
4109 TREE_OPERAND (ref
, 1), TREE_OPERAND (ref
, 2));
4113 result
= build_nt (ARRAY_REF
,
4114 stabilize_reference (TREE_OPERAND (ref
, 0)),
4115 stabilize_reference_1 (TREE_OPERAND (ref
, 1)),
4116 TREE_OPERAND (ref
, 2), TREE_OPERAND (ref
, 3));
4119 case ARRAY_RANGE_REF
:
4120 result
= build_nt (ARRAY_RANGE_REF
,
4121 stabilize_reference (TREE_OPERAND (ref
, 0)),
4122 stabilize_reference_1 (TREE_OPERAND (ref
, 1)),
4123 TREE_OPERAND (ref
, 2), TREE_OPERAND (ref
, 3));
4127 /* We cannot wrap the first expression in a SAVE_EXPR, as then
4128 it wouldn't be ignored. This matters when dealing with
4130 return stabilize_reference_1 (ref
);
4132 /* If arg isn't a kind of lvalue we recognize, make no change.
4133 Caller should recognize the error for an invalid lvalue. */
4138 return error_mark_node
;
4141 TREE_TYPE (result
) = TREE_TYPE (ref
);
4142 TREE_READONLY (result
) = TREE_READONLY (ref
);
4143 TREE_SIDE_EFFECTS (result
) = TREE_SIDE_EFFECTS (ref
);
4144 TREE_THIS_VOLATILE (result
) = TREE_THIS_VOLATILE (ref
);
4149 /* Low-level constructors for expressions. */
4151 /* A helper function for build1 and constant folders. Set TREE_CONSTANT,
4152 and TREE_SIDE_EFFECTS for an ADDR_EXPR. */
4155 recompute_tree_invariant_for_addr_expr (tree t
)
4158 bool tc
= true, se
= false;
4160 /* We started out assuming this address is both invariant and constant, but
4161 does not have side effects. Now go down any handled components and see if
4162 any of them involve offsets that are either non-constant or non-invariant.
4163 Also check for side-effects.
4165 ??? Note that this code makes no attempt to deal with the case where
4166 taking the address of something causes a copy due to misalignment. */
4168 #define UPDATE_FLAGS(NODE) \
4169 do { tree _node = (NODE); \
4170 if (_node && !TREE_CONSTANT (_node)) tc = false; \
4171 if (_node && TREE_SIDE_EFFECTS (_node)) se = true; } while (0)
4173 for (node
= TREE_OPERAND (t
, 0); handled_component_p (node
);
4174 node
= TREE_OPERAND (node
, 0))
4176 /* If the first operand doesn't have an ARRAY_TYPE, this is a bogus
4177 array reference (probably made temporarily by the G++ front end),
4178 so ignore all the operands. */
4179 if ((TREE_CODE (node
) == ARRAY_REF
4180 || TREE_CODE (node
) == ARRAY_RANGE_REF
)
4181 && TREE_CODE (TREE_TYPE (TREE_OPERAND (node
, 0))) == ARRAY_TYPE
)
4183 UPDATE_FLAGS (TREE_OPERAND (node
, 1));
4184 if (TREE_OPERAND (node
, 2))
4185 UPDATE_FLAGS (TREE_OPERAND (node
, 2));
4186 if (TREE_OPERAND (node
, 3))
4187 UPDATE_FLAGS (TREE_OPERAND (node
, 3));
4189 /* Likewise, just because this is a COMPONENT_REF doesn't mean we have a
4190 FIELD_DECL, apparently. The G++ front end can put something else
4191 there, at least temporarily. */
4192 else if (TREE_CODE (node
) == COMPONENT_REF
4193 && TREE_CODE (TREE_OPERAND (node
, 1)) == FIELD_DECL
)
4195 if (TREE_OPERAND (node
, 2))
4196 UPDATE_FLAGS (TREE_OPERAND (node
, 2));
4200 node
= lang_hooks
.expr_to_decl (node
, &tc
, &se
);
4202 /* Now see what's inside. If it's an INDIRECT_REF, copy our properties from
4203 the address, since &(*a)->b is a form of addition. If it's a constant, the
4204 address is constant too. If it's a decl, its address is constant if the
4205 decl is static. Everything else is not constant and, furthermore,
4206 taking the address of a volatile variable is not volatile. */
4207 if (TREE_CODE (node
) == INDIRECT_REF
4208 || TREE_CODE (node
) == MEM_REF
)
4209 UPDATE_FLAGS (TREE_OPERAND (node
, 0));
4210 else if (CONSTANT_CLASS_P (node
))
4212 else if (DECL_P (node
))
4213 tc
&= (staticp (node
) != NULL_TREE
);
4217 se
|= TREE_SIDE_EFFECTS (node
);
4221 TREE_CONSTANT (t
) = tc
;
4222 TREE_SIDE_EFFECTS (t
) = se
;
4226 /* Build an expression of code CODE, data type TYPE, and operands as
4227 specified. Expressions and reference nodes can be created this way.
4228 Constants, decls, types and misc nodes cannot be.
4230 We define 5 non-variadic functions, from 0 to 4 arguments. This is
4231 enough for all extant tree codes. */
4234 build0_stat (enum tree_code code
, tree tt MEM_STAT_DECL
)
4238 gcc_assert (TREE_CODE_LENGTH (code
) == 0);
4240 t
= make_node_stat (code PASS_MEM_STAT
);
4247 build1_stat (enum tree_code code
, tree type
, tree node MEM_STAT_DECL
)
4249 int length
= sizeof (struct tree_exp
);
4252 record_node_allocation_statistics (code
, length
);
4254 gcc_assert (TREE_CODE_LENGTH (code
) == 1);
4256 t
= ggc_alloc_tree_node_stat (length PASS_MEM_STAT
);
4258 memset (t
, 0, sizeof (struct tree_common
));
4260 TREE_SET_CODE (t
, code
);
4262 TREE_TYPE (t
) = type
;
4263 SET_EXPR_LOCATION (t
, UNKNOWN_LOCATION
);
4264 TREE_OPERAND (t
, 0) = node
;
4265 if (node
&& !TYPE_P (node
))
4267 TREE_SIDE_EFFECTS (t
) = TREE_SIDE_EFFECTS (node
);
4268 TREE_READONLY (t
) = TREE_READONLY (node
);
4271 if (TREE_CODE_CLASS (code
) == tcc_statement
)
4272 TREE_SIDE_EFFECTS (t
) = 1;
4276 /* All of these have side-effects, no matter what their
4278 TREE_SIDE_EFFECTS (t
) = 1;
4279 TREE_READONLY (t
) = 0;
4283 /* Whether a dereference is readonly has nothing to do with whether
4284 its operand is readonly. */
4285 TREE_READONLY (t
) = 0;
4290 recompute_tree_invariant_for_addr_expr (t
);
4294 if ((TREE_CODE_CLASS (code
) == tcc_unary
|| code
== VIEW_CONVERT_EXPR
)
4295 && node
&& !TYPE_P (node
)
4296 && TREE_CONSTANT (node
))
4297 TREE_CONSTANT (t
) = 1;
4298 if (TREE_CODE_CLASS (code
) == tcc_reference
4299 && node
&& TREE_THIS_VOLATILE (node
))
4300 TREE_THIS_VOLATILE (t
) = 1;
4307 #define PROCESS_ARG(N) \
4309 TREE_OPERAND (t, N) = arg##N; \
4310 if (arg##N &&!TYPE_P (arg##N)) \
4312 if (TREE_SIDE_EFFECTS (arg##N)) \
4314 if (!TREE_READONLY (arg##N) \
4315 && !CONSTANT_CLASS_P (arg##N)) \
4316 (void) (read_only = 0); \
4317 if (!TREE_CONSTANT (arg##N)) \
4318 (void) (constant = 0); \
4323 build2_stat (enum tree_code code
, tree tt
, tree arg0
, tree arg1 MEM_STAT_DECL
)
4325 bool constant
, read_only
, side_effects
;
4328 gcc_assert (TREE_CODE_LENGTH (code
) == 2);
4330 if ((code
== MINUS_EXPR
|| code
== PLUS_EXPR
|| code
== MULT_EXPR
)
4331 && arg0
&& arg1
&& tt
&& POINTER_TYPE_P (tt
)
4332 /* When sizetype precision doesn't match that of pointers
4333 we need to be able to build explicit extensions or truncations
4334 of the offset argument. */
4335 && TYPE_PRECISION (sizetype
) == TYPE_PRECISION (tt
))
4336 gcc_assert (TREE_CODE (arg0
) == INTEGER_CST
4337 && TREE_CODE (arg1
) == INTEGER_CST
);
4339 if (code
== POINTER_PLUS_EXPR
&& arg0
&& arg1
&& tt
)
4340 gcc_assert (POINTER_TYPE_P (tt
) && POINTER_TYPE_P (TREE_TYPE (arg0
))
4341 && ptrofftype_p (TREE_TYPE (arg1
)));
4343 t
= make_node_stat (code PASS_MEM_STAT
);
4346 /* Below, we automatically set TREE_SIDE_EFFECTS and TREE_READONLY for the
4347 result based on those same flags for the arguments. But if the
4348 arguments aren't really even `tree' expressions, we shouldn't be trying
4351 /* Expressions without side effects may be constant if their
4352 arguments are as well. */
4353 constant
= (TREE_CODE_CLASS (code
) == tcc_comparison
4354 || TREE_CODE_CLASS (code
) == tcc_binary
);
4356 side_effects
= TREE_SIDE_EFFECTS (t
);
4361 TREE_READONLY (t
) = read_only
;
4362 TREE_CONSTANT (t
) = constant
;
4363 TREE_SIDE_EFFECTS (t
) = side_effects
;
4364 TREE_THIS_VOLATILE (t
)
4365 = (TREE_CODE_CLASS (code
) == tcc_reference
4366 && arg0
&& TREE_THIS_VOLATILE (arg0
));
4373 build3_stat (enum tree_code code
, tree tt
, tree arg0
, tree arg1
,
4374 tree arg2 MEM_STAT_DECL
)
4376 bool constant
, read_only
, side_effects
;
4379 gcc_assert (TREE_CODE_LENGTH (code
) == 3);
4380 gcc_assert (TREE_CODE_CLASS (code
) != tcc_vl_exp
);
4382 t
= make_node_stat (code PASS_MEM_STAT
);
4387 /* As a special exception, if COND_EXPR has NULL branches, we
4388 assume that it is a gimple statement and always consider
4389 it to have side effects. */
4390 if (code
== COND_EXPR
4391 && tt
== void_type_node
4392 && arg1
== NULL_TREE
4393 && arg2
== NULL_TREE
)
4394 side_effects
= true;
4396 side_effects
= TREE_SIDE_EFFECTS (t
);
4402 if (code
== COND_EXPR
)
4403 TREE_READONLY (t
) = read_only
;
4405 TREE_SIDE_EFFECTS (t
) = side_effects
;
4406 TREE_THIS_VOLATILE (t
)
4407 = (TREE_CODE_CLASS (code
) == tcc_reference
4408 && arg0
&& TREE_THIS_VOLATILE (arg0
));
4414 build4_stat (enum tree_code code
, tree tt
, tree arg0
, tree arg1
,
4415 tree arg2
, tree arg3 MEM_STAT_DECL
)
4417 bool constant
, read_only
, side_effects
;
4420 gcc_assert (TREE_CODE_LENGTH (code
) == 4);
4422 t
= make_node_stat (code PASS_MEM_STAT
);
4425 side_effects
= TREE_SIDE_EFFECTS (t
);
4432 TREE_SIDE_EFFECTS (t
) = side_effects
;
4433 TREE_THIS_VOLATILE (t
)
4434 = (TREE_CODE_CLASS (code
) == tcc_reference
4435 && arg0
&& TREE_THIS_VOLATILE (arg0
));
4441 build5_stat (enum tree_code code
, tree tt
, tree arg0
, tree arg1
,
4442 tree arg2
, tree arg3
, tree arg4 MEM_STAT_DECL
)
4444 bool constant
, read_only
, side_effects
;
4447 gcc_assert (TREE_CODE_LENGTH (code
) == 5);
4449 t
= make_node_stat (code PASS_MEM_STAT
);
4452 side_effects
= TREE_SIDE_EFFECTS (t
);
4460 TREE_SIDE_EFFECTS (t
) = side_effects
;
4461 TREE_THIS_VOLATILE (t
)
4462 = (TREE_CODE_CLASS (code
) == tcc_reference
4463 && arg0
&& TREE_THIS_VOLATILE (arg0
));
4468 /* Build a simple MEM_REF tree with the sematics of a plain INDIRECT_REF
4469 on the pointer PTR. */
4472 build_simple_mem_ref_loc (location_t loc
, tree ptr
)
4474 HOST_WIDE_INT offset
= 0;
4475 tree ptype
= TREE_TYPE (ptr
);
4477 /* For convenience allow addresses that collapse to a simple base
4479 if (TREE_CODE (ptr
) == ADDR_EXPR
4480 && (handled_component_p (TREE_OPERAND (ptr
, 0))
4481 || TREE_CODE (TREE_OPERAND (ptr
, 0)) == MEM_REF
))
4483 ptr
= get_addr_base_and_unit_offset (TREE_OPERAND (ptr
, 0), &offset
);
4485 ptr
= build_fold_addr_expr (ptr
);
4486 gcc_assert (is_gimple_reg (ptr
) || is_gimple_min_invariant (ptr
));
4488 tem
= build2 (MEM_REF
, TREE_TYPE (ptype
),
4489 ptr
, build_int_cst (ptype
, offset
));
4490 SET_EXPR_LOCATION (tem
, loc
);
4494 /* Return the constant offset of a MEM_REF or TARGET_MEM_REF tree T. */
4497 mem_ref_offset (const_tree t
)
4499 return offset_int::from (TREE_OPERAND (t
, 1), SIGNED
);
4502 /* Return an invariant ADDR_EXPR of type TYPE taking the address of BASE
4503 offsetted by OFFSET units. */
4506 build_invariant_address (tree type
, tree base
, HOST_WIDE_INT offset
)
4508 tree ref
= fold_build2 (MEM_REF
, TREE_TYPE (type
),
4509 build_fold_addr_expr (base
),
4510 build_int_cst (ptr_type_node
, offset
));
4511 tree addr
= build1 (ADDR_EXPR
, type
, ref
);
4512 recompute_tree_invariant_for_addr_expr (addr
);
4516 /* Similar except don't specify the TREE_TYPE
4517 and leave the TREE_SIDE_EFFECTS as 0.
4518 It is permissible for arguments to be null,
4519 or even garbage if their values do not matter. */
4522 build_nt (enum tree_code code
, ...)
4529 gcc_assert (TREE_CODE_CLASS (code
) != tcc_vl_exp
);
4533 t
= make_node (code
);
4534 length
= TREE_CODE_LENGTH (code
);
4536 for (i
= 0; i
< length
; i
++)
4537 TREE_OPERAND (t
, i
) = va_arg (p
, tree
);
4543 /* Similar to build_nt, but for creating a CALL_EXPR object with a
4547 build_nt_call_vec (tree fn
, vec
<tree
, va_gc
> *args
)
4552 ret
= build_vl_exp (CALL_EXPR
, vec_safe_length (args
) + 3);
4553 CALL_EXPR_FN (ret
) = fn
;
4554 CALL_EXPR_STATIC_CHAIN (ret
) = NULL_TREE
;
4555 FOR_EACH_VEC_SAFE_ELT (args
, ix
, t
)
4556 CALL_EXPR_ARG (ret
, ix
) = t
;
4560 /* Create a DECL_... node of code CODE, name NAME and data type TYPE.
4561 We do NOT enter this node in any sort of symbol table.
4563 LOC is the location of the decl.
4565 layout_decl is used to set up the decl's storage layout.
4566 Other slots are initialized to 0 or null pointers. */
4569 build_decl_stat (location_t loc
, enum tree_code code
, tree name
,
4570 tree type MEM_STAT_DECL
)
4574 t
= make_node_stat (code PASS_MEM_STAT
);
4575 DECL_SOURCE_LOCATION (t
) = loc
;
4577 /* if (type == error_mark_node)
4578 type = integer_type_node; */
4579 /* That is not done, deliberately, so that having error_mark_node
4580 as the type can suppress useless errors in the use of this variable. */
4582 DECL_NAME (t
) = name
;
4583 TREE_TYPE (t
) = type
;
4585 if (code
== VAR_DECL
|| code
== PARM_DECL
|| code
== RESULT_DECL
)
4591 /* Builds and returns function declaration with NAME and TYPE. */
4594 build_fn_decl (const char *name
, tree type
)
4596 tree id
= get_identifier (name
);
4597 tree decl
= build_decl (input_location
, FUNCTION_DECL
, id
, type
);
4599 DECL_EXTERNAL (decl
) = 1;
4600 TREE_PUBLIC (decl
) = 1;
4601 DECL_ARTIFICIAL (decl
) = 1;
4602 TREE_NOTHROW (decl
) = 1;
4607 vec
<tree
, va_gc
> *all_translation_units
;
4609 /* Builds a new translation-unit decl with name NAME, queues it in the
4610 global list of translation-unit decls and returns it. */
4613 build_translation_unit_decl (tree name
)
4615 tree tu
= build_decl (UNKNOWN_LOCATION
, TRANSLATION_UNIT_DECL
,
4617 TRANSLATION_UNIT_LANGUAGE (tu
) = lang_hooks
.name
;
4618 vec_safe_push (all_translation_units
, tu
);
4623 /* BLOCK nodes are used to represent the structure of binding contours
4624 and declarations, once those contours have been exited and their contents
4625 compiled. This information is used for outputting debugging info. */
4628 build_block (tree vars
, tree subblocks
, tree supercontext
, tree chain
)
4630 tree block
= make_node (BLOCK
);
4632 BLOCK_VARS (block
) = vars
;
4633 BLOCK_SUBBLOCKS (block
) = subblocks
;
4634 BLOCK_SUPERCONTEXT (block
) = supercontext
;
4635 BLOCK_CHAIN (block
) = chain
;
4640 /* Like SET_EXPR_LOCATION, but make sure the tree can have a location.
4642 LOC is the location to use in tree T. */
4645 protected_set_expr_location (tree t
, location_t loc
)
4647 if (CAN_HAVE_LOCATION_P (t
))
4648 SET_EXPR_LOCATION (t
, loc
);
4651 /* Return a declaration like DDECL except that its DECL_ATTRIBUTES
4655 build_decl_attribute_variant (tree ddecl
, tree attribute
)
4657 DECL_ATTRIBUTES (ddecl
) = attribute
;
4661 /* Return a type like TTYPE except that its TYPE_ATTRIBUTE
4662 is ATTRIBUTE and its qualifiers are QUALS.
4664 Record such modified types already made so we don't make duplicates. */
4667 build_type_attribute_qual_variant (tree ttype
, tree attribute
, int quals
)
4669 if (! attribute_list_equal (TYPE_ATTRIBUTES (ttype
), attribute
))
4671 inchash::hash hstate
;
4675 enum tree_code code
= TREE_CODE (ttype
);
4677 /* Building a distinct copy of a tagged type is inappropriate; it
4678 causes breakage in code that expects there to be a one-to-one
4679 relationship between a struct and its fields.
4680 build_duplicate_type is another solution (as used in
4681 handle_transparent_union_attribute), but that doesn't play well
4682 with the stronger C++ type identity model. */
4683 if (TREE_CODE (ttype
) == RECORD_TYPE
4684 || TREE_CODE (ttype
) == UNION_TYPE
4685 || TREE_CODE (ttype
) == QUAL_UNION_TYPE
4686 || TREE_CODE (ttype
) == ENUMERAL_TYPE
)
4688 warning (OPT_Wattributes
,
4689 "ignoring attributes applied to %qT after definition",
4690 TYPE_MAIN_VARIANT (ttype
));
4691 return build_qualified_type (ttype
, quals
);
4694 ttype
= build_qualified_type (ttype
, TYPE_UNQUALIFIED
);
4695 ntype
= build_distinct_type_copy (ttype
);
4697 TYPE_ATTRIBUTES (ntype
) = attribute
;
4699 hstate
.add_int (code
);
4700 if (TREE_TYPE (ntype
))
4701 hstate
.add_object (TYPE_HASH (TREE_TYPE (ntype
)));
4702 attribute_hash_list (attribute
, hstate
);
4704 switch (TREE_CODE (ntype
))
4707 type_hash_list (TYPE_ARG_TYPES (ntype
), hstate
);
4710 if (TYPE_DOMAIN (ntype
))
4711 hstate
.add_object (TYPE_HASH (TYPE_DOMAIN (ntype
)));
4714 t
= TYPE_MAX_VALUE (ntype
);
4715 for (i
= 0; i
< TREE_INT_CST_NUNITS (t
); i
++)
4716 hstate
.add_object (TREE_INT_CST_ELT (t
, i
));
4719 case FIXED_POINT_TYPE
:
4721 unsigned int precision
= TYPE_PRECISION (ntype
);
4722 hstate
.add_object (precision
);
4729 ntype
= type_hash_canon (hstate
.end(), ntype
);
4731 /* If the target-dependent attributes make NTYPE different from
4732 its canonical type, we will need to use structural equality
4733 checks for this type. */
4734 if (TYPE_STRUCTURAL_EQUALITY_P (ttype
)
4735 || !comp_type_attributes (ntype
, ttype
))
4736 SET_TYPE_STRUCTURAL_EQUALITY (ntype
);
4737 else if (TYPE_CANONICAL (ntype
) == ntype
)
4738 TYPE_CANONICAL (ntype
) = TYPE_CANONICAL (ttype
);
4740 ttype
= build_qualified_type (ntype
, quals
);
4742 else if (TYPE_QUALS (ttype
) != quals
)
4743 ttype
= build_qualified_type (ttype
, quals
);
4748 /* Check if "omp declare simd" attribute arguments, CLAUSES1 and CLAUSES2, are
4752 omp_declare_simd_clauses_equal (tree clauses1
, tree clauses2
)
4755 for (cl1
= clauses1
, cl2
= clauses2
;
4757 cl1
= OMP_CLAUSE_CHAIN (cl1
), cl2
= OMP_CLAUSE_CHAIN (cl2
))
4759 if (OMP_CLAUSE_CODE (cl1
) != OMP_CLAUSE_CODE (cl2
))
4761 if (OMP_CLAUSE_CODE (cl1
) != OMP_CLAUSE_SIMDLEN
)
4763 if (simple_cst_equal (OMP_CLAUSE_DECL (cl1
),
4764 OMP_CLAUSE_DECL (cl2
)) != 1)
4767 switch (OMP_CLAUSE_CODE (cl1
))
4769 case OMP_CLAUSE_ALIGNED
:
4770 if (simple_cst_equal (OMP_CLAUSE_ALIGNED_ALIGNMENT (cl1
),
4771 OMP_CLAUSE_ALIGNED_ALIGNMENT (cl2
)) != 1)
4774 case OMP_CLAUSE_LINEAR
:
4775 if (simple_cst_equal (OMP_CLAUSE_LINEAR_STEP (cl1
),
4776 OMP_CLAUSE_LINEAR_STEP (cl2
)) != 1)
4779 case OMP_CLAUSE_SIMDLEN
:
4780 if (simple_cst_equal (OMP_CLAUSE_SIMDLEN_EXPR (cl1
),
4781 OMP_CLAUSE_SIMDLEN_EXPR (cl2
)) != 1)
4790 /* Compare two constructor-element-type constants. Return 1 if the lists
4791 are known to be equal; otherwise return 0. */
4794 simple_cst_list_equal (const_tree l1
, const_tree l2
)
4796 while (l1
!= NULL_TREE
&& l2
!= NULL_TREE
)
4798 if (simple_cst_equal (TREE_VALUE (l1
), TREE_VALUE (l2
)) != 1)
4801 l1
= TREE_CHAIN (l1
);
4802 l2
= TREE_CHAIN (l2
);
4808 /* Compare two attributes for their value identity. Return true if the
4809 attribute values are known to be equal; otherwise return false.
4813 attribute_value_equal (const_tree attr1
, const_tree attr2
)
4815 if (TREE_VALUE (attr1
) == TREE_VALUE (attr2
))
4818 if (TREE_VALUE (attr1
) != NULL_TREE
4819 && TREE_CODE (TREE_VALUE (attr1
)) == TREE_LIST
4820 && TREE_VALUE (attr2
) != NULL
4821 && TREE_CODE (TREE_VALUE (attr2
)) == TREE_LIST
)
4822 return (simple_cst_list_equal (TREE_VALUE (attr1
),
4823 TREE_VALUE (attr2
)) == 1);
4825 if ((flag_openmp
|| flag_openmp_simd
)
4826 && TREE_VALUE (attr1
) && TREE_VALUE (attr2
)
4827 && TREE_CODE (TREE_VALUE (attr1
)) == OMP_CLAUSE
4828 && TREE_CODE (TREE_VALUE (attr2
)) == OMP_CLAUSE
)
4829 return omp_declare_simd_clauses_equal (TREE_VALUE (attr1
),
4830 TREE_VALUE (attr2
));
4832 return (simple_cst_equal (TREE_VALUE (attr1
), TREE_VALUE (attr2
)) == 1);
4835 /* Return 0 if the attributes for two types are incompatible, 1 if they
4836 are compatible, and 2 if they are nearly compatible (which causes a
4837 warning to be generated). */
4839 comp_type_attributes (const_tree type1
, const_tree type2
)
4841 const_tree a1
= TYPE_ATTRIBUTES (type1
);
4842 const_tree a2
= TYPE_ATTRIBUTES (type2
);
4847 for (a
= a1
; a
!= NULL_TREE
; a
= TREE_CHAIN (a
))
4849 const struct attribute_spec
*as
;
4852 as
= lookup_attribute_spec (get_attribute_name (a
));
4853 if (!as
|| as
->affects_type_identity
== false)
4856 attr
= lookup_attribute (as
->name
, CONST_CAST_TREE (a2
));
4857 if (!attr
|| !attribute_value_equal (a
, attr
))
4862 for (a
= a2
; a
!= NULL_TREE
; a
= TREE_CHAIN (a
))
4864 const struct attribute_spec
*as
;
4866 as
= lookup_attribute_spec (get_attribute_name (a
));
4867 if (!as
|| as
->affects_type_identity
== false)
4870 if (!lookup_attribute (as
->name
, CONST_CAST_TREE (a1
)))
4872 /* We don't need to compare trees again, as we did this
4873 already in first loop. */
4875 /* All types - affecting identity - are equal, so
4876 there is no need to call target hook for comparison. */
4880 /* As some type combinations - like default calling-convention - might
4881 be compatible, we have to call the target hook to get the final result. */
4882 return targetm
.comp_type_attributes (type1
, type2
);
4885 /* Return a type like TTYPE except that its TYPE_ATTRIBUTE
4888 Record such modified types already made so we don't make duplicates. */
4891 build_type_attribute_variant (tree ttype
, tree attribute
)
4893 return build_type_attribute_qual_variant (ttype
, attribute
,
4894 TYPE_QUALS (ttype
));
4898 /* Reset the expression *EXPR_P, a size or position.
4900 ??? We could reset all non-constant sizes or positions. But it's cheap
4901 enough to not do so and refrain from adding workarounds to dwarf2out.c.
4903 We need to reset self-referential sizes or positions because they cannot
4904 be gimplified and thus can contain a CALL_EXPR after the gimplification
4905 is finished, which will run afoul of LTO streaming. And they need to be
4906 reset to something essentially dummy but not constant, so as to preserve
4907 the properties of the object they are attached to. */
4910 free_lang_data_in_one_sizepos (tree
*expr_p
)
4912 tree expr
= *expr_p
;
4913 if (CONTAINS_PLACEHOLDER_P (expr
))
4914 *expr_p
= build0 (PLACEHOLDER_EXPR
, TREE_TYPE (expr
));
4918 /* Reset all the fields in a binfo node BINFO. We only keep
4919 BINFO_VTABLE, which is used by gimple_fold_obj_type_ref. */
4922 free_lang_data_in_binfo (tree binfo
)
4927 gcc_assert (TREE_CODE (binfo
) == TREE_BINFO
);
4929 BINFO_VIRTUALS (binfo
) = NULL_TREE
;
4930 BINFO_BASE_ACCESSES (binfo
) = NULL
;
4931 BINFO_INHERITANCE_CHAIN (binfo
) = NULL_TREE
;
4932 BINFO_SUBVTT_INDEX (binfo
) = NULL_TREE
;
4934 FOR_EACH_VEC_ELT (*BINFO_BASE_BINFOS (binfo
), i
, t
)
4935 free_lang_data_in_binfo (t
);
4939 /* Reset all language specific information still present in TYPE. */
4942 free_lang_data_in_type (tree type
)
4944 gcc_assert (TYPE_P (type
));
4946 /* Give the FE a chance to remove its own data first. */
4947 lang_hooks
.free_lang_data (type
);
4949 TREE_LANG_FLAG_0 (type
) = 0;
4950 TREE_LANG_FLAG_1 (type
) = 0;
4951 TREE_LANG_FLAG_2 (type
) = 0;
4952 TREE_LANG_FLAG_3 (type
) = 0;
4953 TREE_LANG_FLAG_4 (type
) = 0;
4954 TREE_LANG_FLAG_5 (type
) = 0;
4955 TREE_LANG_FLAG_6 (type
) = 0;
4957 if (TREE_CODE (type
) == FUNCTION_TYPE
)
4959 /* Remove the const and volatile qualifiers from arguments. The
4960 C++ front end removes them, but the C front end does not,
4961 leading to false ODR violation errors when merging two
4962 instances of the same function signature compiled by
4963 different front ends. */
4966 for (p
= TYPE_ARG_TYPES (type
); p
; p
= TREE_CHAIN (p
))
4968 tree arg_type
= TREE_VALUE (p
);
4970 if (TYPE_READONLY (arg_type
) || TYPE_VOLATILE (arg_type
))
4972 int quals
= TYPE_QUALS (arg_type
)
4974 & ~TYPE_QUAL_VOLATILE
;
4975 TREE_VALUE (p
) = build_qualified_type (arg_type
, quals
);
4976 free_lang_data_in_type (TREE_VALUE (p
));
4981 /* Remove members that are not actually FIELD_DECLs from the field
4982 list of an aggregate. These occur in C++. */
4983 if (RECORD_OR_UNION_TYPE_P (type
))
4987 /* Note that TYPE_FIELDS can be shared across distinct
4988 TREE_TYPEs. Therefore, if the first field of TYPE_FIELDS is
4989 to be removed, we cannot set its TREE_CHAIN to NULL.
4990 Otherwise, we would not be able to find all the other fields
4991 in the other instances of this TREE_TYPE.
4993 This was causing an ICE in testsuite/g++.dg/lto/20080915.C. */
4995 member
= TYPE_FIELDS (type
);
4998 if (TREE_CODE (member
) == FIELD_DECL
4999 || TREE_CODE (member
) == TYPE_DECL
)
5002 TREE_CHAIN (prev
) = member
;
5004 TYPE_FIELDS (type
) = member
;
5008 member
= TREE_CHAIN (member
);
5012 TREE_CHAIN (prev
) = NULL_TREE
;
5014 TYPE_FIELDS (type
) = NULL_TREE
;
5016 TYPE_METHODS (type
) = NULL_TREE
;
5017 if (TYPE_BINFO (type
))
5019 free_lang_data_in_binfo (TYPE_BINFO (type
));
5020 if ((!BINFO_VTABLE (TYPE_BINFO (type
))
5021 || !flag_devirtualize
)
5022 && (!BINFO_N_BASE_BINFOS (TYPE_BINFO (type
))
5023 || debug_info_level
!= DINFO_LEVEL_NONE
))
5024 TYPE_BINFO (type
) = NULL
;
5029 /* For non-aggregate types, clear out the language slot (which
5030 overloads TYPE_BINFO). */
5031 TYPE_LANG_SLOT_1 (type
) = NULL_TREE
;
5033 if (INTEGRAL_TYPE_P (type
)
5034 || SCALAR_FLOAT_TYPE_P (type
)
5035 || FIXED_POINT_TYPE_P (type
))
5037 free_lang_data_in_one_sizepos (&TYPE_MIN_VALUE (type
));
5038 free_lang_data_in_one_sizepos (&TYPE_MAX_VALUE (type
));
5042 free_lang_data_in_one_sizepos (&TYPE_SIZE (type
));
5043 free_lang_data_in_one_sizepos (&TYPE_SIZE_UNIT (type
));
5045 if (TYPE_CONTEXT (type
)
5046 && TREE_CODE (TYPE_CONTEXT (type
)) == BLOCK
)
5048 tree ctx
= TYPE_CONTEXT (type
);
5051 ctx
= BLOCK_SUPERCONTEXT (ctx
);
5053 while (ctx
&& TREE_CODE (ctx
) == BLOCK
);
5054 TYPE_CONTEXT (type
) = ctx
;
5059 /* Return true if DECL may need an assembler name to be set. */
5062 need_assembler_name_p (tree decl
)
5064 /* We use DECL_ASSEMBLER_NAME to hold mangled type names for One Definition Rule
5066 if (flag_lto_odr_type_mering
5067 && TREE_CODE (decl
) == TYPE_DECL
5069 && decl
== TYPE_NAME (TREE_TYPE (decl
))
5070 && !is_lang_specific (TREE_TYPE (decl
))
5071 && AGGREGATE_TYPE_P (TREE_TYPE (decl
))
5072 && !variably_modified_type_p (TREE_TYPE (decl
), NULL_TREE
)
5073 && !type_in_anonymous_namespace_p (TREE_TYPE (decl
)))
5074 return !DECL_ASSEMBLER_NAME_SET_P (decl
);
5075 /* Only FUNCTION_DECLs and VAR_DECLs are considered. */
5076 if (TREE_CODE (decl
) != FUNCTION_DECL
5077 && TREE_CODE (decl
) != VAR_DECL
)
5080 /* If DECL already has its assembler name set, it does not need a
5082 if (!HAS_DECL_ASSEMBLER_NAME_P (decl
)
5083 || DECL_ASSEMBLER_NAME_SET_P (decl
))
5086 /* Abstract decls do not need an assembler name. */
5087 if (DECL_ABSTRACT_P (decl
))
5090 /* For VAR_DECLs, only static, public and external symbols need an
5092 if (TREE_CODE (decl
) == VAR_DECL
5093 && !TREE_STATIC (decl
)
5094 && !TREE_PUBLIC (decl
)
5095 && !DECL_EXTERNAL (decl
))
5098 if (TREE_CODE (decl
) == FUNCTION_DECL
)
5100 /* Do not set assembler name on builtins. Allow RTL expansion to
5101 decide whether to expand inline or via a regular call. */
5102 if (DECL_BUILT_IN (decl
)
5103 && DECL_BUILT_IN_CLASS (decl
) != BUILT_IN_FRONTEND
)
5106 /* Functions represented in the callgraph need an assembler name. */
5107 if (cgraph_node::get (decl
) != NULL
)
5110 /* Unused and not public functions don't need an assembler name. */
5111 if (!TREE_USED (decl
) && !TREE_PUBLIC (decl
))
5119 /* Reset all language specific information still present in symbol
5123 free_lang_data_in_decl (tree decl
)
5125 gcc_assert (DECL_P (decl
));
5127 /* Give the FE a chance to remove its own data first. */
5128 lang_hooks
.free_lang_data (decl
);
5130 TREE_LANG_FLAG_0 (decl
) = 0;
5131 TREE_LANG_FLAG_1 (decl
) = 0;
5132 TREE_LANG_FLAG_2 (decl
) = 0;
5133 TREE_LANG_FLAG_3 (decl
) = 0;
5134 TREE_LANG_FLAG_4 (decl
) = 0;
5135 TREE_LANG_FLAG_5 (decl
) = 0;
5136 TREE_LANG_FLAG_6 (decl
) = 0;
5138 free_lang_data_in_one_sizepos (&DECL_SIZE (decl
));
5139 free_lang_data_in_one_sizepos (&DECL_SIZE_UNIT (decl
));
5140 if (TREE_CODE (decl
) == FIELD_DECL
)
5142 free_lang_data_in_one_sizepos (&DECL_FIELD_OFFSET (decl
));
5143 if (TREE_CODE (DECL_CONTEXT (decl
)) == QUAL_UNION_TYPE
)
5144 DECL_QUALIFIER (decl
) = NULL_TREE
;
5147 if (TREE_CODE (decl
) == FUNCTION_DECL
)
5149 struct cgraph_node
*node
;
5150 if (!(node
= cgraph_node::get (decl
))
5151 || (!node
->definition
&& !node
->clones
))
5154 node
->release_body ();
5157 release_function_body (decl
);
5158 DECL_ARGUMENTS (decl
) = NULL
;
5159 DECL_RESULT (decl
) = NULL
;
5160 DECL_INITIAL (decl
) = error_mark_node
;
5163 if (gimple_has_body_p (decl
))
5167 /* If DECL has a gimple body, then the context for its
5168 arguments must be DECL. Otherwise, it doesn't really
5169 matter, as we will not be emitting any code for DECL. In
5170 general, there may be other instances of DECL created by
5171 the front end and since PARM_DECLs are generally shared,
5172 their DECL_CONTEXT changes as the replicas of DECL are
5173 created. The only time where DECL_CONTEXT is important
5174 is for the FUNCTION_DECLs that have a gimple body (since
5175 the PARM_DECL will be used in the function's body). */
5176 for (t
= DECL_ARGUMENTS (decl
); t
; t
= TREE_CHAIN (t
))
5177 DECL_CONTEXT (t
) = decl
;
5178 if (!DECL_FUNCTION_SPECIFIC_TARGET (decl
))
5179 DECL_FUNCTION_SPECIFIC_TARGET (decl
)
5180 = target_option_default_node
;
5181 if (!DECL_FUNCTION_SPECIFIC_OPTIMIZATION (decl
))
5182 DECL_FUNCTION_SPECIFIC_OPTIMIZATION (decl
)
5183 = optimization_default_node
;
5186 /* DECL_SAVED_TREE holds the GENERIC representation for DECL.
5187 At this point, it is not needed anymore. */
5188 DECL_SAVED_TREE (decl
) = NULL_TREE
;
5190 /* Clear the abstract origin if it refers to a method. Otherwise
5191 dwarf2out.c will ICE as we clear TYPE_METHODS and thus the
5192 origin will not be output correctly. */
5193 if (DECL_ABSTRACT_ORIGIN (decl
)
5194 && DECL_CONTEXT (DECL_ABSTRACT_ORIGIN (decl
))
5195 && RECORD_OR_UNION_TYPE_P
5196 (DECL_CONTEXT (DECL_ABSTRACT_ORIGIN (decl
))))
5197 DECL_ABSTRACT_ORIGIN (decl
) = NULL_TREE
;
5199 /* Sometimes the C++ frontend doesn't manage to transform a temporary
5200 DECL_VINDEX referring to itself into a vtable slot number as it
5201 should. Happens with functions that are copied and then forgotten
5202 about. Just clear it, it won't matter anymore. */
5203 if (DECL_VINDEX (decl
) && !tree_fits_shwi_p (DECL_VINDEX (decl
)))
5204 DECL_VINDEX (decl
) = NULL_TREE
;
5206 else if (TREE_CODE (decl
) == VAR_DECL
)
5208 if ((DECL_EXTERNAL (decl
)
5209 && (!TREE_STATIC (decl
) || !TREE_READONLY (decl
)))
5210 || (decl_function_context (decl
) && !TREE_STATIC (decl
)))
5211 DECL_INITIAL (decl
) = NULL_TREE
;
5213 else if (TREE_CODE (decl
) == TYPE_DECL
5214 || TREE_CODE (decl
) == FIELD_DECL
)
5215 DECL_INITIAL (decl
) = NULL_TREE
;
5216 else if (TREE_CODE (decl
) == TRANSLATION_UNIT_DECL
5217 && DECL_INITIAL (decl
)
5218 && TREE_CODE (DECL_INITIAL (decl
)) == BLOCK
)
5220 /* Strip builtins from the translation-unit BLOCK. We still have targets
5221 without builtin_decl_explicit support and also builtins are shared
5222 nodes and thus we can't use TREE_CHAIN in multiple lists. */
5223 tree
*nextp
= &BLOCK_VARS (DECL_INITIAL (decl
));
5227 if (TREE_CODE (var
) == FUNCTION_DECL
5228 && DECL_BUILT_IN (var
))
5229 *nextp
= TREE_CHAIN (var
);
5231 nextp
= &TREE_CHAIN (var
);
5237 /* Data used when collecting DECLs and TYPEs for language data removal. */
5239 struct free_lang_data_d
5241 /* Worklist to avoid excessive recursion. */
5244 /* Set of traversed objects. Used to avoid duplicate visits. */
5245 hash_set
<tree
> *pset
;
5247 /* Array of symbols to process with free_lang_data_in_decl. */
5250 /* Array of types to process with free_lang_data_in_type. */
5255 /* Save all language fields needed to generate proper debug information
5256 for DECL. This saves most fields cleared out by free_lang_data_in_decl. */
5259 save_debug_info_for_decl (tree t
)
5261 /*struct saved_debug_info_d *sdi;*/
5263 gcc_assert (debug_info_level
> DINFO_LEVEL_TERSE
&& t
&& DECL_P (t
));
5265 /* FIXME. Partial implementation for saving debug info removed. */
5269 /* Save all language fields needed to generate proper debug information
5270 for TYPE. This saves most fields cleared out by free_lang_data_in_type. */
5273 save_debug_info_for_type (tree t
)
5275 /*struct saved_debug_info_d *sdi;*/
5277 gcc_assert (debug_info_level
> DINFO_LEVEL_TERSE
&& t
&& TYPE_P (t
));
5279 /* FIXME. Partial implementation for saving debug info removed. */
5283 /* Add type or decl T to one of the list of tree nodes that need their
5284 language data removed. The lists are held inside FLD. */
5287 add_tree_to_fld_list (tree t
, struct free_lang_data_d
*fld
)
5291 fld
->decls
.safe_push (t
);
5292 if (debug_info_level
> DINFO_LEVEL_TERSE
)
5293 save_debug_info_for_decl (t
);
5295 else if (TYPE_P (t
))
5297 fld
->types
.safe_push (t
);
5298 if (debug_info_level
> DINFO_LEVEL_TERSE
)
5299 save_debug_info_for_type (t
);
5305 /* Push tree node T into FLD->WORKLIST. */
5308 fld_worklist_push (tree t
, struct free_lang_data_d
*fld
)
5310 if (t
&& !is_lang_specific (t
) && !fld
->pset
->contains (t
))
5311 fld
->worklist
.safe_push ((t
));
5315 /* Operand callback helper for free_lang_data_in_node. *TP is the
5316 subtree operand being considered. */
5319 find_decls_types_r (tree
*tp
, int *ws
, void *data
)
5322 struct free_lang_data_d
*fld
= (struct free_lang_data_d
*) data
;
5324 if (TREE_CODE (t
) == TREE_LIST
)
5327 /* Language specific nodes will be removed, so there is no need
5328 to gather anything under them. */
5329 if (is_lang_specific (t
))
5337 /* Note that walk_tree does not traverse every possible field in
5338 decls, so we have to do our own traversals here. */
5339 add_tree_to_fld_list (t
, fld
);
5341 fld_worklist_push (DECL_NAME (t
), fld
);
5342 fld_worklist_push (DECL_CONTEXT (t
), fld
);
5343 fld_worklist_push (DECL_SIZE (t
), fld
);
5344 fld_worklist_push (DECL_SIZE_UNIT (t
), fld
);
5346 /* We are going to remove everything under DECL_INITIAL for
5347 TYPE_DECLs. No point walking them. */
5348 if (TREE_CODE (t
) != TYPE_DECL
)
5349 fld_worklist_push (DECL_INITIAL (t
), fld
);
5351 fld_worklist_push (DECL_ATTRIBUTES (t
), fld
);
5352 fld_worklist_push (DECL_ABSTRACT_ORIGIN (t
), fld
);
5354 if (TREE_CODE (t
) == FUNCTION_DECL
)
5356 fld_worklist_push (DECL_ARGUMENTS (t
), fld
);
5357 fld_worklist_push (DECL_RESULT (t
), fld
);
5359 else if (TREE_CODE (t
) == TYPE_DECL
)
5361 fld_worklist_push (DECL_ORIGINAL_TYPE (t
), fld
);
5363 else if (TREE_CODE (t
) == FIELD_DECL
)
5365 fld_worklist_push (DECL_FIELD_OFFSET (t
), fld
);
5366 fld_worklist_push (DECL_BIT_FIELD_TYPE (t
), fld
);
5367 fld_worklist_push (DECL_FIELD_BIT_OFFSET (t
), fld
);
5368 fld_worklist_push (DECL_FCONTEXT (t
), fld
);
5371 if ((TREE_CODE (t
) == VAR_DECL
|| TREE_CODE (t
) == PARM_DECL
)
5372 && DECL_HAS_VALUE_EXPR_P (t
))
5373 fld_worklist_push (DECL_VALUE_EXPR (t
), fld
);
5375 if (TREE_CODE (t
) != FIELD_DECL
5376 && TREE_CODE (t
) != TYPE_DECL
)
5377 fld_worklist_push (TREE_CHAIN (t
), fld
);
5380 else if (TYPE_P (t
))
5382 /* Note that walk_tree does not traverse every possible field in
5383 types, so we have to do our own traversals here. */
5384 add_tree_to_fld_list (t
, fld
);
5386 if (!RECORD_OR_UNION_TYPE_P (t
))
5387 fld_worklist_push (TYPE_CACHED_VALUES (t
), fld
);
5388 fld_worklist_push (TYPE_SIZE (t
), fld
);
5389 fld_worklist_push (TYPE_SIZE_UNIT (t
), fld
);
5390 fld_worklist_push (TYPE_ATTRIBUTES (t
), fld
);
5391 fld_worklist_push (TYPE_POINTER_TO (t
), fld
);
5392 fld_worklist_push (TYPE_REFERENCE_TO (t
), fld
);
5393 fld_worklist_push (TYPE_NAME (t
), fld
);
5394 /* Do not walk TYPE_NEXT_PTR_TO or TYPE_NEXT_REF_TO. We do not stream
5395 them and thus do not and want not to reach unused pointer types
5397 if (!POINTER_TYPE_P (t
))
5398 fld_worklist_push (TYPE_MINVAL (t
), fld
);
5399 if (!RECORD_OR_UNION_TYPE_P (t
))
5400 fld_worklist_push (TYPE_MAXVAL (t
), fld
);
5401 fld_worklist_push (TYPE_MAIN_VARIANT (t
), fld
);
5402 /* Do not walk TYPE_NEXT_VARIANT. We do not stream it and thus
5403 do not and want not to reach unused variants this way. */
5404 if (TYPE_CONTEXT (t
))
5406 tree ctx
= TYPE_CONTEXT (t
);
5407 /* We adjust BLOCK TYPE_CONTEXTs to the innermost non-BLOCK one.
5408 So push that instead. */
5409 while (ctx
&& TREE_CODE (ctx
) == BLOCK
)
5410 ctx
= BLOCK_SUPERCONTEXT (ctx
);
5411 fld_worklist_push (ctx
, fld
);
5413 /* Do not walk TYPE_CANONICAL. We do not stream it and thus do not
5414 and want not to reach unused types this way. */
5416 if (RECORD_OR_UNION_TYPE_P (t
) && TYPE_BINFO (t
))
5420 FOR_EACH_VEC_ELT (*BINFO_BASE_BINFOS (TYPE_BINFO (t
)), i
, tem
)
5421 fld_worklist_push (TREE_TYPE (tem
), fld
);
5422 tem
= BINFO_VIRTUALS (TYPE_BINFO (t
));
5424 /* The Java FE overloads BINFO_VIRTUALS for its own purpose. */
5425 && TREE_CODE (tem
) == TREE_LIST
)
5428 fld_worklist_push (TREE_VALUE (tem
), fld
);
5429 tem
= TREE_CHAIN (tem
);
5433 if (RECORD_OR_UNION_TYPE_P (t
))
5436 /* Push all TYPE_FIELDS - there can be interleaving interesting
5437 and non-interesting things. */
5438 tem
= TYPE_FIELDS (t
);
5441 if (TREE_CODE (tem
) == FIELD_DECL
5442 || TREE_CODE (tem
) == TYPE_DECL
)
5443 fld_worklist_push (tem
, fld
);
5444 tem
= TREE_CHAIN (tem
);
5448 fld_worklist_push (TYPE_STUB_DECL (t
), fld
);
5451 else if (TREE_CODE (t
) == BLOCK
)
5454 for (tem
= BLOCK_VARS (t
); tem
; tem
= TREE_CHAIN (tem
))
5455 fld_worklist_push (tem
, fld
);
5456 for (tem
= BLOCK_SUBBLOCKS (t
); tem
; tem
= BLOCK_CHAIN (tem
))
5457 fld_worklist_push (tem
, fld
);
5458 fld_worklist_push (BLOCK_ABSTRACT_ORIGIN (t
), fld
);
5461 if (TREE_CODE (t
) != IDENTIFIER_NODE
5462 && CODE_CONTAINS_STRUCT (TREE_CODE (t
), TS_TYPED
))
5463 fld_worklist_push (TREE_TYPE (t
), fld
);
5469 /* Find decls and types in T. */
5472 find_decls_types (tree t
, struct free_lang_data_d
*fld
)
5476 if (!fld
->pset
->contains (t
))
5477 walk_tree (&t
, find_decls_types_r
, fld
, fld
->pset
);
5478 if (fld
->worklist
.is_empty ())
5480 t
= fld
->worklist
.pop ();
5484 /* Translate all the types in LIST with the corresponding runtime
5488 get_eh_types_for_runtime (tree list
)
5492 if (list
== NULL_TREE
)
5495 head
= build_tree_list (0, lookup_type_for_runtime (TREE_VALUE (list
)));
5497 list
= TREE_CHAIN (list
);
5500 tree n
= build_tree_list (0, lookup_type_for_runtime (TREE_VALUE (list
)));
5501 TREE_CHAIN (prev
) = n
;
5502 prev
= TREE_CHAIN (prev
);
5503 list
= TREE_CHAIN (list
);
5510 /* Find decls and types referenced in EH region R and store them in
5511 FLD->DECLS and FLD->TYPES. */
5514 find_decls_types_in_eh_region (eh_region r
, struct free_lang_data_d
*fld
)
5525 /* The types referenced in each catch must first be changed to the
5526 EH types used at runtime. This removes references to FE types
5528 for (c
= r
->u
.eh_try
.first_catch
; c
; c
= c
->next_catch
)
5530 c
->type_list
= get_eh_types_for_runtime (c
->type_list
);
5531 walk_tree (&c
->type_list
, find_decls_types_r
, fld
, fld
->pset
);
5536 case ERT_ALLOWED_EXCEPTIONS
:
5537 r
->u
.allowed
.type_list
5538 = get_eh_types_for_runtime (r
->u
.allowed
.type_list
);
5539 walk_tree (&r
->u
.allowed
.type_list
, find_decls_types_r
, fld
, fld
->pset
);
5542 case ERT_MUST_NOT_THROW
:
5543 walk_tree (&r
->u
.must_not_throw
.failure_decl
,
5544 find_decls_types_r
, fld
, fld
->pset
);
5550 /* Find decls and types referenced in cgraph node N and store them in
5551 FLD->DECLS and FLD->TYPES. Unlike pass_referenced_vars, this will
5552 look for *every* kind of DECL and TYPE node reachable from N,
5553 including those embedded inside types and decls (i.e,, TYPE_DECLs,
5554 NAMESPACE_DECLs, etc). */
5557 find_decls_types_in_node (struct cgraph_node
*n
, struct free_lang_data_d
*fld
)
5560 struct function
*fn
;
5564 find_decls_types (n
->decl
, fld
);
5566 if (!gimple_has_body_p (n
->decl
))
5569 gcc_assert (current_function_decl
== NULL_TREE
&& cfun
== NULL
);
5571 fn
= DECL_STRUCT_FUNCTION (n
->decl
);
5573 /* Traverse locals. */
5574 FOR_EACH_LOCAL_DECL (fn
, ix
, t
)
5575 find_decls_types (t
, fld
);
5577 /* Traverse EH regions in FN. */
5580 FOR_ALL_EH_REGION_FN (r
, fn
)
5581 find_decls_types_in_eh_region (r
, fld
);
5584 /* Traverse every statement in FN. */
5585 FOR_EACH_BB_FN (bb
, fn
)
5588 gimple_stmt_iterator si
;
5591 for (psi
= gsi_start_phis (bb
); !gsi_end_p (psi
); gsi_next (&psi
))
5593 gphi
*phi
= psi
.phi ();
5595 for (i
= 0; i
< gimple_phi_num_args (phi
); i
++)
5597 tree
*arg_p
= gimple_phi_arg_def_ptr (phi
, i
);
5598 find_decls_types (*arg_p
, fld
);
5602 for (si
= gsi_start_bb (bb
); !gsi_end_p (si
); gsi_next (&si
))
5604 gimple stmt
= gsi_stmt (si
);
5606 if (is_gimple_call (stmt
))
5607 find_decls_types (gimple_call_fntype (stmt
), fld
);
5609 for (i
= 0; i
< gimple_num_ops (stmt
); i
++)
5611 tree arg
= gimple_op (stmt
, i
);
5612 find_decls_types (arg
, fld
);
5619 /* Find decls and types referenced in varpool node N and store them in
5620 FLD->DECLS and FLD->TYPES. Unlike pass_referenced_vars, this will
5621 look for *every* kind of DECL and TYPE node reachable from N,
5622 including those embedded inside types and decls (i.e,, TYPE_DECLs,
5623 NAMESPACE_DECLs, etc). */
5626 find_decls_types_in_var (varpool_node
*v
, struct free_lang_data_d
*fld
)
5628 find_decls_types (v
->decl
, fld
);
5631 /* If T needs an assembler name, have one created for it. */
5634 assign_assembler_name_if_neeeded (tree t
)
5636 if (need_assembler_name_p (t
))
5638 /* When setting DECL_ASSEMBLER_NAME, the C++ mangler may emit
5639 diagnostics that use input_location to show locus
5640 information. The problem here is that, at this point,
5641 input_location is generally anchored to the end of the file
5642 (since the parser is long gone), so we don't have a good
5643 position to pin it to.
5645 To alleviate this problem, this uses the location of T's
5646 declaration. Examples of this are
5647 testsuite/g++.dg/template/cond2.C and
5648 testsuite/g++.dg/template/pr35240.C. */
5649 location_t saved_location
= input_location
;
5650 input_location
= DECL_SOURCE_LOCATION (t
);
5652 decl_assembler_name (t
);
5654 input_location
= saved_location
;
5659 /* Free language specific information for every operand and expression
5660 in every node of the call graph. This process operates in three stages:
5662 1- Every callgraph node and varpool node is traversed looking for
5663 decls and types embedded in them. This is a more exhaustive
5664 search than that done by find_referenced_vars, because it will
5665 also collect individual fields, decls embedded in types, etc.
5667 2- All the decls found are sent to free_lang_data_in_decl.
5669 3- All the types found are sent to free_lang_data_in_type.
5671 The ordering between decls and types is important because
5672 free_lang_data_in_decl sets assembler names, which includes
5673 mangling. So types cannot be freed up until assembler names have
5677 free_lang_data_in_cgraph (void)
5679 struct cgraph_node
*n
;
5681 struct free_lang_data_d fld
;
5686 /* Initialize sets and arrays to store referenced decls and types. */
5687 fld
.pset
= new hash_set
<tree
>;
5688 fld
.worklist
.create (0);
5689 fld
.decls
.create (100);
5690 fld
.types
.create (100);
5692 /* Find decls and types in the body of every function in the callgraph. */
5693 FOR_EACH_FUNCTION (n
)
5694 find_decls_types_in_node (n
, &fld
);
5696 FOR_EACH_VEC_SAFE_ELT (alias_pairs
, i
, p
)
5697 find_decls_types (p
->decl
, &fld
);
5699 /* Find decls and types in every varpool symbol. */
5700 FOR_EACH_VARIABLE (v
)
5701 find_decls_types_in_var (v
, &fld
);
5703 /* Set the assembler name on every decl found. We need to do this
5704 now because free_lang_data_in_decl will invalidate data needed
5705 for mangling. This breaks mangling on interdependent decls. */
5706 FOR_EACH_VEC_ELT (fld
.decls
, i
, t
)
5707 assign_assembler_name_if_neeeded (t
);
5709 /* Traverse every decl found freeing its language data. */
5710 FOR_EACH_VEC_ELT (fld
.decls
, i
, t
)
5711 free_lang_data_in_decl (t
);
5713 /* Traverse every type found freeing its language data. */
5714 FOR_EACH_VEC_ELT (fld
.types
, i
, t
)
5715 free_lang_data_in_type (t
);
5718 fld
.worklist
.release ();
5719 fld
.decls
.release ();
5720 fld
.types
.release ();
5724 /* Free resources that are used by FE but are not needed once they are done. */
5727 free_lang_data (void)
5731 /* If we are the LTO frontend we have freed lang-specific data already. */
5733 || (!flag_generate_lto
&& !flag_generate_offload
))
5736 /* Allocate and assign alias sets to the standard integer types
5737 while the slots are still in the way the frontends generated them. */
5738 for (i
= 0; i
< itk_none
; ++i
)
5739 if (integer_types
[i
])
5740 TYPE_ALIAS_SET (integer_types
[i
]) = get_alias_set (integer_types
[i
]);
5742 /* Traverse the IL resetting language specific information for
5743 operands, expressions, etc. */
5744 free_lang_data_in_cgraph ();
5746 /* Create gimple variants for common types. */
5747 ptrdiff_type_node
= integer_type_node
;
5748 fileptr_type_node
= ptr_type_node
;
5750 /* Reset some langhooks. Do not reset types_compatible_p, it may
5751 still be used indirectly via the get_alias_set langhook. */
5752 lang_hooks
.dwarf_name
= lhd_dwarf_name
;
5753 lang_hooks
.decl_printable_name
= gimple_decl_printable_name
;
5754 /* We do not want the default decl_assembler_name implementation,
5755 rather if we have fixed everything we want a wrapper around it
5756 asserting that all non-local symbols already got their assembler
5757 name and only produce assembler names for local symbols. Or rather
5758 make sure we never call decl_assembler_name on local symbols and
5759 devise a separate, middle-end private scheme for it. */
5761 /* Reset diagnostic machinery. */
5762 tree_diagnostics_defaults (global_dc
);
5770 const pass_data pass_data_ipa_free_lang_data
=
5772 SIMPLE_IPA_PASS
, /* type */
5773 "*free_lang_data", /* name */
5774 OPTGROUP_NONE
, /* optinfo_flags */
5775 TV_IPA_FREE_LANG_DATA
, /* tv_id */
5776 0, /* properties_required */
5777 0, /* properties_provided */
5778 0, /* properties_destroyed */
5779 0, /* todo_flags_start */
5780 0, /* todo_flags_finish */
5783 class pass_ipa_free_lang_data
: public simple_ipa_opt_pass
5786 pass_ipa_free_lang_data (gcc::context
*ctxt
)
5787 : simple_ipa_opt_pass (pass_data_ipa_free_lang_data
, ctxt
)
5790 /* opt_pass methods: */
5791 virtual unsigned int execute (function
*) { return free_lang_data (); }
5793 }; // class pass_ipa_free_lang_data
5797 simple_ipa_opt_pass
*
5798 make_pass_ipa_free_lang_data (gcc::context
*ctxt
)
5800 return new pass_ipa_free_lang_data (ctxt
);
5803 /* The backbone of is_attribute_p(). ATTR_LEN is the string length of
5804 ATTR_NAME. Also used internally by remove_attribute(). */
5806 private_is_attribute_p (const char *attr_name
, size_t attr_len
, const_tree ident
)
5808 size_t ident_len
= IDENTIFIER_LENGTH (ident
);
5810 if (ident_len
== attr_len
)
5812 if (strcmp (attr_name
, IDENTIFIER_POINTER (ident
)) == 0)
5815 else if (ident_len
== attr_len
+ 4)
5817 /* There is the possibility that ATTR is 'text' and IDENT is
5819 const char *p
= IDENTIFIER_POINTER (ident
);
5820 if (p
[0] == '_' && p
[1] == '_'
5821 && p
[ident_len
- 2] == '_' && p
[ident_len
- 1] == '_'
5822 && strncmp (attr_name
, p
+ 2, attr_len
) == 0)
5829 /* The backbone of lookup_attribute(). ATTR_LEN is the string length
5830 of ATTR_NAME, and LIST is not NULL_TREE. */
5832 private_lookup_attribute (const char *attr_name
, size_t attr_len
, tree list
)
5836 size_t ident_len
= IDENTIFIER_LENGTH (get_attribute_name (list
));
5838 if (ident_len
== attr_len
)
5840 if (!strcmp (attr_name
,
5841 IDENTIFIER_POINTER (get_attribute_name (list
))))
5844 /* TODO: If we made sure that attributes were stored in the
5845 canonical form without '__...__' (ie, as in 'text' as opposed
5846 to '__text__') then we could avoid the following case. */
5847 else if (ident_len
== attr_len
+ 4)
5849 const char *p
= IDENTIFIER_POINTER (get_attribute_name (list
));
5850 if (p
[0] == '_' && p
[1] == '_'
5851 && p
[ident_len
- 2] == '_' && p
[ident_len
- 1] == '_'
5852 && strncmp (attr_name
, p
+ 2, attr_len
) == 0)
5855 list
= TREE_CHAIN (list
);
5861 /* Given an attribute name ATTR_NAME and a list of attributes LIST,
5862 return a pointer to the attribute's list first element if the attribute
5863 starts with ATTR_NAME. ATTR_NAME must be in the form 'text' (not
5867 private_lookup_attribute_by_prefix (const char *attr_name
, size_t attr_len
,
5872 size_t ident_len
= IDENTIFIER_LENGTH (get_attribute_name (list
));
5874 if (attr_len
> ident_len
)
5876 list
= TREE_CHAIN (list
);
5880 const char *p
= IDENTIFIER_POINTER (get_attribute_name (list
));
5882 if (strncmp (attr_name
, p
, attr_len
) == 0)
5885 /* TODO: If we made sure that attributes were stored in the
5886 canonical form without '__...__' (ie, as in 'text' as opposed
5887 to '__text__') then we could avoid the following case. */
5888 if (p
[0] == '_' && p
[1] == '_' &&
5889 strncmp (attr_name
, p
+ 2, attr_len
) == 0)
5892 list
= TREE_CHAIN (list
);
5899 /* A variant of lookup_attribute() that can be used with an identifier
5900 as the first argument, and where the identifier can be either
5901 'text' or '__text__'.
5903 Given an attribute ATTR_IDENTIFIER, and a list of attributes LIST,
5904 return a pointer to the attribute's list element if the attribute
5905 is part of the list, or NULL_TREE if not found. If the attribute
5906 appears more than once, this only returns the first occurrence; the
5907 TREE_CHAIN of the return value should be passed back in if further
5908 occurrences are wanted. ATTR_IDENTIFIER must be an identifier but
5909 can be in the form 'text' or '__text__'. */
5911 lookup_ident_attribute (tree attr_identifier
, tree list
)
5913 gcc_checking_assert (TREE_CODE (attr_identifier
) == IDENTIFIER_NODE
);
5917 gcc_checking_assert (TREE_CODE (get_attribute_name (list
))
5918 == IDENTIFIER_NODE
);
5920 /* Identifiers can be compared directly for equality. */
5921 if (attr_identifier
== get_attribute_name (list
))
5924 /* If they are not equal, they may still be one in the form
5925 'text' while the other one is in the form '__text__'. TODO:
5926 If we were storing attributes in normalized 'text' form, then
5927 this could all go away and we could take full advantage of
5928 the fact that we're comparing identifiers. :-) */
5930 size_t attr_len
= IDENTIFIER_LENGTH (attr_identifier
);
5931 size_t ident_len
= IDENTIFIER_LENGTH (get_attribute_name (list
));
5933 if (ident_len
== attr_len
+ 4)
5935 const char *p
= IDENTIFIER_POINTER (get_attribute_name (list
));
5936 const char *q
= IDENTIFIER_POINTER (attr_identifier
);
5937 if (p
[0] == '_' && p
[1] == '_'
5938 && p
[ident_len
- 2] == '_' && p
[ident_len
- 1] == '_'
5939 && strncmp (q
, p
+ 2, attr_len
) == 0)
5942 else if (ident_len
+ 4 == attr_len
)
5944 const char *p
= IDENTIFIER_POINTER (get_attribute_name (list
));
5945 const char *q
= IDENTIFIER_POINTER (attr_identifier
);
5946 if (q
[0] == '_' && q
[1] == '_'
5947 && q
[attr_len
- 2] == '_' && q
[attr_len
- 1] == '_'
5948 && strncmp (q
+ 2, p
, ident_len
) == 0)
5952 list
= TREE_CHAIN (list
);
5958 /* Remove any instances of attribute ATTR_NAME in LIST and return the
5962 remove_attribute (const char *attr_name
, tree list
)
5965 size_t attr_len
= strlen (attr_name
);
5967 gcc_checking_assert (attr_name
[0] != '_');
5969 for (p
= &list
; *p
; )
5972 /* TODO: If we were storing attributes in normalized form, here
5973 we could use a simple strcmp(). */
5974 if (private_is_attribute_p (attr_name
, attr_len
, get_attribute_name (l
)))
5975 *p
= TREE_CHAIN (l
);
5977 p
= &TREE_CHAIN (l
);
5983 /* Return an attribute list that is the union of a1 and a2. */
5986 merge_attributes (tree a1
, tree a2
)
5990 /* Either one unset? Take the set one. */
5992 if ((attributes
= a1
) == 0)
5995 /* One that completely contains the other? Take it. */
5997 else if (a2
!= 0 && ! attribute_list_contained (a1
, a2
))
5999 if (attribute_list_contained (a2
, a1
))
6003 /* Pick the longest list, and hang on the other list. */
6005 if (list_length (a1
) < list_length (a2
))
6006 attributes
= a2
, a2
= a1
;
6008 for (; a2
!= 0; a2
= TREE_CHAIN (a2
))
6011 for (a
= lookup_ident_attribute (get_attribute_name (a2
),
6013 a
!= NULL_TREE
&& !attribute_value_equal (a
, a2
);
6014 a
= lookup_ident_attribute (get_attribute_name (a2
),
6019 a1
= copy_node (a2
);
6020 TREE_CHAIN (a1
) = attributes
;
6029 /* Given types T1 and T2, merge their attributes and return
6033 merge_type_attributes (tree t1
, tree t2
)
6035 return merge_attributes (TYPE_ATTRIBUTES (t1
),
6036 TYPE_ATTRIBUTES (t2
));
6039 /* Given decls OLDDECL and NEWDECL, merge their attributes and return
6043 merge_decl_attributes (tree olddecl
, tree newdecl
)
6045 return merge_attributes (DECL_ATTRIBUTES (olddecl
),
6046 DECL_ATTRIBUTES (newdecl
));
6049 #if TARGET_DLLIMPORT_DECL_ATTRIBUTES
6051 /* Specialization of merge_decl_attributes for various Windows targets.
6053 This handles the following situation:
6055 __declspec (dllimport) int foo;
6058 The second instance of `foo' nullifies the dllimport. */
6061 merge_dllimport_decl_attributes (tree old
, tree new_tree
)
6064 int delete_dllimport_p
= 1;
6066 /* What we need to do here is remove from `old' dllimport if it doesn't
6067 appear in `new'. dllimport behaves like extern: if a declaration is
6068 marked dllimport and a definition appears later, then the object
6069 is not dllimport'd. We also remove a `new' dllimport if the old list
6070 contains dllexport: dllexport always overrides dllimport, regardless
6071 of the order of declaration. */
6072 if (!VAR_OR_FUNCTION_DECL_P (new_tree
))
6073 delete_dllimport_p
= 0;
6074 else if (DECL_DLLIMPORT_P (new_tree
)
6075 && lookup_attribute ("dllexport", DECL_ATTRIBUTES (old
)))
6077 DECL_DLLIMPORT_P (new_tree
) = 0;
6078 warning (OPT_Wattributes
, "%q+D already declared with dllexport attribute: "
6079 "dllimport ignored", new_tree
);
6081 else if (DECL_DLLIMPORT_P (old
) && !DECL_DLLIMPORT_P (new_tree
))
6083 /* Warn about overriding a symbol that has already been used, e.g.:
6084 extern int __attribute__ ((dllimport)) foo;
6085 int* bar () {return &foo;}
6088 if (TREE_USED (old
))
6090 warning (0, "%q+D redeclared without dllimport attribute "
6091 "after being referenced with dll linkage", new_tree
);
6092 /* If we have used a variable's address with dllimport linkage,
6093 keep the old DECL_DLLIMPORT_P flag: the ADDR_EXPR using the
6094 decl may already have had TREE_CONSTANT computed.
6095 We still remove the attribute so that assembler code refers
6096 to '&foo rather than '_imp__foo'. */
6097 if (TREE_CODE (old
) == VAR_DECL
&& TREE_ADDRESSABLE (old
))
6098 DECL_DLLIMPORT_P (new_tree
) = 1;
6101 /* Let an inline definition silently override the external reference,
6102 but otherwise warn about attribute inconsistency. */
6103 else if (TREE_CODE (new_tree
) == VAR_DECL
6104 || !DECL_DECLARED_INLINE_P (new_tree
))
6105 warning (OPT_Wattributes
, "%q+D redeclared without dllimport attribute: "
6106 "previous dllimport ignored", new_tree
);
6109 delete_dllimport_p
= 0;
6111 a
= merge_attributes (DECL_ATTRIBUTES (old
), DECL_ATTRIBUTES (new_tree
));
6113 if (delete_dllimport_p
)
6114 a
= remove_attribute ("dllimport", a
);
6119 /* Handle a "dllimport" or "dllexport" attribute; arguments as in
6120 struct attribute_spec.handler. */
6123 handle_dll_attribute (tree
* pnode
, tree name
, tree args
, int flags
,
6129 /* These attributes may apply to structure and union types being created,
6130 but otherwise should pass to the declaration involved. */
6133 if (flags
& ((int) ATTR_FLAG_DECL_NEXT
| (int) ATTR_FLAG_FUNCTION_NEXT
6134 | (int) ATTR_FLAG_ARRAY_NEXT
))
6136 *no_add_attrs
= true;
6137 return tree_cons (name
, args
, NULL_TREE
);
6139 if (TREE_CODE (node
) == RECORD_TYPE
6140 || TREE_CODE (node
) == UNION_TYPE
)
6142 node
= TYPE_NAME (node
);
6148 warning (OPT_Wattributes
, "%qE attribute ignored",
6150 *no_add_attrs
= true;
6155 if (TREE_CODE (node
) != FUNCTION_DECL
6156 && TREE_CODE (node
) != VAR_DECL
6157 && TREE_CODE (node
) != TYPE_DECL
)
6159 *no_add_attrs
= true;
6160 warning (OPT_Wattributes
, "%qE attribute ignored",
6165 if (TREE_CODE (node
) == TYPE_DECL
6166 && TREE_CODE (TREE_TYPE (node
)) != RECORD_TYPE
6167 && TREE_CODE (TREE_TYPE (node
)) != UNION_TYPE
)
6169 *no_add_attrs
= true;
6170 warning (OPT_Wattributes
, "%qE attribute ignored",
6175 is_dllimport
= is_attribute_p ("dllimport", name
);
6177 /* Report error on dllimport ambiguities seen now before they cause
6181 /* Honor any target-specific overrides. */
6182 if (!targetm
.valid_dllimport_attribute_p (node
))
6183 *no_add_attrs
= true;
6185 else if (TREE_CODE (node
) == FUNCTION_DECL
6186 && DECL_DECLARED_INLINE_P (node
))
6188 warning (OPT_Wattributes
, "inline function %q+D declared as "
6189 " dllimport: attribute ignored", node
);
6190 *no_add_attrs
= true;
6192 /* Like MS, treat definition of dllimported variables and
6193 non-inlined functions on declaration as syntax errors. */
6194 else if (TREE_CODE (node
) == FUNCTION_DECL
&& DECL_INITIAL (node
))
6196 error ("function %q+D definition is marked dllimport", node
);
6197 *no_add_attrs
= true;
6200 else if (TREE_CODE (node
) == VAR_DECL
)
6202 if (DECL_INITIAL (node
))
6204 error ("variable %q+D definition is marked dllimport",
6206 *no_add_attrs
= true;
6209 /* `extern' needn't be specified with dllimport.
6210 Specify `extern' now and hope for the best. Sigh. */
6211 DECL_EXTERNAL (node
) = 1;
6212 /* Also, implicitly give dllimport'd variables declared within
6213 a function global scope, unless declared static. */
6214 if (current_function_decl
!= NULL_TREE
&& !TREE_STATIC (node
))
6215 TREE_PUBLIC (node
) = 1;
6218 if (*no_add_attrs
== false)
6219 DECL_DLLIMPORT_P (node
) = 1;
6221 else if (TREE_CODE (node
) == FUNCTION_DECL
6222 && DECL_DECLARED_INLINE_P (node
)
6223 && flag_keep_inline_dllexport
)
6224 /* An exported function, even if inline, must be emitted. */
6225 DECL_EXTERNAL (node
) = 0;
6227 /* Report error if symbol is not accessible at global scope. */
6228 if (!TREE_PUBLIC (node
)
6229 && (TREE_CODE (node
) == VAR_DECL
6230 || TREE_CODE (node
) == FUNCTION_DECL
))
6232 error ("external linkage required for symbol %q+D because of "
6233 "%qE attribute", node
, name
);
6234 *no_add_attrs
= true;
6237 /* A dllexport'd entity must have default visibility so that other
6238 program units (shared libraries or the main executable) can see
6239 it. A dllimport'd entity must have default visibility so that
6240 the linker knows that undefined references within this program
6241 unit can be resolved by the dynamic linker. */
6244 if (DECL_VISIBILITY_SPECIFIED (node
)
6245 && DECL_VISIBILITY (node
) != VISIBILITY_DEFAULT
)
6246 error ("%qE implies default visibility, but %qD has already "
6247 "been declared with a different visibility",
6249 DECL_VISIBILITY (node
) = VISIBILITY_DEFAULT
;
6250 DECL_VISIBILITY_SPECIFIED (node
) = 1;
6256 #endif /* TARGET_DLLIMPORT_DECL_ATTRIBUTES */
6258 /* Set the type qualifiers for TYPE to TYPE_QUALS, which is a bitmask
6259 of the various TYPE_QUAL values. */
6262 set_type_quals (tree type
, int type_quals
)
6264 TYPE_READONLY (type
) = (type_quals
& TYPE_QUAL_CONST
) != 0;
6265 TYPE_VOLATILE (type
) = (type_quals
& TYPE_QUAL_VOLATILE
) != 0;
6266 TYPE_RESTRICT (type
) = (type_quals
& TYPE_QUAL_RESTRICT
) != 0;
6267 TYPE_ATOMIC (type
) = (type_quals
& TYPE_QUAL_ATOMIC
) != 0;
6268 TYPE_ADDR_SPACE (type
) = DECODE_QUAL_ADDR_SPACE (type_quals
);
6271 /* Returns true iff unqualified CAND and BASE are equivalent. */
6274 check_base_type (const_tree cand
, const_tree base
)
6276 return (TYPE_NAME (cand
) == TYPE_NAME (base
)
6277 /* Apparently this is needed for Objective-C. */
6278 && TYPE_CONTEXT (cand
) == TYPE_CONTEXT (base
)
6279 /* Check alignment. */
6280 && TYPE_ALIGN (cand
) == TYPE_ALIGN (base
)
6281 && attribute_list_equal (TYPE_ATTRIBUTES (cand
),
6282 TYPE_ATTRIBUTES (base
)));
6285 /* Returns true iff CAND is equivalent to BASE with TYPE_QUALS. */
6288 check_qualified_type (const_tree cand
, const_tree base
, int type_quals
)
6290 return (TYPE_QUALS (cand
) == type_quals
6291 && check_base_type (cand
, base
));
6294 /* Returns true iff CAND is equivalent to BASE with ALIGN. */
6297 check_aligned_type (const_tree cand
, const_tree base
, unsigned int align
)
6299 return (TYPE_QUALS (cand
) == TYPE_QUALS (base
)
6300 && TYPE_NAME (cand
) == TYPE_NAME (base
)
6301 /* Apparently this is needed for Objective-C. */
6302 && TYPE_CONTEXT (cand
) == TYPE_CONTEXT (base
)
6303 /* Check alignment. */
6304 && TYPE_ALIGN (cand
) == align
6305 && attribute_list_equal (TYPE_ATTRIBUTES (cand
),
6306 TYPE_ATTRIBUTES (base
)));
6309 /* This function checks to see if TYPE matches the size one of the built-in
6310 atomic types, and returns that core atomic type. */
6313 find_atomic_core_type (tree type
)
6315 tree base_atomic_type
;
6317 /* Only handle complete types. */
6318 if (TYPE_SIZE (type
) == NULL_TREE
)
6321 HOST_WIDE_INT type_size
= tree_to_uhwi (TYPE_SIZE (type
));
6325 base_atomic_type
= atomicQI_type_node
;
6329 base_atomic_type
= atomicHI_type_node
;
6333 base_atomic_type
= atomicSI_type_node
;
6337 base_atomic_type
= atomicDI_type_node
;
6341 base_atomic_type
= atomicTI_type_node
;
6345 base_atomic_type
= NULL_TREE
;
6348 return base_atomic_type
;
6351 /* Return a version of the TYPE, qualified as indicated by the
6352 TYPE_QUALS, if one exists. If no qualified version exists yet,
6353 return NULL_TREE. */
6356 get_qualified_type (tree type
, int type_quals
)
6360 if (TYPE_QUALS (type
) == type_quals
)
6363 /* Search the chain of variants to see if there is already one there just
6364 like the one we need to have. If so, use that existing one. We must
6365 preserve the TYPE_NAME, since there is code that depends on this. */
6366 for (t
= TYPE_MAIN_VARIANT (type
); t
; t
= TYPE_NEXT_VARIANT (t
))
6367 if (check_qualified_type (t
, type
, type_quals
))
6373 /* Like get_qualified_type, but creates the type if it does not
6374 exist. This function never returns NULL_TREE. */
6377 build_qualified_type (tree type
, int type_quals
)
6381 /* See if we already have the appropriate qualified variant. */
6382 t
= get_qualified_type (type
, type_quals
);
6384 /* If not, build it. */
6387 t
= build_variant_type_copy (type
);
6388 set_type_quals (t
, type_quals
);
6390 if (((type_quals
& TYPE_QUAL_ATOMIC
) == TYPE_QUAL_ATOMIC
))
6392 /* See if this object can map to a basic atomic type. */
6393 tree atomic_type
= find_atomic_core_type (type
);
6396 /* Ensure the alignment of this type is compatible with
6397 the required alignment of the atomic type. */
6398 if (TYPE_ALIGN (atomic_type
) > TYPE_ALIGN (t
))
6399 TYPE_ALIGN (t
) = TYPE_ALIGN (atomic_type
);
6403 if (TYPE_STRUCTURAL_EQUALITY_P (type
))
6404 /* Propagate structural equality. */
6405 SET_TYPE_STRUCTURAL_EQUALITY (t
);
6406 else if (TYPE_CANONICAL (type
) != type
)
6407 /* Build the underlying canonical type, since it is different
6410 tree c
= build_qualified_type (TYPE_CANONICAL (type
), type_quals
);
6411 TYPE_CANONICAL (t
) = TYPE_CANONICAL (c
);
6414 /* T is its own canonical type. */
6415 TYPE_CANONICAL (t
) = t
;
6422 /* Create a variant of type T with alignment ALIGN. */
6425 build_aligned_type (tree type
, unsigned int align
)
6429 if (TYPE_PACKED (type
)
6430 || TYPE_ALIGN (type
) == align
)
6433 for (t
= TYPE_MAIN_VARIANT (type
); t
; t
= TYPE_NEXT_VARIANT (t
))
6434 if (check_aligned_type (t
, type
, align
))
6437 t
= build_variant_type_copy (type
);
6438 TYPE_ALIGN (t
) = align
;
6443 /* Create a new distinct copy of TYPE. The new type is made its own
6444 MAIN_VARIANT. If TYPE requires structural equality checks, the
6445 resulting type requires structural equality checks; otherwise, its
6446 TYPE_CANONICAL points to itself. */
6449 build_distinct_type_copy (tree type
)
6451 tree t
= copy_node (type
);
6453 TYPE_POINTER_TO (t
) = 0;
6454 TYPE_REFERENCE_TO (t
) = 0;
6456 /* Set the canonical type either to a new equivalence class, or
6457 propagate the need for structural equality checks. */
6458 if (TYPE_STRUCTURAL_EQUALITY_P (type
))
6459 SET_TYPE_STRUCTURAL_EQUALITY (t
);
6461 TYPE_CANONICAL (t
) = t
;
6463 /* Make it its own variant. */
6464 TYPE_MAIN_VARIANT (t
) = t
;
6465 TYPE_NEXT_VARIANT (t
) = 0;
6467 /* Note that it is now possible for TYPE_MIN_VALUE to be a value
6468 whose TREE_TYPE is not t. This can also happen in the Ada
6469 frontend when using subtypes. */
6474 /* Create a new variant of TYPE, equivalent but distinct. This is so
6475 the caller can modify it. TYPE_CANONICAL for the return type will
6476 be equivalent to TYPE_CANONICAL of TYPE, indicating that the types
6477 are considered equal by the language itself (or that both types
6478 require structural equality checks). */
6481 build_variant_type_copy (tree type
)
6483 tree t
, m
= TYPE_MAIN_VARIANT (type
);
6485 t
= build_distinct_type_copy (type
);
6487 /* Since we're building a variant, assume that it is a non-semantic
6488 variant. This also propagates TYPE_STRUCTURAL_EQUALITY_P. */
6489 TYPE_CANONICAL (t
) = TYPE_CANONICAL (type
);
6491 /* Add the new type to the chain of variants of TYPE. */
6492 TYPE_NEXT_VARIANT (t
) = TYPE_NEXT_VARIANT (m
);
6493 TYPE_NEXT_VARIANT (m
) = t
;
6494 TYPE_MAIN_VARIANT (t
) = m
;
6499 /* Return true if the from tree in both tree maps are equal. */
6502 tree_map_base_eq (const void *va
, const void *vb
)
6504 const struct tree_map_base
*const a
= (const struct tree_map_base
*) va
,
6505 *const b
= (const struct tree_map_base
*) vb
;
6506 return (a
->from
== b
->from
);
6509 /* Hash a from tree in a tree_base_map. */
6512 tree_map_base_hash (const void *item
)
6514 return htab_hash_pointer (((const struct tree_map_base
*)item
)->from
);
6517 /* Return true if this tree map structure is marked for garbage collection
6518 purposes. We simply return true if the from tree is marked, so that this
6519 structure goes away when the from tree goes away. */
6522 tree_map_base_marked_p (const void *p
)
6524 return ggc_marked_p (((const struct tree_map_base
*) p
)->from
);
6527 /* Hash a from tree in a tree_map. */
6530 tree_map_hash (const void *item
)
6532 return (((const struct tree_map
*) item
)->hash
);
6535 /* Hash a from tree in a tree_decl_map. */
6538 tree_decl_map_hash (const void *item
)
6540 return DECL_UID (((const struct tree_decl_map
*) item
)->base
.from
);
6543 /* Return the initialization priority for DECL. */
6546 decl_init_priority_lookup (tree decl
)
6548 symtab_node
*snode
= symtab_node::get (decl
);
6551 return DEFAULT_INIT_PRIORITY
;
6553 snode
->get_init_priority ();
6556 /* Return the finalization priority for DECL. */
6559 decl_fini_priority_lookup (tree decl
)
6561 cgraph_node
*node
= cgraph_node::get (decl
);
6564 return DEFAULT_INIT_PRIORITY
;
6566 node
->get_fini_priority ();
6569 /* Set the initialization priority for DECL to PRIORITY. */
6572 decl_init_priority_insert (tree decl
, priority_type priority
)
6574 struct symtab_node
*snode
;
6576 if (priority
== DEFAULT_INIT_PRIORITY
)
6578 snode
= symtab_node::get (decl
);
6582 else if (TREE_CODE (decl
) == VAR_DECL
)
6583 snode
= varpool_node::get_create (decl
);
6585 snode
= cgraph_node::get_create (decl
);
6586 snode
->set_init_priority (priority
);
6589 /* Set the finalization priority for DECL to PRIORITY. */
6592 decl_fini_priority_insert (tree decl
, priority_type priority
)
6594 struct cgraph_node
*node
;
6596 if (priority
== DEFAULT_INIT_PRIORITY
)
6598 node
= cgraph_node::get (decl
);
6603 node
= cgraph_node::get_create (decl
);
6604 node
->set_fini_priority (priority
);
6607 /* Print out the statistics for the DECL_DEBUG_EXPR hash table. */
6610 print_debug_expr_statistics (void)
6612 fprintf (stderr
, "DECL_DEBUG_EXPR hash: size %ld, %ld elements, %f collisions\n",
6613 (long) debug_expr_for_decl
->size (),
6614 (long) debug_expr_for_decl
->elements (),
6615 debug_expr_for_decl
->collisions ());
6618 /* Print out the statistics for the DECL_VALUE_EXPR hash table. */
6621 print_value_expr_statistics (void)
6623 fprintf (stderr
, "DECL_VALUE_EXPR hash: size %ld, %ld elements, %f collisions\n",
6624 (long) value_expr_for_decl
->size (),
6625 (long) value_expr_for_decl
->elements (),
6626 value_expr_for_decl
->collisions ());
6629 /* Lookup a debug expression for FROM, and return it if we find one. */
6632 decl_debug_expr_lookup (tree from
)
6634 struct tree_decl_map
*h
, in
;
6635 in
.base
.from
= from
;
6637 h
= debug_expr_for_decl
->find_with_hash (&in
, DECL_UID (from
));
6643 /* Insert a mapping FROM->TO in the debug expression hashtable. */
6646 decl_debug_expr_insert (tree from
, tree to
)
6648 struct tree_decl_map
*h
;
6650 h
= ggc_alloc
<tree_decl_map
> ();
6651 h
->base
.from
= from
;
6653 *debug_expr_for_decl
->find_slot_with_hash (h
, DECL_UID (from
), INSERT
) = h
;
6656 /* Lookup a value expression for FROM, and return it if we find one. */
6659 decl_value_expr_lookup (tree from
)
6661 struct tree_decl_map
*h
, in
;
6662 in
.base
.from
= from
;
6664 h
= value_expr_for_decl
->find_with_hash (&in
, DECL_UID (from
));
6670 /* Insert a mapping FROM->TO in the value expression hashtable. */
6673 decl_value_expr_insert (tree from
, tree to
)
6675 struct tree_decl_map
*h
;
6677 h
= ggc_alloc
<tree_decl_map
> ();
6678 h
->base
.from
= from
;
6680 *value_expr_for_decl
->find_slot_with_hash (h
, DECL_UID (from
), INSERT
) = h
;
6683 /* Lookup a vector of debug arguments for FROM, and return it if we
6687 decl_debug_args_lookup (tree from
)
6689 struct tree_vec_map
*h
, in
;
6691 if (!DECL_HAS_DEBUG_ARGS_P (from
))
6693 gcc_checking_assert (debug_args_for_decl
!= NULL
);
6694 in
.base
.from
= from
;
6695 h
= debug_args_for_decl
->find_with_hash (&in
, DECL_UID (from
));
6701 /* Insert a mapping FROM->empty vector of debug arguments in the value
6702 expression hashtable. */
6705 decl_debug_args_insert (tree from
)
6707 struct tree_vec_map
*h
;
6710 if (DECL_HAS_DEBUG_ARGS_P (from
))
6711 return decl_debug_args_lookup (from
);
6712 if (debug_args_for_decl
== NULL
)
6713 debug_args_for_decl
= hash_table
<tree_vec_map_cache_hasher
>::create_ggc (64);
6714 h
= ggc_alloc
<tree_vec_map
> ();
6715 h
->base
.from
= from
;
6717 loc
= debug_args_for_decl
->find_slot_with_hash (h
, DECL_UID (from
), INSERT
);
6719 DECL_HAS_DEBUG_ARGS_P (from
) = 1;
6723 /* Hashing of types so that we don't make duplicates.
6724 The entry point is `type_hash_canon'. */
6726 /* Compute a hash code for a list of types (chain of TREE_LIST nodes
6727 with types in the TREE_VALUE slots), by adding the hash codes
6728 of the individual types. */
6731 type_hash_list (const_tree list
, inchash::hash
&hstate
)
6735 for (tail
= list
; tail
; tail
= TREE_CHAIN (tail
))
6736 if (TREE_VALUE (tail
) != error_mark_node
)
6737 hstate
.add_object (TYPE_HASH (TREE_VALUE (tail
)));
6740 /* These are the Hashtable callback functions. */
6742 /* Returns true iff the types are equivalent. */
6745 type_cache_hasher::equal (type_hash
*a
, type_hash
*b
)
6747 /* First test the things that are the same for all types. */
6748 if (a
->hash
!= b
->hash
6749 || TREE_CODE (a
->type
) != TREE_CODE (b
->type
)
6750 || TREE_TYPE (a
->type
) != TREE_TYPE (b
->type
)
6751 || !attribute_list_equal (TYPE_ATTRIBUTES (a
->type
),
6752 TYPE_ATTRIBUTES (b
->type
))
6753 || (TREE_CODE (a
->type
) != COMPLEX_TYPE
6754 && TYPE_NAME (a
->type
) != TYPE_NAME (b
->type
)))
6757 /* Be careful about comparing arrays before and after the element type
6758 has been completed; don't compare TYPE_ALIGN unless both types are
6760 if (COMPLETE_TYPE_P (a
->type
) && COMPLETE_TYPE_P (b
->type
)
6761 && (TYPE_ALIGN (a
->type
) != TYPE_ALIGN (b
->type
)
6762 || TYPE_MODE (a
->type
) != TYPE_MODE (b
->type
)))
6765 switch (TREE_CODE (a
->type
))
6770 case REFERENCE_TYPE
:
6775 return TYPE_VECTOR_SUBPARTS (a
->type
) == TYPE_VECTOR_SUBPARTS (b
->type
);
6778 if (TYPE_VALUES (a
->type
) != TYPE_VALUES (b
->type
)
6779 && !(TYPE_VALUES (a
->type
)
6780 && TREE_CODE (TYPE_VALUES (a
->type
)) == TREE_LIST
6781 && TYPE_VALUES (b
->type
)
6782 && TREE_CODE (TYPE_VALUES (b
->type
)) == TREE_LIST
6783 && type_list_equal (TYPE_VALUES (a
->type
),
6784 TYPE_VALUES (b
->type
))))
6787 /* ... fall through ... */
6792 if (TYPE_PRECISION (a
->type
) != TYPE_PRECISION (b
->type
))
6794 return ((TYPE_MAX_VALUE (a
->type
) == TYPE_MAX_VALUE (b
->type
)
6795 || tree_int_cst_equal (TYPE_MAX_VALUE (a
->type
),
6796 TYPE_MAX_VALUE (b
->type
)))
6797 && (TYPE_MIN_VALUE (a
->type
) == TYPE_MIN_VALUE (b
->type
)
6798 || tree_int_cst_equal (TYPE_MIN_VALUE (a
->type
),
6799 TYPE_MIN_VALUE (b
->type
))));
6801 case FIXED_POINT_TYPE
:
6802 return TYPE_SATURATING (a
->type
) == TYPE_SATURATING (b
->type
);
6805 return TYPE_OFFSET_BASETYPE (a
->type
) == TYPE_OFFSET_BASETYPE (b
->type
);
6808 if (TYPE_METHOD_BASETYPE (a
->type
) == TYPE_METHOD_BASETYPE (b
->type
)
6809 && (TYPE_ARG_TYPES (a
->type
) == TYPE_ARG_TYPES (b
->type
)
6810 || (TYPE_ARG_TYPES (a
->type
)
6811 && TREE_CODE (TYPE_ARG_TYPES (a
->type
)) == TREE_LIST
6812 && TYPE_ARG_TYPES (b
->type
)
6813 && TREE_CODE (TYPE_ARG_TYPES (b
->type
)) == TREE_LIST
6814 && type_list_equal (TYPE_ARG_TYPES (a
->type
),
6815 TYPE_ARG_TYPES (b
->type
)))))
6819 return TYPE_DOMAIN (a
->type
) == TYPE_DOMAIN (b
->type
);
6823 case QUAL_UNION_TYPE
:
6824 return (TYPE_FIELDS (a
->type
) == TYPE_FIELDS (b
->type
)
6825 || (TYPE_FIELDS (a
->type
)
6826 && TREE_CODE (TYPE_FIELDS (a
->type
)) == TREE_LIST
6827 && TYPE_FIELDS (b
->type
)
6828 && TREE_CODE (TYPE_FIELDS (b
->type
)) == TREE_LIST
6829 && type_list_equal (TYPE_FIELDS (a
->type
),
6830 TYPE_FIELDS (b
->type
))));
6833 if (TYPE_ARG_TYPES (a
->type
) == TYPE_ARG_TYPES (b
->type
)
6834 || (TYPE_ARG_TYPES (a
->type
)
6835 && TREE_CODE (TYPE_ARG_TYPES (a
->type
)) == TREE_LIST
6836 && TYPE_ARG_TYPES (b
->type
)
6837 && TREE_CODE (TYPE_ARG_TYPES (b
->type
)) == TREE_LIST
6838 && type_list_equal (TYPE_ARG_TYPES (a
->type
),
6839 TYPE_ARG_TYPES (b
->type
))))
6847 if (lang_hooks
.types
.type_hash_eq
!= NULL
)
6848 return lang_hooks
.types
.type_hash_eq (a
->type
, b
->type
);
6853 /* Given TYPE, and HASHCODE its hash code, return the canonical
6854 object for an identical type if one already exists.
6855 Otherwise, return TYPE, and record it as the canonical object.
6857 To use this function, first create a type of the sort you want.
6858 Then compute its hash code from the fields of the type that
6859 make it different from other similar types.
6860 Then call this function and use the value. */
6863 type_hash_canon (unsigned int hashcode
, tree type
)
6868 /* The hash table only contains main variants, so ensure that's what we're
6870 gcc_assert (TYPE_MAIN_VARIANT (type
) == type
);
6872 /* The TYPE_ALIGN field of a type is set by layout_type(), so we
6873 must call that routine before comparing TYPE_ALIGNs. */
6879 loc
= type_hash_table
->find_slot_with_hash (&in
, hashcode
, INSERT
);
6882 tree t1
= ((type_hash
*) *loc
)->type
;
6883 gcc_assert (TYPE_MAIN_VARIANT (t1
) == t1
);
6884 if (GATHER_STATISTICS
)
6886 tree_code_counts
[(int) TREE_CODE (type
)]--;
6887 tree_node_counts
[(int) t_kind
]--;
6888 tree_node_sizes
[(int) t_kind
] -= sizeof (struct tree_type_non_common
);
6894 struct type_hash
*h
;
6896 h
= ggc_alloc
<type_hash
> ();
6906 print_type_hash_statistics (void)
6908 fprintf (stderr
, "Type hash: size %ld, %ld elements, %f collisions\n",
6909 (long) type_hash_table
->size (),
6910 (long) type_hash_table
->elements (),
6911 type_hash_table
->collisions ());
6914 /* Compute a hash code for a list of attributes (chain of TREE_LIST nodes
6915 with names in the TREE_PURPOSE slots and args in the TREE_VALUE slots),
6916 by adding the hash codes of the individual attributes. */
6919 attribute_hash_list (const_tree list
, inchash::hash
&hstate
)
6923 for (tail
= list
; tail
; tail
= TREE_CHAIN (tail
))
6924 /* ??? Do we want to add in TREE_VALUE too? */
6925 hstate
.add_object (IDENTIFIER_HASH_VALUE (get_attribute_name (tail
)));
6928 /* Given two lists of attributes, return true if list l2 is
6929 equivalent to l1. */
6932 attribute_list_equal (const_tree l1
, const_tree l2
)
6937 return attribute_list_contained (l1
, l2
)
6938 && attribute_list_contained (l2
, l1
);
6941 /* Given two lists of attributes, return true if list L2 is
6942 completely contained within L1. */
6943 /* ??? This would be faster if attribute names were stored in a canonicalized
6944 form. Otherwise, if L1 uses `foo' and L2 uses `__foo__', the long method
6945 must be used to show these elements are equivalent (which they are). */
6946 /* ??? It's not clear that attributes with arguments will always be handled
6950 attribute_list_contained (const_tree l1
, const_tree l2
)
6954 /* First check the obvious, maybe the lists are identical. */
6958 /* Maybe the lists are similar. */
6959 for (t1
= l1
, t2
= l2
;
6961 && get_attribute_name (t1
) == get_attribute_name (t2
)
6962 && TREE_VALUE (t1
) == TREE_VALUE (t2
);
6963 t1
= TREE_CHAIN (t1
), t2
= TREE_CHAIN (t2
))
6966 /* Maybe the lists are equal. */
6967 if (t1
== 0 && t2
== 0)
6970 for (; t2
!= 0; t2
= TREE_CHAIN (t2
))
6973 /* This CONST_CAST is okay because lookup_attribute does not
6974 modify its argument and the return value is assigned to a
6976 for (attr
= lookup_ident_attribute (get_attribute_name (t2
),
6977 CONST_CAST_TREE (l1
));
6978 attr
!= NULL_TREE
&& !attribute_value_equal (t2
, attr
);
6979 attr
= lookup_ident_attribute (get_attribute_name (t2
),
6983 if (attr
== NULL_TREE
)
6990 /* Given two lists of types
6991 (chains of TREE_LIST nodes with types in the TREE_VALUE slots)
6992 return 1 if the lists contain the same types in the same order.
6993 Also, the TREE_PURPOSEs must match. */
6996 type_list_equal (const_tree l1
, const_tree l2
)
7000 for (t1
= l1
, t2
= l2
; t1
&& t2
; t1
= TREE_CHAIN (t1
), t2
= TREE_CHAIN (t2
))
7001 if (TREE_VALUE (t1
) != TREE_VALUE (t2
)
7002 || (TREE_PURPOSE (t1
) != TREE_PURPOSE (t2
)
7003 && ! (1 == simple_cst_equal (TREE_PURPOSE (t1
), TREE_PURPOSE (t2
))
7004 && (TREE_TYPE (TREE_PURPOSE (t1
))
7005 == TREE_TYPE (TREE_PURPOSE (t2
))))))
7011 /* Returns the number of arguments to the FUNCTION_TYPE or METHOD_TYPE
7012 given by TYPE. If the argument list accepts variable arguments,
7013 then this function counts only the ordinary arguments. */
7016 type_num_arguments (const_tree type
)
7021 for (t
= TYPE_ARG_TYPES (type
); t
; t
= TREE_CHAIN (t
))
7022 /* If the function does not take a variable number of arguments,
7023 the last element in the list will have type `void'. */
7024 if (VOID_TYPE_P (TREE_VALUE (t
)))
7032 /* Nonzero if integer constants T1 and T2
7033 represent the same constant value. */
7036 tree_int_cst_equal (const_tree t1
, const_tree t2
)
7041 if (t1
== 0 || t2
== 0)
7044 if (TREE_CODE (t1
) == INTEGER_CST
7045 && TREE_CODE (t2
) == INTEGER_CST
7046 && wi::to_widest (t1
) == wi::to_widest (t2
))
7052 /* Return true if T is an INTEGER_CST whose numerical value (extended
7053 according to TYPE_UNSIGNED) fits in a signed HOST_WIDE_INT. */
7056 tree_fits_shwi_p (const_tree t
)
7058 return (t
!= NULL_TREE
7059 && TREE_CODE (t
) == INTEGER_CST
7060 && wi::fits_shwi_p (wi::to_widest (t
)));
7063 /* Return true if T is an INTEGER_CST whose numerical value (extended
7064 according to TYPE_UNSIGNED) fits in an unsigned HOST_WIDE_INT. */
7067 tree_fits_uhwi_p (const_tree t
)
7069 return (t
!= NULL_TREE
7070 && TREE_CODE (t
) == INTEGER_CST
7071 && wi::fits_uhwi_p (wi::to_widest (t
)));
7074 /* T is an INTEGER_CST whose numerical value (extended according to
7075 TYPE_UNSIGNED) fits in a signed HOST_WIDE_INT. Return that
7079 tree_to_shwi (const_tree t
)
7081 gcc_assert (tree_fits_shwi_p (t
));
7082 return TREE_INT_CST_LOW (t
);
7085 /* T is an INTEGER_CST whose numerical value (extended according to
7086 TYPE_UNSIGNED) fits in an unsigned HOST_WIDE_INT. Return that
7089 unsigned HOST_WIDE_INT
7090 tree_to_uhwi (const_tree t
)
7092 gcc_assert (tree_fits_uhwi_p (t
));
7093 return TREE_INT_CST_LOW (t
);
7096 /* Return the most significant (sign) bit of T. */
7099 tree_int_cst_sign_bit (const_tree t
)
7101 unsigned bitno
= TYPE_PRECISION (TREE_TYPE (t
)) - 1;
7103 return wi::extract_uhwi (t
, bitno
, 1);
7106 /* Return an indication of the sign of the integer constant T.
7107 The return value is -1 if T < 0, 0 if T == 0, and 1 if T > 0.
7108 Note that -1 will never be returned if T's type is unsigned. */
7111 tree_int_cst_sgn (const_tree t
)
7113 if (wi::eq_p (t
, 0))
7115 else if (TYPE_UNSIGNED (TREE_TYPE (t
)))
7117 else if (wi::neg_p (t
))
7123 /* Return the minimum number of bits needed to represent VALUE in a
7124 signed or unsigned type, UNSIGNEDP says which. */
7127 tree_int_cst_min_precision (tree value
, signop sgn
)
7129 /* If the value is negative, compute its negative minus 1. The latter
7130 adjustment is because the absolute value of the largest negative value
7131 is one larger than the largest positive value. This is equivalent to
7132 a bit-wise negation, so use that operation instead. */
7134 if (tree_int_cst_sgn (value
) < 0)
7135 value
= fold_build1 (BIT_NOT_EXPR
, TREE_TYPE (value
), value
);
7137 /* Return the number of bits needed, taking into account the fact
7138 that we need one more bit for a signed than unsigned type.
7139 If value is 0 or -1, the minimum precision is 1 no matter
7140 whether unsignedp is true or false. */
7142 if (integer_zerop (value
))
7145 return tree_floor_log2 (value
) + 1 + (sgn
== SIGNED
? 1 : 0) ;
7148 /* Return truthvalue of whether T1 is the same tree structure as T2.
7149 Return 1 if they are the same.
7150 Return 0 if they are understandably different.
7151 Return -1 if either contains tree structure not understood by
7155 simple_cst_equal (const_tree t1
, const_tree t2
)
7157 enum tree_code code1
, code2
;
7163 if (t1
== 0 || t2
== 0)
7166 code1
= TREE_CODE (t1
);
7167 code2
= TREE_CODE (t2
);
7169 if (CONVERT_EXPR_CODE_P (code1
) || code1
== NON_LVALUE_EXPR
)
7171 if (CONVERT_EXPR_CODE_P (code2
)
7172 || code2
== NON_LVALUE_EXPR
)
7173 return simple_cst_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
7175 return simple_cst_equal (TREE_OPERAND (t1
, 0), t2
);
7178 else if (CONVERT_EXPR_CODE_P (code2
)
7179 || code2
== NON_LVALUE_EXPR
)
7180 return simple_cst_equal (t1
, TREE_OPERAND (t2
, 0));
7188 return wi::to_widest (t1
) == wi::to_widest (t2
);
7191 return REAL_VALUES_IDENTICAL (TREE_REAL_CST (t1
), TREE_REAL_CST (t2
));
7194 return FIXED_VALUES_IDENTICAL (TREE_FIXED_CST (t1
), TREE_FIXED_CST (t2
));
7197 return (TREE_STRING_LENGTH (t1
) == TREE_STRING_LENGTH (t2
)
7198 && ! memcmp (TREE_STRING_POINTER (t1
), TREE_STRING_POINTER (t2
),
7199 TREE_STRING_LENGTH (t1
)));
7203 unsigned HOST_WIDE_INT idx
;
7204 vec
<constructor_elt
, va_gc
> *v1
= CONSTRUCTOR_ELTS (t1
);
7205 vec
<constructor_elt
, va_gc
> *v2
= CONSTRUCTOR_ELTS (t2
);
7207 if (vec_safe_length (v1
) != vec_safe_length (v2
))
7210 for (idx
= 0; idx
< vec_safe_length (v1
); ++idx
)
7211 /* ??? Should we handle also fields here? */
7212 if (!simple_cst_equal ((*v1
)[idx
].value
, (*v2
)[idx
].value
))
7218 return simple_cst_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
7221 cmp
= simple_cst_equal (CALL_EXPR_FN (t1
), CALL_EXPR_FN (t2
));
7224 if (call_expr_nargs (t1
) != call_expr_nargs (t2
))
7227 const_tree arg1
, arg2
;
7228 const_call_expr_arg_iterator iter1
, iter2
;
7229 for (arg1
= first_const_call_expr_arg (t1
, &iter1
),
7230 arg2
= first_const_call_expr_arg (t2
, &iter2
);
7232 arg1
= next_const_call_expr_arg (&iter1
),
7233 arg2
= next_const_call_expr_arg (&iter2
))
7235 cmp
= simple_cst_equal (arg1
, arg2
);
7239 return arg1
== arg2
;
7243 /* Special case: if either target is an unallocated VAR_DECL,
7244 it means that it's going to be unified with whatever the
7245 TARGET_EXPR is really supposed to initialize, so treat it
7246 as being equivalent to anything. */
7247 if ((TREE_CODE (TREE_OPERAND (t1
, 0)) == VAR_DECL
7248 && DECL_NAME (TREE_OPERAND (t1
, 0)) == NULL_TREE
7249 && !DECL_RTL_SET_P (TREE_OPERAND (t1
, 0)))
7250 || (TREE_CODE (TREE_OPERAND (t2
, 0)) == VAR_DECL
7251 && DECL_NAME (TREE_OPERAND (t2
, 0)) == NULL_TREE
7252 && !DECL_RTL_SET_P (TREE_OPERAND (t2
, 0))))
7255 cmp
= simple_cst_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
7260 return simple_cst_equal (TREE_OPERAND (t1
, 1), TREE_OPERAND (t2
, 1));
7262 case WITH_CLEANUP_EXPR
:
7263 cmp
= simple_cst_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
7267 return simple_cst_equal (TREE_OPERAND (t1
, 1), TREE_OPERAND (t1
, 1));
7270 if (TREE_OPERAND (t1
, 1) == TREE_OPERAND (t2
, 1))
7271 return simple_cst_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
7285 /* This general rule works for most tree codes. All exceptions should be
7286 handled above. If this is a language-specific tree code, we can't
7287 trust what might be in the operand, so say we don't know
7289 if ((int) code1
>= (int) LAST_AND_UNUSED_TREE_CODE
)
7292 switch (TREE_CODE_CLASS (code1
))
7296 case tcc_comparison
:
7297 case tcc_expression
:
7301 for (i
= 0; i
< TREE_CODE_LENGTH (code1
); i
++)
7303 cmp
= simple_cst_equal (TREE_OPERAND (t1
, i
), TREE_OPERAND (t2
, i
));
7315 /* Compare the value of T, an INTEGER_CST, with U, an unsigned integer value.
7316 Return -1, 0, or 1 if the value of T is less than, equal to, or greater
7317 than U, respectively. */
7320 compare_tree_int (const_tree t
, unsigned HOST_WIDE_INT u
)
7322 if (tree_int_cst_sgn (t
) < 0)
7324 else if (!tree_fits_uhwi_p (t
))
7326 else if (TREE_INT_CST_LOW (t
) == u
)
7328 else if (TREE_INT_CST_LOW (t
) < u
)
7334 /* Return true if SIZE represents a constant size that is in bounds of
7335 what the middle-end and the backend accepts (covering not more than
7336 half of the address-space). */
7339 valid_constant_size_p (const_tree size
)
7341 if (! tree_fits_uhwi_p (size
)
7342 || TREE_OVERFLOW (size
)
7343 || tree_int_cst_sign_bit (size
) != 0)
7348 /* Return the precision of the type, or for a complex or vector type the
7349 precision of the type of its elements. */
7352 element_precision (const_tree type
)
7354 enum tree_code code
= TREE_CODE (type
);
7355 if (code
== COMPLEX_TYPE
|| code
== VECTOR_TYPE
)
7356 type
= TREE_TYPE (type
);
7358 return TYPE_PRECISION (type
);
7361 /* Return true if CODE represents an associative tree code. Otherwise
7364 associative_tree_code (enum tree_code code
)
7383 /* Return true if CODE represents a commutative tree code. Otherwise
7386 commutative_tree_code (enum tree_code code
)
7392 case MULT_HIGHPART_EXPR
:
7400 case UNORDERED_EXPR
:
7404 case TRUTH_AND_EXPR
:
7405 case TRUTH_XOR_EXPR
:
7407 case WIDEN_MULT_EXPR
:
7408 case VEC_WIDEN_MULT_HI_EXPR
:
7409 case VEC_WIDEN_MULT_LO_EXPR
:
7410 case VEC_WIDEN_MULT_EVEN_EXPR
:
7411 case VEC_WIDEN_MULT_ODD_EXPR
:
7420 /* Return true if CODE represents a ternary tree code for which the
7421 first two operands are commutative. Otherwise return false. */
7423 commutative_ternary_tree_code (enum tree_code code
)
7427 case WIDEN_MULT_PLUS_EXPR
:
7428 case WIDEN_MULT_MINUS_EXPR
:
7442 /* Generate a hash value for an expression. This can be used iteratively
7443 by passing a previous result as the HSTATE argument.
7445 This function is intended to produce the same hash for expressions which
7446 would compare equal using operand_equal_p. */
7448 add_expr (const_tree t
, inchash::hash
&hstate
)
7451 enum tree_code code
;
7452 enum tree_code_class tclass
;
7456 hstate
.merge_hash (0);
7460 code
= TREE_CODE (t
);
7464 /* Alas, constants aren't shared, so we can't rely on pointer
7467 hstate
.merge_hash (0);
7470 for (i
= 0; i
< TREE_INT_CST_NUNITS (t
); i
++)
7471 hstate
.add_wide_int (TREE_INT_CST_ELT (t
, i
));
7475 unsigned int val2
= real_hash (TREE_REAL_CST_PTR (t
));
7476 hstate
.merge_hash (val2
);
7481 unsigned int val2
= fixed_hash (TREE_FIXED_CST_PTR (t
));
7482 hstate
.merge_hash (val2
);
7486 hstate
.add ((const void *) TREE_STRING_POINTER (t
), TREE_STRING_LENGTH (t
));
7489 inchash::add_expr (TREE_REALPART (t
), hstate
);
7490 inchash::add_expr (TREE_IMAGPART (t
), hstate
);
7495 for (i
= 0; i
< VECTOR_CST_NELTS (t
); ++i
)
7496 inchash::add_expr (VECTOR_CST_ELT (t
, i
), hstate
);
7500 /* We can just compare by pointer. */
7501 hstate
.add_wide_int (SSA_NAME_VERSION (t
));
7503 case PLACEHOLDER_EXPR
:
7504 /* The node itself doesn't matter. */
7507 /* A list of expressions, for a CALL_EXPR or as the elements of a
7509 for (; t
; t
= TREE_CHAIN (t
))
7510 inchash::add_expr (TREE_VALUE (t
), hstate
);
7514 unsigned HOST_WIDE_INT idx
;
7516 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t
), idx
, field
, value
)
7518 inchash::add_expr (field
, hstate
);
7519 inchash::add_expr (value
, hstate
);
7524 /* When referring to a built-in FUNCTION_DECL, use the __builtin__ form.
7525 Otherwise nodes that compare equal according to operand_equal_p might
7526 get different hash codes. However, don't do this for machine specific
7527 or front end builtins, since the function code is overloaded in those
7529 if (DECL_BUILT_IN_CLASS (t
) == BUILT_IN_NORMAL
7530 && builtin_decl_explicit_p (DECL_FUNCTION_CODE (t
)))
7532 t
= builtin_decl_explicit (DECL_FUNCTION_CODE (t
));
7533 code
= TREE_CODE (t
);
7537 tclass
= TREE_CODE_CLASS (code
);
7539 if (tclass
== tcc_declaration
)
7541 /* DECL's have a unique ID */
7542 hstate
.add_wide_int (DECL_UID (t
));
7546 gcc_assert (IS_EXPR_CODE_CLASS (tclass
));
7548 hstate
.add_object (code
);
7550 /* Don't hash the type, that can lead to having nodes which
7551 compare equal according to operand_equal_p, but which
7552 have different hash codes. */
7553 if (CONVERT_EXPR_CODE_P (code
)
7554 || code
== NON_LVALUE_EXPR
)
7556 /* Make sure to include signness in the hash computation. */
7557 hstate
.add_int (TYPE_UNSIGNED (TREE_TYPE (t
)));
7558 inchash::add_expr (TREE_OPERAND (t
, 0), hstate
);
7561 else if (commutative_tree_code (code
))
7563 /* It's a commutative expression. We want to hash it the same
7564 however it appears. We do this by first hashing both operands
7565 and then rehashing based on the order of their independent
7567 inchash::hash one
, two
;
7568 inchash::add_expr (TREE_OPERAND (t
, 0), one
);
7569 inchash::add_expr (TREE_OPERAND (t
, 1), two
);
7570 hstate
.add_commutative (one
, two
);
7573 for (i
= TREE_OPERAND_LENGTH (t
) - 1; i
>= 0; --i
)
7574 inchash::add_expr (TREE_OPERAND (t
, i
), hstate
);
7582 /* Constructors for pointer, array and function types.
7583 (RECORD_TYPE, UNION_TYPE and ENUMERAL_TYPE nodes are
7584 constructed by language-dependent code, not here.) */
7586 /* Construct, lay out and return the type of pointers to TO_TYPE with
7587 mode MODE. If CAN_ALIAS_ALL is TRUE, indicate this type can
7588 reference all of memory. If such a type has already been
7589 constructed, reuse it. */
7592 build_pointer_type_for_mode (tree to_type
, machine_mode mode
,
7597 if (to_type
== error_mark_node
)
7598 return error_mark_node
;
7600 /* If the pointed-to type has the may_alias attribute set, force
7601 a TYPE_REF_CAN_ALIAS_ALL pointer to be generated. */
7602 if (lookup_attribute ("may_alias", TYPE_ATTRIBUTES (to_type
)))
7603 can_alias_all
= true;
7605 /* In some cases, languages will have things that aren't a POINTER_TYPE
7606 (such as a RECORD_TYPE for fat pointers in Ada) as TYPE_POINTER_TO.
7607 In that case, return that type without regard to the rest of our
7610 ??? This is a kludge, but consistent with the way this function has
7611 always operated and there doesn't seem to be a good way to avoid this
7613 if (TYPE_POINTER_TO (to_type
) != 0
7614 && TREE_CODE (TYPE_POINTER_TO (to_type
)) != POINTER_TYPE
)
7615 return TYPE_POINTER_TO (to_type
);
7617 /* First, if we already have a type for pointers to TO_TYPE and it's
7618 the proper mode, use it. */
7619 for (t
= TYPE_POINTER_TO (to_type
); t
; t
= TYPE_NEXT_PTR_TO (t
))
7620 if (TYPE_MODE (t
) == mode
&& TYPE_REF_CAN_ALIAS_ALL (t
) == can_alias_all
)
7623 t
= make_node (POINTER_TYPE
);
7625 TREE_TYPE (t
) = to_type
;
7626 SET_TYPE_MODE (t
, mode
);
7627 TYPE_REF_CAN_ALIAS_ALL (t
) = can_alias_all
;
7628 TYPE_NEXT_PTR_TO (t
) = TYPE_POINTER_TO (to_type
);
7629 TYPE_POINTER_TO (to_type
) = t
;
7631 if (TYPE_STRUCTURAL_EQUALITY_P (to_type
))
7632 SET_TYPE_STRUCTURAL_EQUALITY (t
);
7633 else if (TYPE_CANONICAL (to_type
) != to_type
)
7635 = build_pointer_type_for_mode (TYPE_CANONICAL (to_type
),
7636 mode
, can_alias_all
);
7638 /* Lay out the type. This function has many callers that are concerned
7639 with expression-construction, and this simplifies them all. */
7645 /* By default build pointers in ptr_mode. */
7648 build_pointer_type (tree to_type
)
7650 addr_space_t as
= to_type
== error_mark_node
? ADDR_SPACE_GENERIC
7651 : TYPE_ADDR_SPACE (to_type
);
7652 machine_mode pointer_mode
= targetm
.addr_space
.pointer_mode (as
);
7653 return build_pointer_type_for_mode (to_type
, pointer_mode
, false);
7656 /* Same as build_pointer_type_for_mode, but for REFERENCE_TYPE. */
7659 build_reference_type_for_mode (tree to_type
, machine_mode mode
,
7664 if (to_type
== error_mark_node
)
7665 return error_mark_node
;
7667 /* If the pointed-to type has the may_alias attribute set, force
7668 a TYPE_REF_CAN_ALIAS_ALL pointer to be generated. */
7669 if (lookup_attribute ("may_alias", TYPE_ATTRIBUTES (to_type
)))
7670 can_alias_all
= true;
7672 /* In some cases, languages will have things that aren't a REFERENCE_TYPE
7673 (such as a RECORD_TYPE for fat pointers in Ada) as TYPE_REFERENCE_TO.
7674 In that case, return that type without regard to the rest of our
7677 ??? This is a kludge, but consistent with the way this function has
7678 always operated and there doesn't seem to be a good way to avoid this
7680 if (TYPE_REFERENCE_TO (to_type
) != 0
7681 && TREE_CODE (TYPE_REFERENCE_TO (to_type
)) != REFERENCE_TYPE
)
7682 return TYPE_REFERENCE_TO (to_type
);
7684 /* First, if we already have a type for pointers to TO_TYPE and it's
7685 the proper mode, use it. */
7686 for (t
= TYPE_REFERENCE_TO (to_type
); t
; t
= TYPE_NEXT_REF_TO (t
))
7687 if (TYPE_MODE (t
) == mode
&& TYPE_REF_CAN_ALIAS_ALL (t
) == can_alias_all
)
7690 t
= make_node (REFERENCE_TYPE
);
7692 TREE_TYPE (t
) = to_type
;
7693 SET_TYPE_MODE (t
, mode
);
7694 TYPE_REF_CAN_ALIAS_ALL (t
) = can_alias_all
;
7695 TYPE_NEXT_REF_TO (t
) = TYPE_REFERENCE_TO (to_type
);
7696 TYPE_REFERENCE_TO (to_type
) = t
;
7698 if (TYPE_STRUCTURAL_EQUALITY_P (to_type
))
7699 SET_TYPE_STRUCTURAL_EQUALITY (t
);
7700 else if (TYPE_CANONICAL (to_type
) != to_type
)
7702 = build_reference_type_for_mode (TYPE_CANONICAL (to_type
),
7703 mode
, can_alias_all
);
7711 /* Build the node for the type of references-to-TO_TYPE by default
7715 build_reference_type (tree to_type
)
7717 addr_space_t as
= to_type
== error_mark_node
? ADDR_SPACE_GENERIC
7718 : TYPE_ADDR_SPACE (to_type
);
7719 machine_mode pointer_mode
= targetm
.addr_space
.pointer_mode (as
);
7720 return build_reference_type_for_mode (to_type
, pointer_mode
, false);
7723 #define MAX_INT_CACHED_PREC \
7724 (HOST_BITS_PER_WIDE_INT > 64 ? HOST_BITS_PER_WIDE_INT : 64)
7725 static GTY(()) tree nonstandard_integer_type_cache
[2 * MAX_INT_CACHED_PREC
+ 2];
7727 /* Builds a signed or unsigned integer type of precision PRECISION.
7728 Used for C bitfields whose precision does not match that of
7729 built-in target types. */
7731 build_nonstandard_integer_type (unsigned HOST_WIDE_INT precision
,
7737 unsignedp
= MAX_INT_CACHED_PREC
+ 1;
7739 if (precision
<= MAX_INT_CACHED_PREC
)
7741 itype
= nonstandard_integer_type_cache
[precision
+ unsignedp
];
7746 itype
= make_node (INTEGER_TYPE
);
7747 TYPE_PRECISION (itype
) = precision
;
7750 fixup_unsigned_type (itype
);
7752 fixup_signed_type (itype
);
7755 if (tree_fits_uhwi_p (TYPE_MAX_VALUE (itype
)))
7756 ret
= type_hash_canon (tree_to_uhwi (TYPE_MAX_VALUE (itype
)), itype
);
7757 if (precision
<= MAX_INT_CACHED_PREC
)
7758 nonstandard_integer_type_cache
[precision
+ unsignedp
] = ret
;
7763 /* Create a range of some discrete type TYPE (an INTEGER_TYPE, ENUMERAL_TYPE
7764 or BOOLEAN_TYPE) with low bound LOWVAL and high bound HIGHVAL. If SHARED
7765 is true, reuse such a type that has already been constructed. */
7768 build_range_type_1 (tree type
, tree lowval
, tree highval
, bool shared
)
7770 tree itype
= make_node (INTEGER_TYPE
);
7771 inchash::hash hstate
;
7773 TREE_TYPE (itype
) = type
;
7775 TYPE_MIN_VALUE (itype
) = fold_convert (type
, lowval
);
7776 TYPE_MAX_VALUE (itype
) = highval
? fold_convert (type
, highval
) : NULL
;
7778 TYPE_PRECISION (itype
) = TYPE_PRECISION (type
);
7779 SET_TYPE_MODE (itype
, TYPE_MODE (type
));
7780 TYPE_SIZE (itype
) = TYPE_SIZE (type
);
7781 TYPE_SIZE_UNIT (itype
) = TYPE_SIZE_UNIT (type
);
7782 TYPE_ALIGN (itype
) = TYPE_ALIGN (type
);
7783 TYPE_USER_ALIGN (itype
) = TYPE_USER_ALIGN (type
);
7788 if ((TYPE_MIN_VALUE (itype
)
7789 && TREE_CODE (TYPE_MIN_VALUE (itype
)) != INTEGER_CST
)
7790 || (TYPE_MAX_VALUE (itype
)
7791 && TREE_CODE (TYPE_MAX_VALUE (itype
)) != INTEGER_CST
))
7793 /* Since we cannot reliably merge this type, we need to compare it using
7794 structural equality checks. */
7795 SET_TYPE_STRUCTURAL_EQUALITY (itype
);
7799 inchash::add_expr (TYPE_MIN_VALUE (itype
), hstate
);
7800 inchash::add_expr (TYPE_MAX_VALUE (itype
), hstate
);
7801 hstate
.merge_hash (TYPE_HASH (type
));
7802 itype
= type_hash_canon (hstate
.end (), itype
);
7807 /* Wrapper around build_range_type_1 with SHARED set to true. */
7810 build_range_type (tree type
, tree lowval
, tree highval
)
7812 return build_range_type_1 (type
, lowval
, highval
, true);
7815 /* Wrapper around build_range_type_1 with SHARED set to false. */
7818 build_nonshared_range_type (tree type
, tree lowval
, tree highval
)
7820 return build_range_type_1 (type
, lowval
, highval
, false);
7823 /* Create a type of integers to be the TYPE_DOMAIN of an ARRAY_TYPE.
7824 MAXVAL should be the maximum value in the domain
7825 (one less than the length of the array).
7827 The maximum value that MAXVAL can have is INT_MAX for a HOST_WIDE_INT.
7828 We don't enforce this limit, that is up to caller (e.g. language front end).
7829 The limit exists because the result is a signed type and we don't handle
7830 sizes that use more than one HOST_WIDE_INT. */
7833 build_index_type (tree maxval
)
7835 return build_range_type (sizetype
, size_zero_node
, maxval
);
7838 /* Return true if the debug information for TYPE, a subtype, should be emitted
7839 as a subrange type. If so, set LOWVAL to the low bound and HIGHVAL to the
7840 high bound, respectively. Sometimes doing so unnecessarily obfuscates the
7841 debug info and doesn't reflect the source code. */
7844 subrange_type_for_debug_p (const_tree type
, tree
*lowval
, tree
*highval
)
7846 tree base_type
= TREE_TYPE (type
), low
, high
;
7848 /* Subrange types have a base type which is an integral type. */
7849 if (!INTEGRAL_TYPE_P (base_type
))
7852 /* Get the real bounds of the subtype. */
7853 if (lang_hooks
.types
.get_subrange_bounds
)
7854 lang_hooks
.types
.get_subrange_bounds (type
, &low
, &high
);
7857 low
= TYPE_MIN_VALUE (type
);
7858 high
= TYPE_MAX_VALUE (type
);
7861 /* If the type and its base type have the same representation and the same
7862 name, then the type is not a subrange but a copy of the base type. */
7863 if ((TREE_CODE (base_type
) == INTEGER_TYPE
7864 || TREE_CODE (base_type
) == BOOLEAN_TYPE
)
7865 && int_size_in_bytes (type
) == int_size_in_bytes (base_type
)
7866 && tree_int_cst_equal (low
, TYPE_MIN_VALUE (base_type
))
7867 && tree_int_cst_equal (high
, TYPE_MAX_VALUE (base_type
))
7868 && TYPE_IDENTIFIER (type
) == TYPE_IDENTIFIER (base_type
))
7878 /* Construct, lay out and return the type of arrays of elements with ELT_TYPE
7879 and number of elements specified by the range of values of INDEX_TYPE.
7880 If SHARED is true, reuse such a type that has already been constructed. */
7883 build_array_type_1 (tree elt_type
, tree index_type
, bool shared
)
7887 if (TREE_CODE (elt_type
) == FUNCTION_TYPE
)
7889 error ("arrays of functions are not meaningful");
7890 elt_type
= integer_type_node
;
7893 t
= make_node (ARRAY_TYPE
);
7894 TREE_TYPE (t
) = elt_type
;
7895 TYPE_DOMAIN (t
) = index_type
;
7896 TYPE_ADDR_SPACE (t
) = TYPE_ADDR_SPACE (elt_type
);
7899 /* If the element type is incomplete at this point we get marked for
7900 structural equality. Do not record these types in the canonical
7902 if (TYPE_STRUCTURAL_EQUALITY_P (t
))
7907 inchash::hash hstate
;
7908 hstate
.add_object (TYPE_HASH (elt_type
));
7910 hstate
.add_object (TYPE_HASH (index_type
));
7911 t
= type_hash_canon (hstate
.end (), t
);
7914 if (TYPE_CANONICAL (t
) == t
)
7916 if (TYPE_STRUCTURAL_EQUALITY_P (elt_type
)
7917 || (index_type
&& TYPE_STRUCTURAL_EQUALITY_P (index_type
)))
7918 SET_TYPE_STRUCTURAL_EQUALITY (t
);
7919 else if (TYPE_CANONICAL (elt_type
) != elt_type
7920 || (index_type
&& TYPE_CANONICAL (index_type
) != index_type
))
7922 = build_array_type_1 (TYPE_CANONICAL (elt_type
),
7924 ? TYPE_CANONICAL (index_type
) : NULL_TREE
,
7931 /* Wrapper around build_array_type_1 with SHARED set to true. */
7934 build_array_type (tree elt_type
, tree index_type
)
7936 return build_array_type_1 (elt_type
, index_type
, true);
7939 /* Wrapper around build_array_type_1 with SHARED set to false. */
7942 build_nonshared_array_type (tree elt_type
, tree index_type
)
7944 return build_array_type_1 (elt_type
, index_type
, false);
7947 /* Return a representation of ELT_TYPE[NELTS], using indices of type
7951 build_array_type_nelts (tree elt_type
, unsigned HOST_WIDE_INT nelts
)
7953 return build_array_type (elt_type
, build_index_type (size_int (nelts
- 1)));
7956 /* Recursively examines the array elements of TYPE, until a non-array
7957 element type is found. */
7960 strip_array_types (tree type
)
7962 while (TREE_CODE (type
) == ARRAY_TYPE
)
7963 type
= TREE_TYPE (type
);
7968 /* Computes the canonical argument types from the argument type list
7971 Upon return, *ANY_STRUCTURAL_P will be true iff either it was true
7972 on entry to this function, or if any of the ARGTYPES are
7975 Upon return, *ANY_NONCANONICAL_P will be true iff either it was
7976 true on entry to this function, or if any of the ARGTYPES are
7979 Returns a canonical argument list, which may be ARGTYPES when the
7980 canonical argument list is unneeded (i.e., *ANY_STRUCTURAL_P is
7981 true) or would not differ from ARGTYPES. */
7984 maybe_canonicalize_argtypes (tree argtypes
,
7985 bool *any_structural_p
,
7986 bool *any_noncanonical_p
)
7989 bool any_noncanonical_argtypes_p
= false;
7991 for (arg
= argtypes
; arg
&& !(*any_structural_p
); arg
= TREE_CHAIN (arg
))
7993 if (!TREE_VALUE (arg
) || TREE_VALUE (arg
) == error_mark_node
)
7994 /* Fail gracefully by stating that the type is structural. */
7995 *any_structural_p
= true;
7996 else if (TYPE_STRUCTURAL_EQUALITY_P (TREE_VALUE (arg
)))
7997 *any_structural_p
= true;
7998 else if (TYPE_CANONICAL (TREE_VALUE (arg
)) != TREE_VALUE (arg
)
7999 || TREE_PURPOSE (arg
))
8000 /* If the argument has a default argument, we consider it
8001 non-canonical even though the type itself is canonical.
8002 That way, different variants of function and method types
8003 with default arguments will all point to the variant with
8004 no defaults as their canonical type. */
8005 any_noncanonical_argtypes_p
= true;
8008 if (*any_structural_p
)
8011 if (any_noncanonical_argtypes_p
)
8013 /* Build the canonical list of argument types. */
8014 tree canon_argtypes
= NULL_TREE
;
8015 bool is_void
= false;
8017 for (arg
= argtypes
; arg
; arg
= TREE_CHAIN (arg
))
8019 if (arg
== void_list_node
)
8022 canon_argtypes
= tree_cons (NULL_TREE
,
8023 TYPE_CANONICAL (TREE_VALUE (arg
)),
8027 canon_argtypes
= nreverse (canon_argtypes
);
8029 canon_argtypes
= chainon (canon_argtypes
, void_list_node
);
8031 /* There is a non-canonical type. */
8032 *any_noncanonical_p
= true;
8033 return canon_argtypes
;
8036 /* The canonical argument types are the same as ARGTYPES. */
8040 /* Construct, lay out and return
8041 the type of functions returning type VALUE_TYPE
8042 given arguments of types ARG_TYPES.
8043 ARG_TYPES is a chain of TREE_LIST nodes whose TREE_VALUEs
8044 are data type nodes for the arguments of the function.
8045 If such a type has already been constructed, reuse it. */
8048 build_function_type (tree value_type
, tree arg_types
)
8051 inchash::hash hstate
;
8052 bool any_structural_p
, any_noncanonical_p
;
8053 tree canon_argtypes
;
8055 if (TREE_CODE (value_type
) == FUNCTION_TYPE
)
8057 error ("function return type cannot be function");
8058 value_type
= integer_type_node
;
8061 /* Make a node of the sort we want. */
8062 t
= make_node (FUNCTION_TYPE
);
8063 TREE_TYPE (t
) = value_type
;
8064 TYPE_ARG_TYPES (t
) = arg_types
;
8066 /* If we already have such a type, use the old one. */
8067 hstate
.add_object (TYPE_HASH (value_type
));
8068 type_hash_list (arg_types
, hstate
);
8069 t
= type_hash_canon (hstate
.end (), t
);
8071 /* Set up the canonical type. */
8072 any_structural_p
= TYPE_STRUCTURAL_EQUALITY_P (value_type
);
8073 any_noncanonical_p
= TYPE_CANONICAL (value_type
) != value_type
;
8074 canon_argtypes
= maybe_canonicalize_argtypes (arg_types
,
8076 &any_noncanonical_p
);
8077 if (any_structural_p
)
8078 SET_TYPE_STRUCTURAL_EQUALITY (t
);
8079 else if (any_noncanonical_p
)
8080 TYPE_CANONICAL (t
) = build_function_type (TYPE_CANONICAL (value_type
),
8083 if (!COMPLETE_TYPE_P (t
))
8088 /* Build a function type. The RETURN_TYPE is the type returned by the
8089 function. If VAARGS is set, no void_type_node is appended to the
8090 the list. ARGP must be always be terminated be a NULL_TREE. */
8093 build_function_type_list_1 (bool vaargs
, tree return_type
, va_list argp
)
8097 t
= va_arg (argp
, tree
);
8098 for (args
= NULL_TREE
; t
!= NULL_TREE
; t
= va_arg (argp
, tree
))
8099 args
= tree_cons (NULL_TREE
, t
, args
);
8104 if (args
!= NULL_TREE
)
8105 args
= nreverse (args
);
8106 gcc_assert (last
!= void_list_node
);
8108 else if (args
== NULL_TREE
)
8109 args
= void_list_node
;
8113 args
= nreverse (args
);
8114 TREE_CHAIN (last
) = void_list_node
;
8116 args
= build_function_type (return_type
, args
);
8121 /* Build a function type. The RETURN_TYPE is the type returned by the
8122 function. If additional arguments are provided, they are
8123 additional argument types. The list of argument types must always
8124 be terminated by NULL_TREE. */
8127 build_function_type_list (tree return_type
, ...)
8132 va_start (p
, return_type
);
8133 args
= build_function_type_list_1 (false, return_type
, p
);
8138 /* Build a variable argument function type. The RETURN_TYPE is the
8139 type returned by the function. If additional arguments are provided,
8140 they are additional argument types. The list of argument types must
8141 always be terminated by NULL_TREE. */
8144 build_varargs_function_type_list (tree return_type
, ...)
8149 va_start (p
, return_type
);
8150 args
= build_function_type_list_1 (true, return_type
, p
);
8156 /* Build a function type. RETURN_TYPE is the type returned by the
8157 function; VAARGS indicates whether the function takes varargs. The
8158 function takes N named arguments, the types of which are provided in
8162 build_function_type_array_1 (bool vaargs
, tree return_type
, int n
,
8166 tree t
= vaargs
? NULL_TREE
: void_list_node
;
8168 for (i
= n
- 1; i
>= 0; i
--)
8169 t
= tree_cons (NULL_TREE
, arg_types
[i
], t
);
8171 return build_function_type (return_type
, t
);
8174 /* Build a function type. RETURN_TYPE is the type returned by the
8175 function. The function takes N named arguments, the types of which
8176 are provided in ARG_TYPES. */
8179 build_function_type_array (tree return_type
, int n
, tree
*arg_types
)
8181 return build_function_type_array_1 (false, return_type
, n
, arg_types
);
8184 /* Build a variable argument function type. RETURN_TYPE is the type
8185 returned by the function. The function takes N named arguments, the
8186 types of which are provided in ARG_TYPES. */
8189 build_varargs_function_type_array (tree return_type
, int n
, tree
*arg_types
)
8191 return build_function_type_array_1 (true, return_type
, n
, arg_types
);
8194 /* Build a METHOD_TYPE for a member of BASETYPE. The RETTYPE (a TYPE)
8195 and ARGTYPES (a TREE_LIST) are the return type and arguments types
8196 for the method. An implicit additional parameter (of type
8197 pointer-to-BASETYPE) is added to the ARGTYPES. */
8200 build_method_type_directly (tree basetype
,
8206 inchash::hash hstate
;
8207 bool any_structural_p
, any_noncanonical_p
;
8208 tree canon_argtypes
;
8210 /* Make a node of the sort we want. */
8211 t
= make_node (METHOD_TYPE
);
8213 TYPE_METHOD_BASETYPE (t
) = TYPE_MAIN_VARIANT (basetype
);
8214 TREE_TYPE (t
) = rettype
;
8215 ptype
= build_pointer_type (basetype
);
8217 /* The actual arglist for this function includes a "hidden" argument
8218 which is "this". Put it into the list of argument types. */
8219 argtypes
= tree_cons (NULL_TREE
, ptype
, argtypes
);
8220 TYPE_ARG_TYPES (t
) = argtypes
;
8222 /* If we already have such a type, use the old one. */
8223 hstate
.add_object (TYPE_HASH (basetype
));
8224 hstate
.add_object (TYPE_HASH (rettype
));
8225 type_hash_list (argtypes
, hstate
);
8226 t
= type_hash_canon (hstate
.end (), t
);
8228 /* Set up the canonical type. */
8230 = (TYPE_STRUCTURAL_EQUALITY_P (basetype
)
8231 || TYPE_STRUCTURAL_EQUALITY_P (rettype
));
8233 = (TYPE_CANONICAL (basetype
) != basetype
8234 || TYPE_CANONICAL (rettype
) != rettype
);
8235 canon_argtypes
= maybe_canonicalize_argtypes (TREE_CHAIN (argtypes
),
8237 &any_noncanonical_p
);
8238 if (any_structural_p
)
8239 SET_TYPE_STRUCTURAL_EQUALITY (t
);
8240 else if (any_noncanonical_p
)
8242 = build_method_type_directly (TYPE_CANONICAL (basetype
),
8243 TYPE_CANONICAL (rettype
),
8245 if (!COMPLETE_TYPE_P (t
))
8251 /* Construct, lay out and return the type of methods belonging to class
8252 BASETYPE and whose arguments and values are described by TYPE.
8253 If that type exists already, reuse it.
8254 TYPE must be a FUNCTION_TYPE node. */
8257 build_method_type (tree basetype
, tree type
)
8259 gcc_assert (TREE_CODE (type
) == FUNCTION_TYPE
);
8261 return build_method_type_directly (basetype
,
8263 TYPE_ARG_TYPES (type
));
8266 /* Construct, lay out and return the type of offsets to a value
8267 of type TYPE, within an object of type BASETYPE.
8268 If a suitable offset type exists already, reuse it. */
8271 build_offset_type (tree basetype
, tree type
)
8274 inchash::hash hstate
;
8276 /* Make a node of the sort we want. */
8277 t
= make_node (OFFSET_TYPE
);
8279 TYPE_OFFSET_BASETYPE (t
) = TYPE_MAIN_VARIANT (basetype
);
8280 TREE_TYPE (t
) = type
;
8282 /* If we already have such a type, use the old one. */
8283 hstate
.add_object (TYPE_HASH (basetype
));
8284 hstate
.add_object (TYPE_HASH (type
));
8285 t
= type_hash_canon (hstate
.end (), t
);
8287 if (!COMPLETE_TYPE_P (t
))
8290 if (TYPE_CANONICAL (t
) == t
)
8292 if (TYPE_STRUCTURAL_EQUALITY_P (basetype
)
8293 || TYPE_STRUCTURAL_EQUALITY_P (type
))
8294 SET_TYPE_STRUCTURAL_EQUALITY (t
);
8295 else if (TYPE_CANONICAL (TYPE_MAIN_VARIANT (basetype
)) != basetype
8296 || TYPE_CANONICAL (type
) != type
)
8298 = build_offset_type (TYPE_CANONICAL (TYPE_MAIN_VARIANT (basetype
)),
8299 TYPE_CANONICAL (type
));
8305 /* Create a complex type whose components are COMPONENT_TYPE. */
8308 build_complex_type (tree component_type
)
8311 inchash::hash hstate
;
8313 gcc_assert (INTEGRAL_TYPE_P (component_type
)
8314 || SCALAR_FLOAT_TYPE_P (component_type
)
8315 || FIXED_POINT_TYPE_P (component_type
));
8317 /* Make a node of the sort we want. */
8318 t
= make_node (COMPLEX_TYPE
);
8320 TREE_TYPE (t
) = TYPE_MAIN_VARIANT (component_type
);
8322 /* If we already have such a type, use the old one. */
8323 hstate
.add_object (TYPE_HASH (component_type
));
8324 t
= type_hash_canon (hstate
.end (), t
);
8326 if (!COMPLETE_TYPE_P (t
))
8329 if (TYPE_CANONICAL (t
) == t
)
8331 if (TYPE_STRUCTURAL_EQUALITY_P (component_type
))
8332 SET_TYPE_STRUCTURAL_EQUALITY (t
);
8333 else if (TYPE_CANONICAL (component_type
) != component_type
)
8335 = build_complex_type (TYPE_CANONICAL (component_type
));
8338 /* We need to create a name, since complex is a fundamental type. */
8339 if (! TYPE_NAME (t
))
8342 if (component_type
== char_type_node
)
8343 name
= "complex char";
8344 else if (component_type
== signed_char_type_node
)
8345 name
= "complex signed char";
8346 else if (component_type
== unsigned_char_type_node
)
8347 name
= "complex unsigned char";
8348 else if (component_type
== short_integer_type_node
)
8349 name
= "complex short int";
8350 else if (component_type
== short_unsigned_type_node
)
8351 name
= "complex short unsigned int";
8352 else if (component_type
== integer_type_node
)
8353 name
= "complex int";
8354 else if (component_type
== unsigned_type_node
)
8355 name
= "complex unsigned int";
8356 else if (component_type
== long_integer_type_node
)
8357 name
= "complex long int";
8358 else if (component_type
== long_unsigned_type_node
)
8359 name
= "complex long unsigned int";
8360 else if (component_type
== long_long_integer_type_node
)
8361 name
= "complex long long int";
8362 else if (component_type
== long_long_unsigned_type_node
)
8363 name
= "complex long long unsigned int";
8368 TYPE_NAME (t
) = build_decl (UNKNOWN_LOCATION
, TYPE_DECL
,
8369 get_identifier (name
), t
);
8372 return build_qualified_type (t
, TYPE_QUALS (component_type
));
8375 /* If TYPE is a real or complex floating-point type and the target
8376 does not directly support arithmetic on TYPE then return the wider
8377 type to be used for arithmetic on TYPE. Otherwise, return
8381 excess_precision_type (tree type
)
8383 if (flag_excess_precision
!= EXCESS_PRECISION_FAST
)
8385 int flt_eval_method
= TARGET_FLT_EVAL_METHOD
;
8386 switch (TREE_CODE (type
))
8389 switch (flt_eval_method
)
8392 if (TYPE_MODE (type
) == TYPE_MODE (float_type_node
))
8393 return double_type_node
;
8396 if (TYPE_MODE (type
) == TYPE_MODE (float_type_node
)
8397 || TYPE_MODE (type
) == TYPE_MODE (double_type_node
))
8398 return long_double_type_node
;
8405 if (TREE_CODE (TREE_TYPE (type
)) != REAL_TYPE
)
8407 switch (flt_eval_method
)
8410 if (TYPE_MODE (TREE_TYPE (type
)) == TYPE_MODE (float_type_node
))
8411 return complex_double_type_node
;
8414 if (TYPE_MODE (TREE_TYPE (type
)) == TYPE_MODE (float_type_node
)
8415 || (TYPE_MODE (TREE_TYPE (type
))
8416 == TYPE_MODE (double_type_node
)))
8417 return complex_long_double_type_node
;
8430 /* Return OP, stripped of any conversions to wider types as much as is safe.
8431 Converting the value back to OP's type makes a value equivalent to OP.
8433 If FOR_TYPE is nonzero, we return a value which, if converted to
8434 type FOR_TYPE, would be equivalent to converting OP to type FOR_TYPE.
8436 OP must have integer, real or enumeral type. Pointers are not allowed!
8438 There are some cases where the obvious value we could return
8439 would regenerate to OP if converted to OP's type,
8440 but would not extend like OP to wider types.
8441 If FOR_TYPE indicates such extension is contemplated, we eschew such values.
8442 For example, if OP is (unsigned short)(signed char)-1,
8443 we avoid returning (signed char)-1 if FOR_TYPE is int,
8444 even though extending that to an unsigned short would regenerate OP,
8445 since the result of extending (signed char)-1 to (int)
8446 is different from (int) OP. */
8449 get_unwidened (tree op
, tree for_type
)
8451 /* Set UNS initially if converting OP to FOR_TYPE is a zero-extension. */
8452 tree type
= TREE_TYPE (op
);
8454 = TYPE_PRECISION (for_type
!= 0 ? for_type
: type
);
8456 = (for_type
!= 0 && for_type
!= type
8457 && final_prec
> TYPE_PRECISION (type
)
8458 && TYPE_UNSIGNED (type
));
8461 while (CONVERT_EXPR_P (op
))
8465 /* TYPE_PRECISION on vector types has different meaning
8466 (TYPE_VECTOR_SUBPARTS) and casts from vectors are view conversions,
8467 so avoid them here. */
8468 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (op
, 0))) == VECTOR_TYPE
)
8471 bitschange
= TYPE_PRECISION (TREE_TYPE (op
))
8472 - TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op
, 0)));
8474 /* Truncations are many-one so cannot be removed.
8475 Unless we are later going to truncate down even farther. */
8477 && final_prec
> TYPE_PRECISION (TREE_TYPE (op
)))
8480 /* See what's inside this conversion. If we decide to strip it,
8482 op
= TREE_OPERAND (op
, 0);
8484 /* If we have not stripped any zero-extensions (uns is 0),
8485 we can strip any kind of extension.
8486 If we have previously stripped a zero-extension,
8487 only zero-extensions can safely be stripped.
8488 Any extension can be stripped if the bits it would produce
8489 are all going to be discarded later by truncating to FOR_TYPE. */
8493 if (! uns
|| final_prec
<= TYPE_PRECISION (TREE_TYPE (op
)))
8495 /* TYPE_UNSIGNED says whether this is a zero-extension.
8496 Let's avoid computing it if it does not affect WIN
8497 and if UNS will not be needed again. */
8499 || CONVERT_EXPR_P (op
))
8500 && TYPE_UNSIGNED (TREE_TYPE (op
)))
8508 /* If we finally reach a constant see if it fits in for_type and
8509 in that case convert it. */
8511 && TREE_CODE (win
) == INTEGER_CST
8512 && TREE_TYPE (win
) != for_type
8513 && int_fits_type_p (win
, for_type
))
8514 win
= fold_convert (for_type
, win
);
8519 /* Return OP or a simpler expression for a narrower value
8520 which can be sign-extended or zero-extended to give back OP.
8521 Store in *UNSIGNEDP_PTR either 1 if the value should be zero-extended
8522 or 0 if the value should be sign-extended. */
8525 get_narrower (tree op
, int *unsignedp_ptr
)
8530 bool integral_p
= INTEGRAL_TYPE_P (TREE_TYPE (op
));
8532 while (TREE_CODE (op
) == NOP_EXPR
)
8535 = (TYPE_PRECISION (TREE_TYPE (op
))
8536 - TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op
, 0))));
8538 /* Truncations are many-one so cannot be removed. */
8542 /* See what's inside this conversion. If we decide to strip it,
8547 op
= TREE_OPERAND (op
, 0);
8548 /* An extension: the outermost one can be stripped,
8549 but remember whether it is zero or sign extension. */
8551 uns
= TYPE_UNSIGNED (TREE_TYPE (op
));
8552 /* Otherwise, if a sign extension has been stripped,
8553 only sign extensions can now be stripped;
8554 if a zero extension has been stripped, only zero-extensions. */
8555 else if (uns
!= TYPE_UNSIGNED (TREE_TYPE (op
)))
8559 else /* bitschange == 0 */
8561 /* A change in nominal type can always be stripped, but we must
8562 preserve the unsignedness. */
8564 uns
= TYPE_UNSIGNED (TREE_TYPE (op
));
8566 op
= TREE_OPERAND (op
, 0);
8567 /* Keep trying to narrow, but don't assign op to win if it
8568 would turn an integral type into something else. */
8569 if (INTEGRAL_TYPE_P (TREE_TYPE (op
)) != integral_p
)
8576 if (TREE_CODE (op
) == COMPONENT_REF
8577 /* Since type_for_size always gives an integer type. */
8578 && TREE_CODE (TREE_TYPE (op
)) != REAL_TYPE
8579 && TREE_CODE (TREE_TYPE (op
)) != FIXED_POINT_TYPE
8580 /* Ensure field is laid out already. */
8581 && DECL_SIZE (TREE_OPERAND (op
, 1)) != 0
8582 && tree_fits_uhwi_p (DECL_SIZE (TREE_OPERAND (op
, 1))))
8584 unsigned HOST_WIDE_INT innerprec
8585 = tree_to_uhwi (DECL_SIZE (TREE_OPERAND (op
, 1)));
8586 int unsignedp
= (DECL_UNSIGNED (TREE_OPERAND (op
, 1))
8587 || TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op
, 1))));
8588 tree type
= lang_hooks
.types
.type_for_size (innerprec
, unsignedp
);
8590 /* We can get this structure field in a narrower type that fits it,
8591 but the resulting extension to its nominal type (a fullword type)
8592 must satisfy the same conditions as for other extensions.
8594 Do this only for fields that are aligned (not bit-fields),
8595 because when bit-field insns will be used there is no
8596 advantage in doing this. */
8598 if (innerprec
< TYPE_PRECISION (TREE_TYPE (op
))
8599 && ! DECL_BIT_FIELD (TREE_OPERAND (op
, 1))
8600 && (first
|| uns
== DECL_UNSIGNED (TREE_OPERAND (op
, 1)))
8604 uns
= DECL_UNSIGNED (TREE_OPERAND (op
, 1));
8605 win
= fold_convert (type
, op
);
8609 *unsignedp_ptr
= uns
;
8613 /* Returns true if integer constant C has a value that is permissible
8614 for type TYPE (an INTEGER_TYPE). */
8617 int_fits_type_p (const_tree c
, const_tree type
)
8619 tree type_low_bound
, type_high_bound
;
8620 bool ok_for_low_bound
, ok_for_high_bound
;
8621 signop sgn_c
= TYPE_SIGN (TREE_TYPE (c
));
8624 type_low_bound
= TYPE_MIN_VALUE (type
);
8625 type_high_bound
= TYPE_MAX_VALUE (type
);
8627 /* If at least one bound of the type is a constant integer, we can check
8628 ourselves and maybe make a decision. If no such decision is possible, but
8629 this type is a subtype, try checking against that. Otherwise, use
8630 fits_to_tree_p, which checks against the precision.
8632 Compute the status for each possibly constant bound, and return if we see
8633 one does not match. Use ok_for_xxx_bound for this purpose, assigning -1
8634 for "unknown if constant fits", 0 for "constant known *not* to fit" and 1
8635 for "constant known to fit". */
8637 /* Check if c >= type_low_bound. */
8638 if (type_low_bound
&& TREE_CODE (type_low_bound
) == INTEGER_CST
)
8640 if (tree_int_cst_lt (c
, type_low_bound
))
8642 ok_for_low_bound
= true;
8645 ok_for_low_bound
= false;
8647 /* Check if c <= type_high_bound. */
8648 if (type_high_bound
&& TREE_CODE (type_high_bound
) == INTEGER_CST
)
8650 if (tree_int_cst_lt (type_high_bound
, c
))
8652 ok_for_high_bound
= true;
8655 ok_for_high_bound
= false;
8657 /* If the constant fits both bounds, the result is known. */
8658 if (ok_for_low_bound
&& ok_for_high_bound
)
8661 /* Perform some generic filtering which may allow making a decision
8662 even if the bounds are not constant. First, negative integers
8663 never fit in unsigned types, */
8664 if (TYPE_UNSIGNED (type
) && sgn_c
== SIGNED
&& wi::neg_p (c
))
8667 /* Second, narrower types always fit in wider ones. */
8668 if (TYPE_PRECISION (type
) > TYPE_PRECISION (TREE_TYPE (c
)))
8671 /* Third, unsigned integers with top bit set never fit signed types. */
8672 if (!TYPE_UNSIGNED (type
) && sgn_c
== UNSIGNED
)
8674 int prec
= GET_MODE_PRECISION (TYPE_MODE (TREE_TYPE (c
))) - 1;
8675 if (prec
< TYPE_PRECISION (TREE_TYPE (c
)))
8677 /* When a tree_cst is converted to a wide-int, the precision
8678 is taken from the type. However, if the precision of the
8679 mode underneath the type is smaller than that, it is
8680 possible that the value will not fit. The test below
8681 fails if any bit is set between the sign bit of the
8682 underlying mode and the top bit of the type. */
8683 if (wi::ne_p (wi::zext (c
, prec
- 1), c
))
8686 else if (wi::neg_p (c
))
8690 /* If we haven't been able to decide at this point, there nothing more we
8691 can check ourselves here. Look at the base type if we have one and it
8692 has the same precision. */
8693 if (TREE_CODE (type
) == INTEGER_TYPE
8694 && TREE_TYPE (type
) != 0
8695 && TYPE_PRECISION (type
) == TYPE_PRECISION (TREE_TYPE (type
)))
8697 type
= TREE_TYPE (type
);
8701 /* Or to fits_to_tree_p, if nothing else. */
8702 return wi::fits_to_tree_p (c
, type
);
8705 /* Stores bounds of an integer TYPE in MIN and MAX. If TYPE has non-constant
8706 bounds or is a POINTER_TYPE, the maximum and/or minimum values that can be
8707 represented (assuming two's-complement arithmetic) within the bit
8708 precision of the type are returned instead. */
8711 get_type_static_bounds (const_tree type
, mpz_t min
, mpz_t max
)
8713 if (!POINTER_TYPE_P (type
) && TYPE_MIN_VALUE (type
)
8714 && TREE_CODE (TYPE_MIN_VALUE (type
)) == INTEGER_CST
)
8715 wi::to_mpz (TYPE_MIN_VALUE (type
), min
, TYPE_SIGN (type
));
8718 if (TYPE_UNSIGNED (type
))
8719 mpz_set_ui (min
, 0);
8722 wide_int mn
= wi::min_value (TYPE_PRECISION (type
), SIGNED
);
8723 wi::to_mpz (mn
, min
, SIGNED
);
8727 if (!POINTER_TYPE_P (type
) && TYPE_MAX_VALUE (type
)
8728 && TREE_CODE (TYPE_MAX_VALUE (type
)) == INTEGER_CST
)
8729 wi::to_mpz (TYPE_MAX_VALUE (type
), max
, TYPE_SIGN (type
));
8732 wide_int mn
= wi::max_value (TYPE_PRECISION (type
), TYPE_SIGN (type
));
8733 wi::to_mpz (mn
, max
, TYPE_SIGN (type
));
8737 /* Return true if VAR is an automatic variable defined in function FN. */
8740 auto_var_in_fn_p (const_tree var
, const_tree fn
)
8742 return (DECL_P (var
) && DECL_CONTEXT (var
) == fn
8743 && ((((TREE_CODE (var
) == VAR_DECL
&& ! DECL_EXTERNAL (var
))
8744 || TREE_CODE (var
) == PARM_DECL
)
8745 && ! TREE_STATIC (var
))
8746 || TREE_CODE (var
) == LABEL_DECL
8747 || TREE_CODE (var
) == RESULT_DECL
));
8750 /* Subprogram of following function. Called by walk_tree.
8752 Return *TP if it is an automatic variable or parameter of the
8753 function passed in as DATA. */
8756 find_var_from_fn (tree
*tp
, int *walk_subtrees
, void *data
)
8758 tree fn
= (tree
) data
;
8763 else if (DECL_P (*tp
)
8764 && auto_var_in_fn_p (*tp
, fn
))
8770 /* Returns true if T is, contains, or refers to a type with variable
8771 size. For METHOD_TYPEs and FUNCTION_TYPEs we exclude the
8772 arguments, but not the return type. If FN is nonzero, only return
8773 true if a modifier of the type or position of FN is a variable or
8774 parameter inside FN.
8776 This concept is more general than that of C99 'variably modified types':
8777 in C99, a struct type is never variably modified because a VLA may not
8778 appear as a structure member. However, in GNU C code like:
8780 struct S { int i[f()]; };
8782 is valid, and other languages may define similar constructs. */
8785 variably_modified_type_p (tree type
, tree fn
)
8789 /* Test if T is either variable (if FN is zero) or an expression containing
8790 a variable in FN. If TYPE isn't gimplified, return true also if
8791 gimplify_one_sizepos would gimplify the expression into a local
8793 #define RETURN_TRUE_IF_VAR(T) \
8794 do { tree _t = (T); \
8795 if (_t != NULL_TREE \
8796 && _t != error_mark_node \
8797 && TREE_CODE (_t) != INTEGER_CST \
8798 && TREE_CODE (_t) != PLACEHOLDER_EXPR \
8800 || (!TYPE_SIZES_GIMPLIFIED (type) \
8801 && !is_gimple_sizepos (_t)) \
8802 || walk_tree (&_t, find_var_from_fn, fn, NULL))) \
8803 return true; } while (0)
8805 if (type
== error_mark_node
)
8808 /* If TYPE itself has variable size, it is variably modified. */
8809 RETURN_TRUE_IF_VAR (TYPE_SIZE (type
));
8810 RETURN_TRUE_IF_VAR (TYPE_SIZE_UNIT (type
));
8812 switch (TREE_CODE (type
))
8815 case REFERENCE_TYPE
:
8817 if (variably_modified_type_p (TREE_TYPE (type
), fn
))
8823 /* If TYPE is a function type, it is variably modified if the
8824 return type is variably modified. */
8825 if (variably_modified_type_p (TREE_TYPE (type
), fn
))
8831 case FIXED_POINT_TYPE
:
8834 /* Scalar types are variably modified if their end points
8836 RETURN_TRUE_IF_VAR (TYPE_MIN_VALUE (type
));
8837 RETURN_TRUE_IF_VAR (TYPE_MAX_VALUE (type
));
8842 case QUAL_UNION_TYPE
:
8843 /* We can't see if any of the fields are variably-modified by the
8844 definition we normally use, since that would produce infinite
8845 recursion via pointers. */
8846 /* This is variably modified if some field's type is. */
8847 for (t
= TYPE_FIELDS (type
); t
; t
= DECL_CHAIN (t
))
8848 if (TREE_CODE (t
) == FIELD_DECL
)
8850 RETURN_TRUE_IF_VAR (DECL_FIELD_OFFSET (t
));
8851 RETURN_TRUE_IF_VAR (DECL_SIZE (t
));
8852 RETURN_TRUE_IF_VAR (DECL_SIZE_UNIT (t
));
8854 if (TREE_CODE (type
) == QUAL_UNION_TYPE
)
8855 RETURN_TRUE_IF_VAR (DECL_QUALIFIER (t
));
8860 /* Do not call ourselves to avoid infinite recursion. This is
8861 variably modified if the element type is. */
8862 RETURN_TRUE_IF_VAR (TYPE_SIZE (TREE_TYPE (type
)));
8863 RETURN_TRUE_IF_VAR (TYPE_SIZE_UNIT (TREE_TYPE (type
)));
8870 /* The current language may have other cases to check, but in general,
8871 all other types are not variably modified. */
8872 return lang_hooks
.tree_inlining
.var_mod_type_p (type
, fn
);
8874 #undef RETURN_TRUE_IF_VAR
8877 /* Given a DECL or TYPE, return the scope in which it was declared, or
8878 NULL_TREE if there is no containing scope. */
8881 get_containing_scope (const_tree t
)
8883 return (TYPE_P (t
) ? TYPE_CONTEXT (t
) : DECL_CONTEXT (t
));
8886 /* Return the innermost context enclosing DECL that is
8887 a FUNCTION_DECL, or zero if none. */
8890 decl_function_context (const_tree decl
)
8894 if (TREE_CODE (decl
) == ERROR_MARK
)
8897 /* C++ virtual functions use DECL_CONTEXT for the class of the vtable
8898 where we look up the function at runtime. Such functions always take
8899 a first argument of type 'pointer to real context'.
8901 C++ should really be fixed to use DECL_CONTEXT for the real context,
8902 and use something else for the "virtual context". */
8903 else if (TREE_CODE (decl
) == FUNCTION_DECL
&& DECL_VINDEX (decl
))
8906 (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl
)))));
8908 context
= DECL_CONTEXT (decl
);
8910 while (context
&& TREE_CODE (context
) != FUNCTION_DECL
)
8912 if (TREE_CODE (context
) == BLOCK
)
8913 context
= BLOCK_SUPERCONTEXT (context
);
8915 context
= get_containing_scope (context
);
8921 /* Return the innermost context enclosing DECL that is
8922 a RECORD_TYPE, UNION_TYPE or QUAL_UNION_TYPE, or zero if none.
8923 TYPE_DECLs and FUNCTION_DECLs are transparent to this function. */
8926 decl_type_context (const_tree decl
)
8928 tree context
= DECL_CONTEXT (decl
);
8931 switch (TREE_CODE (context
))
8933 case NAMESPACE_DECL
:
8934 case TRANSLATION_UNIT_DECL
:
8939 case QUAL_UNION_TYPE
:
8944 context
= DECL_CONTEXT (context
);
8948 context
= BLOCK_SUPERCONTEXT (context
);
8958 /* CALL is a CALL_EXPR. Return the declaration for the function
8959 called, or NULL_TREE if the called function cannot be
8963 get_callee_fndecl (const_tree call
)
8967 if (call
== error_mark_node
)
8968 return error_mark_node
;
8970 /* It's invalid to call this function with anything but a
8972 gcc_assert (TREE_CODE (call
) == CALL_EXPR
);
8974 /* The first operand to the CALL is the address of the function
8976 addr
= CALL_EXPR_FN (call
);
8978 /* If there is no function, return early. */
8979 if (addr
== NULL_TREE
)
8984 /* If this is a readonly function pointer, extract its initial value. */
8985 if (DECL_P (addr
) && TREE_CODE (addr
) != FUNCTION_DECL
8986 && TREE_READONLY (addr
) && ! TREE_THIS_VOLATILE (addr
)
8987 && DECL_INITIAL (addr
))
8988 addr
= DECL_INITIAL (addr
);
8990 /* If the address is just `&f' for some function `f', then we know
8991 that `f' is being called. */
8992 if (TREE_CODE (addr
) == ADDR_EXPR
8993 && TREE_CODE (TREE_OPERAND (addr
, 0)) == FUNCTION_DECL
)
8994 return TREE_OPERAND (addr
, 0);
8996 /* We couldn't figure out what was being called. */
9000 /* Print debugging information about tree nodes generated during the compile,
9001 and any language-specific information. */
9004 dump_tree_statistics (void)
9006 if (GATHER_STATISTICS
)
9009 int total_nodes
, total_bytes
;
9010 fprintf (stderr
, "Kind Nodes Bytes\n");
9011 fprintf (stderr
, "---------------------------------------\n");
9012 total_nodes
= total_bytes
= 0;
9013 for (i
= 0; i
< (int) all_kinds
; i
++)
9015 fprintf (stderr
, "%-20s %7d %10d\n", tree_node_kind_names
[i
],
9016 tree_node_counts
[i
], tree_node_sizes
[i
]);
9017 total_nodes
+= tree_node_counts
[i
];
9018 total_bytes
+= tree_node_sizes
[i
];
9020 fprintf (stderr
, "---------------------------------------\n");
9021 fprintf (stderr
, "%-20s %7d %10d\n", "Total", total_nodes
, total_bytes
);
9022 fprintf (stderr
, "---------------------------------------\n");
9023 fprintf (stderr
, "Code Nodes\n");
9024 fprintf (stderr
, "----------------------------\n");
9025 for (i
= 0; i
< (int) MAX_TREE_CODES
; i
++)
9026 fprintf (stderr
, "%-20s %7d\n", get_tree_code_name ((enum tree_code
) i
),
9027 tree_code_counts
[i
]);
9028 fprintf (stderr
, "----------------------------\n");
9029 ssanames_print_statistics ();
9030 phinodes_print_statistics ();
9033 fprintf (stderr
, "(No per-node statistics)\n");
9035 print_type_hash_statistics ();
9036 print_debug_expr_statistics ();
9037 print_value_expr_statistics ();
9038 lang_hooks
.print_statistics ();
9041 #define FILE_FUNCTION_FORMAT "_GLOBAL__%s_%s"
9043 /* Generate a crc32 of a byte. */
9046 crc32_unsigned_bits (unsigned chksum
, unsigned value
, unsigned bits
)
9050 for (ix
= bits
; ix
--; value
<<= 1)
9054 feedback
= (value
^ chksum
) & 0x80000000 ? 0x04c11db7 : 0;
9061 /* Generate a crc32 of a 32-bit unsigned. */
9064 crc32_unsigned (unsigned chksum
, unsigned value
)
9066 return crc32_unsigned_bits (chksum
, value
, 32);
9069 /* Generate a crc32 of a byte. */
9072 crc32_byte (unsigned chksum
, char byte
)
9074 return crc32_unsigned_bits (chksum
, (unsigned) byte
<< 24, 8);
9077 /* Generate a crc32 of a string. */
9080 crc32_string (unsigned chksum
, const char *string
)
9084 chksum
= crc32_byte (chksum
, *string
);
9090 /* P is a string that will be used in a symbol. Mask out any characters
9091 that are not valid in that context. */
9094 clean_symbol_name (char *p
)
9098 #ifndef NO_DOLLAR_IN_LABEL /* this for `$'; unlikely, but... -- kr */
9101 #ifndef NO_DOT_IN_LABEL /* this for `.'; unlikely, but... */
9108 /* Generate a name for a special-purpose function.
9109 The generated name may need to be unique across the whole link.
9110 Changes to this function may also require corresponding changes to
9111 xstrdup_mask_random.
9112 TYPE is some string to identify the purpose of this function to the
9113 linker or collect2; it must start with an uppercase letter,
9115 I - for constructors
9117 N - for C++ anonymous namespaces
9118 F - for DWARF unwind frame information. */
9121 get_file_function_name (const char *type
)
9127 /* If we already have a name we know to be unique, just use that. */
9128 if (first_global_object_name
)
9129 p
= q
= ASTRDUP (first_global_object_name
);
9130 /* If the target is handling the constructors/destructors, they
9131 will be local to this file and the name is only necessary for
9133 We also assign sub_I and sub_D sufixes to constructors called from
9134 the global static constructors. These are always local. */
9135 else if (((type
[0] == 'I' || type
[0] == 'D') && targetm
.have_ctors_dtors
)
9136 || (strncmp (type
, "sub_", 4) == 0
9137 && (type
[4] == 'I' || type
[4] == 'D')))
9139 const char *file
= main_input_filename
;
9141 file
= LOCATION_FILE (input_location
);
9142 /* Just use the file's basename, because the full pathname
9143 might be quite long. */
9144 p
= q
= ASTRDUP (lbasename (file
));
9148 /* Otherwise, the name must be unique across the entire link.
9149 We don't have anything that we know to be unique to this translation
9150 unit, so use what we do have and throw in some randomness. */
9152 const char *name
= weak_global_object_name
;
9153 const char *file
= main_input_filename
;
9158 file
= LOCATION_FILE (input_location
);
9160 len
= strlen (file
);
9161 q
= (char *) alloca (9 + 17 + len
+ 1);
9162 memcpy (q
, file
, len
+ 1);
9164 snprintf (q
+ len
, 9 + 17 + 1, "_%08X_" HOST_WIDE_INT_PRINT_HEX
,
9165 crc32_string (0, name
), get_random_seed (false));
9170 clean_symbol_name (q
);
9171 buf
= (char *) alloca (sizeof (FILE_FUNCTION_FORMAT
) + strlen (p
)
9174 /* Set up the name of the file-level functions we may need.
9175 Use a global object (which is already required to be unique over
9176 the program) rather than the file name (which imposes extra
9178 sprintf (buf
, FILE_FUNCTION_FORMAT
, type
, p
);
9180 return get_identifier (buf
);
9183 #if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
9185 /* Complain that the tree code of NODE does not match the expected 0
9186 terminated list of trailing codes. The trailing code list can be
9187 empty, for a more vague error message. FILE, LINE, and FUNCTION
9188 are of the caller. */
9191 tree_check_failed (const_tree node
, const char *file
,
9192 int line
, const char *function
, ...)
9196 unsigned length
= 0;
9197 enum tree_code code
;
9199 va_start (args
, function
);
9200 while ((code
= (enum tree_code
) va_arg (args
, int)))
9201 length
+= 4 + strlen (get_tree_code_name (code
));
9206 va_start (args
, function
);
9207 length
+= strlen ("expected ");
9208 buffer
= tmp
= (char *) alloca (length
);
9210 while ((code
= (enum tree_code
) va_arg (args
, int)))
9212 const char *prefix
= length
? " or " : "expected ";
9214 strcpy (tmp
+ length
, prefix
);
9215 length
+= strlen (prefix
);
9216 strcpy (tmp
+ length
, get_tree_code_name (code
));
9217 length
+= strlen (get_tree_code_name (code
));
9222 buffer
= "unexpected node";
9224 internal_error ("tree check: %s, have %s in %s, at %s:%d",
9225 buffer
, get_tree_code_name (TREE_CODE (node
)),
9226 function
, trim_filename (file
), line
);
9229 /* Complain that the tree code of NODE does match the expected 0
9230 terminated list of trailing codes. FILE, LINE, and FUNCTION are of
9234 tree_not_check_failed (const_tree node
, const char *file
,
9235 int line
, const char *function
, ...)
9239 unsigned length
= 0;
9240 enum tree_code code
;
9242 va_start (args
, function
);
9243 while ((code
= (enum tree_code
) va_arg (args
, int)))
9244 length
+= 4 + strlen (get_tree_code_name (code
));
9246 va_start (args
, function
);
9247 buffer
= (char *) alloca (length
);
9249 while ((code
= (enum tree_code
) va_arg (args
, int)))
9253 strcpy (buffer
+ length
, " or ");
9256 strcpy (buffer
+ length
, get_tree_code_name (code
));
9257 length
+= strlen (get_tree_code_name (code
));
9261 internal_error ("tree check: expected none of %s, have %s in %s, at %s:%d",
9262 buffer
, get_tree_code_name (TREE_CODE (node
)),
9263 function
, trim_filename (file
), line
);
9266 /* Similar to tree_check_failed, except that we check for a class of tree
9267 code, given in CL. */
9270 tree_class_check_failed (const_tree node
, const enum tree_code_class cl
,
9271 const char *file
, int line
, const char *function
)
9274 ("tree check: expected class %qs, have %qs (%s) in %s, at %s:%d",
9275 TREE_CODE_CLASS_STRING (cl
),
9276 TREE_CODE_CLASS_STRING (TREE_CODE_CLASS (TREE_CODE (node
))),
9277 get_tree_code_name (TREE_CODE (node
)), function
, trim_filename (file
), line
);
9280 /* Similar to tree_check_failed, except that instead of specifying a
9281 dozen codes, use the knowledge that they're all sequential. */
9284 tree_range_check_failed (const_tree node
, const char *file
, int line
,
9285 const char *function
, enum tree_code c1
,
9289 unsigned length
= 0;
9292 for (c
= c1
; c
<= c2
; ++c
)
9293 length
+= 4 + strlen (get_tree_code_name ((enum tree_code
) c
));
9295 length
+= strlen ("expected ");
9296 buffer
= (char *) alloca (length
);
9299 for (c
= c1
; c
<= c2
; ++c
)
9301 const char *prefix
= length
? " or " : "expected ";
9303 strcpy (buffer
+ length
, prefix
);
9304 length
+= strlen (prefix
);
9305 strcpy (buffer
+ length
, get_tree_code_name ((enum tree_code
) c
));
9306 length
+= strlen (get_tree_code_name ((enum tree_code
) c
));
9309 internal_error ("tree check: %s, have %s in %s, at %s:%d",
9310 buffer
, get_tree_code_name (TREE_CODE (node
)),
9311 function
, trim_filename (file
), line
);
9315 /* Similar to tree_check_failed, except that we check that a tree does
9316 not have the specified code, given in CL. */
9319 tree_not_class_check_failed (const_tree node
, const enum tree_code_class cl
,
9320 const char *file
, int line
, const char *function
)
9323 ("tree check: did not expect class %qs, have %qs (%s) in %s, at %s:%d",
9324 TREE_CODE_CLASS_STRING (cl
),
9325 TREE_CODE_CLASS_STRING (TREE_CODE_CLASS (TREE_CODE (node
))),
9326 get_tree_code_name (TREE_CODE (node
)), function
, trim_filename (file
), line
);
9330 /* Similar to tree_check_failed but applied to OMP_CLAUSE codes. */
9333 omp_clause_check_failed (const_tree node
, const char *file
, int line
,
9334 const char *function
, enum omp_clause_code code
)
9336 internal_error ("tree check: expected omp_clause %s, have %s in %s, at %s:%d",
9337 omp_clause_code_name
[code
], get_tree_code_name (TREE_CODE (node
)),
9338 function
, trim_filename (file
), line
);
9342 /* Similar to tree_range_check_failed but applied to OMP_CLAUSE codes. */
9345 omp_clause_range_check_failed (const_tree node
, const char *file
, int line
,
9346 const char *function
, enum omp_clause_code c1
,
9347 enum omp_clause_code c2
)
9350 unsigned length
= 0;
9353 for (c
= c1
; c
<= c2
; ++c
)
9354 length
+= 4 + strlen (omp_clause_code_name
[c
]);
9356 length
+= strlen ("expected ");
9357 buffer
= (char *) alloca (length
);
9360 for (c
= c1
; c
<= c2
; ++c
)
9362 const char *prefix
= length
? " or " : "expected ";
9364 strcpy (buffer
+ length
, prefix
);
9365 length
+= strlen (prefix
);
9366 strcpy (buffer
+ length
, omp_clause_code_name
[c
]);
9367 length
+= strlen (omp_clause_code_name
[c
]);
9370 internal_error ("tree check: %s, have %s in %s, at %s:%d",
9371 buffer
, omp_clause_code_name
[TREE_CODE (node
)],
9372 function
, trim_filename (file
), line
);
9376 #undef DEFTREESTRUCT
9377 #define DEFTREESTRUCT(VAL, NAME) NAME,
9379 static const char *ts_enum_names
[] = {
9380 #include "treestruct.def"
9382 #undef DEFTREESTRUCT
9384 #define TS_ENUM_NAME(EN) (ts_enum_names[(EN)])
9386 /* Similar to tree_class_check_failed, except that we check for
9387 whether CODE contains the tree structure identified by EN. */
9390 tree_contains_struct_check_failed (const_tree node
,
9391 const enum tree_node_structure_enum en
,
9392 const char *file
, int line
,
9393 const char *function
)
9396 ("tree check: expected tree that contains %qs structure, have %qs in %s, at %s:%d",
9398 get_tree_code_name (TREE_CODE (node
)), function
, trim_filename (file
), line
);
9402 /* Similar to above, except that the check is for the bounds of a TREE_VEC's
9403 (dynamically sized) vector. */
9406 tree_int_cst_elt_check_failed (int idx
, int len
, const char *file
, int line
,
9407 const char *function
)
9410 ("tree check: accessed elt %d of tree_int_cst with %d elts in %s, at %s:%d",
9411 idx
+ 1, len
, function
, trim_filename (file
), line
);
9414 /* Similar to above, except that the check is for the bounds of a TREE_VEC's
9415 (dynamically sized) vector. */
9418 tree_vec_elt_check_failed (int idx
, int len
, const char *file
, int line
,
9419 const char *function
)
9422 ("tree check: accessed elt %d of tree_vec with %d elts in %s, at %s:%d",
9423 idx
+ 1, len
, function
, trim_filename (file
), line
);
9426 /* Similar to above, except that the check is for the bounds of the operand
9427 vector of an expression node EXP. */
9430 tree_operand_check_failed (int idx
, const_tree exp
, const char *file
,
9431 int line
, const char *function
)
9433 enum tree_code code
= TREE_CODE (exp
);
9435 ("tree check: accessed operand %d of %s with %d operands in %s, at %s:%d",
9436 idx
+ 1, get_tree_code_name (code
), TREE_OPERAND_LENGTH (exp
),
9437 function
, trim_filename (file
), line
);
9440 /* Similar to above, except that the check is for the number of
9441 operands of an OMP_CLAUSE node. */
9444 omp_clause_operand_check_failed (int idx
, const_tree t
, const char *file
,
9445 int line
, const char *function
)
9448 ("tree check: accessed operand %d of omp_clause %s with %d operands "
9449 "in %s, at %s:%d", idx
+ 1, omp_clause_code_name
[OMP_CLAUSE_CODE (t
)],
9450 omp_clause_num_ops
[OMP_CLAUSE_CODE (t
)], function
,
9451 trim_filename (file
), line
);
9453 #endif /* ENABLE_TREE_CHECKING */
9455 /* Create a new vector type node holding SUBPARTS units of type INNERTYPE,
9456 and mapped to the machine mode MODE. Initialize its fields and build
9457 the information necessary for debugging output. */
9460 make_vector_type (tree innertype
, int nunits
, machine_mode mode
)
9463 inchash::hash hstate
;
9465 t
= make_node (VECTOR_TYPE
);
9466 TREE_TYPE (t
) = TYPE_MAIN_VARIANT (innertype
);
9467 SET_TYPE_VECTOR_SUBPARTS (t
, nunits
);
9468 SET_TYPE_MODE (t
, mode
);
9470 if (TYPE_STRUCTURAL_EQUALITY_P (innertype
))
9471 SET_TYPE_STRUCTURAL_EQUALITY (t
);
9472 else if (TYPE_CANONICAL (innertype
) != innertype
9473 || mode
!= VOIDmode
)
9475 = make_vector_type (TYPE_CANONICAL (innertype
), nunits
, VOIDmode
);
9479 hstate
.add_wide_int (VECTOR_TYPE
);
9480 hstate
.add_wide_int (nunits
);
9481 hstate
.add_wide_int (mode
);
9482 hstate
.add_object (TYPE_HASH (TREE_TYPE (t
)));
9483 t
= type_hash_canon (hstate
.end (), t
);
9485 /* We have built a main variant, based on the main variant of the
9486 inner type. Use it to build the variant we return. */
9487 if ((TYPE_ATTRIBUTES (innertype
) || TYPE_QUALS (innertype
))
9488 && TREE_TYPE (t
) != innertype
)
9489 return build_type_attribute_qual_variant (t
,
9490 TYPE_ATTRIBUTES (innertype
),
9491 TYPE_QUALS (innertype
));
9497 make_or_reuse_type (unsigned size
, int unsignedp
)
9501 if (size
== INT_TYPE_SIZE
)
9502 return unsignedp
? unsigned_type_node
: integer_type_node
;
9503 if (size
== CHAR_TYPE_SIZE
)
9504 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
9505 if (size
== SHORT_TYPE_SIZE
)
9506 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
9507 if (size
== LONG_TYPE_SIZE
)
9508 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
9509 if (size
== LONG_LONG_TYPE_SIZE
)
9510 return (unsignedp
? long_long_unsigned_type_node
9511 : long_long_integer_type_node
);
9513 for (i
= 0; i
< NUM_INT_N_ENTS
; i
++)
9514 if (size
== int_n_data
[i
].bitsize
9515 && int_n_enabled_p
[i
])
9516 return (unsignedp
? int_n_trees
[i
].unsigned_type
9517 : int_n_trees
[i
].signed_type
);
9520 return make_unsigned_type (size
);
9522 return make_signed_type (size
);
9525 /* Create or reuse a fract type by SIZE, UNSIGNEDP, and SATP. */
9528 make_or_reuse_fract_type (unsigned size
, int unsignedp
, int satp
)
9532 if (size
== SHORT_FRACT_TYPE_SIZE
)
9533 return unsignedp
? sat_unsigned_short_fract_type_node
9534 : sat_short_fract_type_node
;
9535 if (size
== FRACT_TYPE_SIZE
)
9536 return unsignedp
? sat_unsigned_fract_type_node
: sat_fract_type_node
;
9537 if (size
== LONG_FRACT_TYPE_SIZE
)
9538 return unsignedp
? sat_unsigned_long_fract_type_node
9539 : sat_long_fract_type_node
;
9540 if (size
== LONG_LONG_FRACT_TYPE_SIZE
)
9541 return unsignedp
? sat_unsigned_long_long_fract_type_node
9542 : sat_long_long_fract_type_node
;
9546 if (size
== SHORT_FRACT_TYPE_SIZE
)
9547 return unsignedp
? unsigned_short_fract_type_node
9548 : short_fract_type_node
;
9549 if (size
== FRACT_TYPE_SIZE
)
9550 return unsignedp
? unsigned_fract_type_node
: fract_type_node
;
9551 if (size
== LONG_FRACT_TYPE_SIZE
)
9552 return unsignedp
? unsigned_long_fract_type_node
9553 : long_fract_type_node
;
9554 if (size
== LONG_LONG_FRACT_TYPE_SIZE
)
9555 return unsignedp
? unsigned_long_long_fract_type_node
9556 : long_long_fract_type_node
;
9559 return make_fract_type (size
, unsignedp
, satp
);
9562 /* Create or reuse an accum type by SIZE, UNSIGNEDP, and SATP. */
9565 make_or_reuse_accum_type (unsigned size
, int unsignedp
, int satp
)
9569 if (size
== SHORT_ACCUM_TYPE_SIZE
)
9570 return unsignedp
? sat_unsigned_short_accum_type_node
9571 : sat_short_accum_type_node
;
9572 if (size
== ACCUM_TYPE_SIZE
)
9573 return unsignedp
? sat_unsigned_accum_type_node
: sat_accum_type_node
;
9574 if (size
== LONG_ACCUM_TYPE_SIZE
)
9575 return unsignedp
? sat_unsigned_long_accum_type_node
9576 : sat_long_accum_type_node
;
9577 if (size
== LONG_LONG_ACCUM_TYPE_SIZE
)
9578 return unsignedp
? sat_unsigned_long_long_accum_type_node
9579 : sat_long_long_accum_type_node
;
9583 if (size
== SHORT_ACCUM_TYPE_SIZE
)
9584 return unsignedp
? unsigned_short_accum_type_node
9585 : short_accum_type_node
;
9586 if (size
== ACCUM_TYPE_SIZE
)
9587 return unsignedp
? unsigned_accum_type_node
: accum_type_node
;
9588 if (size
== LONG_ACCUM_TYPE_SIZE
)
9589 return unsignedp
? unsigned_long_accum_type_node
9590 : long_accum_type_node
;
9591 if (size
== LONG_LONG_ACCUM_TYPE_SIZE
)
9592 return unsignedp
? unsigned_long_long_accum_type_node
9593 : long_long_accum_type_node
;
9596 return make_accum_type (size
, unsignedp
, satp
);
9600 /* Create an atomic variant node for TYPE. This routine is called
9601 during initialization of data types to create the 5 basic atomic
9602 types. The generic build_variant_type function requires these to
9603 already be set up in order to function properly, so cannot be
9604 called from there. If ALIGN is non-zero, then ensure alignment is
9605 overridden to this value. */
9608 build_atomic_base (tree type
, unsigned int align
)
9612 /* Make sure its not already registered. */
9613 if ((t
= get_qualified_type (type
, TYPE_QUAL_ATOMIC
)))
9616 t
= build_variant_type_copy (type
);
9617 set_type_quals (t
, TYPE_QUAL_ATOMIC
);
9620 TYPE_ALIGN (t
) = align
;
9625 /* Create nodes for all integer types (and error_mark_node) using the sizes
9626 of C datatypes. SIGNED_CHAR specifies whether char is signed,
9627 SHORT_DOUBLE specifies whether double should be of the same precision
9631 build_common_tree_nodes (bool signed_char
, bool short_double
)
9635 error_mark_node
= make_node (ERROR_MARK
);
9636 TREE_TYPE (error_mark_node
) = error_mark_node
;
9638 initialize_sizetypes ();
9640 /* Define both `signed char' and `unsigned char'. */
9641 signed_char_type_node
= make_signed_type (CHAR_TYPE_SIZE
);
9642 TYPE_STRING_FLAG (signed_char_type_node
) = 1;
9643 unsigned_char_type_node
= make_unsigned_type (CHAR_TYPE_SIZE
);
9644 TYPE_STRING_FLAG (unsigned_char_type_node
) = 1;
9646 /* Define `char', which is like either `signed char' or `unsigned char'
9647 but not the same as either. */
9650 ? make_signed_type (CHAR_TYPE_SIZE
)
9651 : make_unsigned_type (CHAR_TYPE_SIZE
));
9652 TYPE_STRING_FLAG (char_type_node
) = 1;
9654 short_integer_type_node
= make_signed_type (SHORT_TYPE_SIZE
);
9655 short_unsigned_type_node
= make_unsigned_type (SHORT_TYPE_SIZE
);
9656 integer_type_node
= make_signed_type (INT_TYPE_SIZE
);
9657 unsigned_type_node
= make_unsigned_type (INT_TYPE_SIZE
);
9658 long_integer_type_node
= make_signed_type (LONG_TYPE_SIZE
);
9659 long_unsigned_type_node
= make_unsigned_type (LONG_TYPE_SIZE
);
9660 long_long_integer_type_node
= make_signed_type (LONG_LONG_TYPE_SIZE
);
9661 long_long_unsigned_type_node
= make_unsigned_type (LONG_LONG_TYPE_SIZE
);
9663 for (i
= 0; i
< NUM_INT_N_ENTS
; i
++)
9665 int_n_trees
[i
].signed_type
= make_signed_type (int_n_data
[i
].bitsize
);
9666 int_n_trees
[i
].unsigned_type
= make_unsigned_type (int_n_data
[i
].bitsize
);
9667 TYPE_SIZE (int_n_trees
[i
].signed_type
) = bitsize_int (int_n_data
[i
].bitsize
);
9668 TYPE_SIZE (int_n_trees
[i
].unsigned_type
) = bitsize_int (int_n_data
[i
].bitsize
);
9670 if (int_n_data
[i
].bitsize
> LONG_LONG_TYPE_SIZE
9671 && int_n_enabled_p
[i
])
9673 integer_types
[itk_intN_0
+ i
* 2] = int_n_trees
[i
].signed_type
;
9674 integer_types
[itk_unsigned_intN_0
+ i
* 2] = int_n_trees
[i
].unsigned_type
;
9678 /* Define a boolean type. This type only represents boolean values but
9679 may be larger than char depending on the value of BOOL_TYPE_SIZE. */
9680 boolean_type_node
= make_unsigned_type (BOOL_TYPE_SIZE
);
9681 TREE_SET_CODE (boolean_type_node
, BOOLEAN_TYPE
);
9682 TYPE_PRECISION (boolean_type_node
) = 1;
9683 TYPE_MAX_VALUE (boolean_type_node
) = build_int_cst (boolean_type_node
, 1);
9685 /* Define what type to use for size_t. */
9686 if (strcmp (SIZE_TYPE
, "unsigned int") == 0)
9687 size_type_node
= unsigned_type_node
;
9688 else if (strcmp (SIZE_TYPE
, "long unsigned int") == 0)
9689 size_type_node
= long_unsigned_type_node
;
9690 else if (strcmp (SIZE_TYPE
, "long long unsigned int") == 0)
9691 size_type_node
= long_long_unsigned_type_node
;
9692 else if (strcmp (SIZE_TYPE
, "short unsigned int") == 0)
9693 size_type_node
= short_unsigned_type_node
;
9698 size_type_node
= NULL_TREE
;
9699 for (i
= 0; i
< NUM_INT_N_ENTS
; i
++)
9700 if (int_n_enabled_p
[i
])
9703 sprintf (name
, "__int%d unsigned", int_n_data
[i
].bitsize
);
9705 if (strcmp (name
, SIZE_TYPE
) == 0)
9707 size_type_node
= int_n_trees
[i
].unsigned_type
;
9710 if (size_type_node
== NULL_TREE
)
9714 /* Fill in the rest of the sized types. Reuse existing type nodes
9716 intQI_type_node
= make_or_reuse_type (GET_MODE_BITSIZE (QImode
), 0);
9717 intHI_type_node
= make_or_reuse_type (GET_MODE_BITSIZE (HImode
), 0);
9718 intSI_type_node
= make_or_reuse_type (GET_MODE_BITSIZE (SImode
), 0);
9719 intDI_type_node
= make_or_reuse_type (GET_MODE_BITSIZE (DImode
), 0);
9720 intTI_type_node
= make_or_reuse_type (GET_MODE_BITSIZE (TImode
), 0);
9722 unsigned_intQI_type_node
= make_or_reuse_type (GET_MODE_BITSIZE (QImode
), 1);
9723 unsigned_intHI_type_node
= make_or_reuse_type (GET_MODE_BITSIZE (HImode
), 1);
9724 unsigned_intSI_type_node
= make_or_reuse_type (GET_MODE_BITSIZE (SImode
), 1);
9725 unsigned_intDI_type_node
= make_or_reuse_type (GET_MODE_BITSIZE (DImode
), 1);
9726 unsigned_intTI_type_node
= make_or_reuse_type (GET_MODE_BITSIZE (TImode
), 1);
9728 /* Don't call build_qualified type for atomics. That routine does
9729 special processing for atomics, and until they are initialized
9730 it's better not to make that call.
9732 Check to see if there is a target override for atomic types. */
9734 atomicQI_type_node
= build_atomic_base (unsigned_intQI_type_node
,
9735 targetm
.atomic_align_for_mode (QImode
));
9736 atomicHI_type_node
= build_atomic_base (unsigned_intHI_type_node
,
9737 targetm
.atomic_align_for_mode (HImode
));
9738 atomicSI_type_node
= build_atomic_base (unsigned_intSI_type_node
,
9739 targetm
.atomic_align_for_mode (SImode
));
9740 atomicDI_type_node
= build_atomic_base (unsigned_intDI_type_node
,
9741 targetm
.atomic_align_for_mode (DImode
));
9742 atomicTI_type_node
= build_atomic_base (unsigned_intTI_type_node
,
9743 targetm
.atomic_align_for_mode (TImode
));
9745 access_public_node
= get_identifier ("public");
9746 access_protected_node
= get_identifier ("protected");
9747 access_private_node
= get_identifier ("private");
9749 /* Define these next since types below may used them. */
9750 integer_zero_node
= build_int_cst (integer_type_node
, 0);
9751 integer_one_node
= build_int_cst (integer_type_node
, 1);
9752 integer_three_node
= build_int_cst (integer_type_node
, 3);
9753 integer_minus_one_node
= build_int_cst (integer_type_node
, -1);
9755 size_zero_node
= size_int (0);
9756 size_one_node
= size_int (1);
9757 bitsize_zero_node
= bitsize_int (0);
9758 bitsize_one_node
= bitsize_int (1);
9759 bitsize_unit_node
= bitsize_int (BITS_PER_UNIT
);
9761 boolean_false_node
= TYPE_MIN_VALUE (boolean_type_node
);
9762 boolean_true_node
= TYPE_MAX_VALUE (boolean_type_node
);
9764 void_type_node
= make_node (VOID_TYPE
);
9765 layout_type (void_type_node
);
9767 pointer_bounds_type_node
= targetm
.chkp_bound_type ();
9769 /* We are not going to have real types in C with less than byte alignment,
9770 so we might as well not have any types that claim to have it. */
9771 TYPE_ALIGN (void_type_node
) = BITS_PER_UNIT
;
9772 TYPE_USER_ALIGN (void_type_node
) = 0;
9774 void_node
= make_node (VOID_CST
);
9775 TREE_TYPE (void_node
) = void_type_node
;
9777 null_pointer_node
= build_int_cst (build_pointer_type (void_type_node
), 0);
9778 layout_type (TREE_TYPE (null_pointer_node
));
9780 ptr_type_node
= build_pointer_type (void_type_node
);
9782 = build_pointer_type (build_type_variant (void_type_node
, 1, 0));
9783 fileptr_type_node
= ptr_type_node
;
9785 pointer_sized_int_node
= build_nonstandard_integer_type (POINTER_SIZE
, 1);
9787 float_type_node
= make_node (REAL_TYPE
);
9788 TYPE_PRECISION (float_type_node
) = FLOAT_TYPE_SIZE
;
9789 layout_type (float_type_node
);
9791 double_type_node
= make_node (REAL_TYPE
);
9793 TYPE_PRECISION (double_type_node
) = FLOAT_TYPE_SIZE
;
9795 TYPE_PRECISION (double_type_node
) = DOUBLE_TYPE_SIZE
;
9796 layout_type (double_type_node
);
9798 long_double_type_node
= make_node (REAL_TYPE
);
9799 TYPE_PRECISION (long_double_type_node
) = LONG_DOUBLE_TYPE_SIZE
;
9800 layout_type (long_double_type_node
);
9802 float_ptr_type_node
= build_pointer_type (float_type_node
);
9803 double_ptr_type_node
= build_pointer_type (double_type_node
);
9804 long_double_ptr_type_node
= build_pointer_type (long_double_type_node
);
9805 integer_ptr_type_node
= build_pointer_type (integer_type_node
);
9807 /* Fixed size integer types. */
9808 uint16_type_node
= make_or_reuse_type (16, 1);
9809 uint32_type_node
= make_or_reuse_type (32, 1);
9810 uint64_type_node
= make_or_reuse_type (64, 1);
9812 /* Decimal float types. */
9813 dfloat32_type_node
= make_node (REAL_TYPE
);
9814 TYPE_PRECISION (dfloat32_type_node
) = DECIMAL32_TYPE_SIZE
;
9815 layout_type (dfloat32_type_node
);
9816 SET_TYPE_MODE (dfloat32_type_node
, SDmode
);
9817 dfloat32_ptr_type_node
= build_pointer_type (dfloat32_type_node
);
9819 dfloat64_type_node
= make_node (REAL_TYPE
);
9820 TYPE_PRECISION (dfloat64_type_node
) = DECIMAL64_TYPE_SIZE
;
9821 layout_type (dfloat64_type_node
);
9822 SET_TYPE_MODE (dfloat64_type_node
, DDmode
);
9823 dfloat64_ptr_type_node
= build_pointer_type (dfloat64_type_node
);
9825 dfloat128_type_node
= make_node (REAL_TYPE
);
9826 TYPE_PRECISION (dfloat128_type_node
) = DECIMAL128_TYPE_SIZE
;
9827 layout_type (dfloat128_type_node
);
9828 SET_TYPE_MODE (dfloat128_type_node
, TDmode
);
9829 dfloat128_ptr_type_node
= build_pointer_type (dfloat128_type_node
);
9831 complex_integer_type_node
= build_complex_type (integer_type_node
);
9832 complex_float_type_node
= build_complex_type (float_type_node
);
9833 complex_double_type_node
= build_complex_type (double_type_node
);
9834 complex_long_double_type_node
= build_complex_type (long_double_type_node
);
9836 /* Make fixed-point nodes based on sat/non-sat and signed/unsigned. */
9837 #define MAKE_FIXED_TYPE_NODE(KIND,SIZE) \
9838 sat_ ## KIND ## _type_node = \
9839 make_sat_signed_ ## KIND ## _type (SIZE); \
9840 sat_unsigned_ ## KIND ## _type_node = \
9841 make_sat_unsigned_ ## KIND ## _type (SIZE); \
9842 KIND ## _type_node = make_signed_ ## KIND ## _type (SIZE); \
9843 unsigned_ ## KIND ## _type_node = \
9844 make_unsigned_ ## KIND ## _type (SIZE);
9846 #define MAKE_FIXED_TYPE_NODE_WIDTH(KIND,WIDTH,SIZE) \
9847 sat_ ## WIDTH ## KIND ## _type_node = \
9848 make_sat_signed_ ## KIND ## _type (SIZE); \
9849 sat_unsigned_ ## WIDTH ## KIND ## _type_node = \
9850 make_sat_unsigned_ ## KIND ## _type (SIZE); \
9851 WIDTH ## KIND ## _type_node = make_signed_ ## KIND ## _type (SIZE); \
9852 unsigned_ ## WIDTH ## KIND ## _type_node = \
9853 make_unsigned_ ## KIND ## _type (SIZE);
9855 /* Make fixed-point type nodes based on four different widths. */
9856 #define MAKE_FIXED_TYPE_NODE_FAMILY(N1,N2) \
9857 MAKE_FIXED_TYPE_NODE_WIDTH (N1, short_, SHORT_ ## N2 ## _TYPE_SIZE) \
9858 MAKE_FIXED_TYPE_NODE (N1, N2 ## _TYPE_SIZE) \
9859 MAKE_FIXED_TYPE_NODE_WIDTH (N1, long_, LONG_ ## N2 ## _TYPE_SIZE) \
9860 MAKE_FIXED_TYPE_NODE_WIDTH (N1, long_long_, LONG_LONG_ ## N2 ## _TYPE_SIZE)
9862 /* Make fixed-point mode nodes based on sat/non-sat and signed/unsigned. */
9863 #define MAKE_FIXED_MODE_NODE(KIND,NAME,MODE) \
9864 NAME ## _type_node = \
9865 make_or_reuse_signed_ ## KIND ## _type (GET_MODE_BITSIZE (MODE ## mode)); \
9866 u ## NAME ## _type_node = \
9867 make_or_reuse_unsigned_ ## KIND ## _type \
9868 (GET_MODE_BITSIZE (U ## MODE ## mode)); \
9869 sat_ ## NAME ## _type_node = \
9870 make_or_reuse_sat_signed_ ## KIND ## _type \
9871 (GET_MODE_BITSIZE (MODE ## mode)); \
9872 sat_u ## NAME ## _type_node = \
9873 make_or_reuse_sat_unsigned_ ## KIND ## _type \
9874 (GET_MODE_BITSIZE (U ## MODE ## mode));
9876 /* Fixed-point type and mode nodes. */
9877 MAKE_FIXED_TYPE_NODE_FAMILY (fract
, FRACT
)
9878 MAKE_FIXED_TYPE_NODE_FAMILY (accum
, ACCUM
)
9879 MAKE_FIXED_MODE_NODE (fract
, qq
, QQ
)
9880 MAKE_FIXED_MODE_NODE (fract
, hq
, HQ
)
9881 MAKE_FIXED_MODE_NODE (fract
, sq
, SQ
)
9882 MAKE_FIXED_MODE_NODE (fract
, dq
, DQ
)
9883 MAKE_FIXED_MODE_NODE (fract
, tq
, TQ
)
9884 MAKE_FIXED_MODE_NODE (accum
, ha
, HA
)
9885 MAKE_FIXED_MODE_NODE (accum
, sa
, SA
)
9886 MAKE_FIXED_MODE_NODE (accum
, da
, DA
)
9887 MAKE_FIXED_MODE_NODE (accum
, ta
, TA
)
9890 tree t
= targetm
.build_builtin_va_list ();
9892 /* Many back-ends define record types without setting TYPE_NAME.
9893 If we copied the record type here, we'd keep the original
9894 record type without a name. This breaks name mangling. So,
9895 don't copy record types and let c_common_nodes_and_builtins()
9896 declare the type to be __builtin_va_list. */
9897 if (TREE_CODE (t
) != RECORD_TYPE
)
9898 t
= build_variant_type_copy (t
);
9900 va_list_type_node
= t
;
9904 /* Modify DECL for given flags.
9905 TM_PURE attribute is set only on types, so the function will modify
9906 DECL's type when ECF_TM_PURE is used. */
9909 set_call_expr_flags (tree decl
, int flags
)
9911 if (flags
& ECF_NOTHROW
)
9912 TREE_NOTHROW (decl
) = 1;
9913 if (flags
& ECF_CONST
)
9914 TREE_READONLY (decl
) = 1;
9915 if (flags
& ECF_PURE
)
9916 DECL_PURE_P (decl
) = 1;
9917 if (flags
& ECF_LOOPING_CONST_OR_PURE
)
9918 DECL_LOOPING_CONST_OR_PURE_P (decl
) = 1;
9919 if (flags
& ECF_NOVOPS
)
9920 DECL_IS_NOVOPS (decl
) = 1;
9921 if (flags
& ECF_NORETURN
)
9922 TREE_THIS_VOLATILE (decl
) = 1;
9923 if (flags
& ECF_MALLOC
)
9924 DECL_IS_MALLOC (decl
) = 1;
9925 if (flags
& ECF_RETURNS_TWICE
)
9926 DECL_IS_RETURNS_TWICE (decl
) = 1;
9927 if (flags
& ECF_LEAF
)
9928 DECL_ATTRIBUTES (decl
) = tree_cons (get_identifier ("leaf"),
9929 NULL
, DECL_ATTRIBUTES (decl
));
9930 if ((flags
& ECF_TM_PURE
) && flag_tm
)
9931 apply_tm_attr (decl
, get_identifier ("transaction_pure"));
9932 /* Looping const or pure is implied by noreturn.
9933 There is currently no way to declare looping const or looping pure alone. */
9934 gcc_assert (!(flags
& ECF_LOOPING_CONST_OR_PURE
)
9935 || ((flags
& ECF_NORETURN
) && (flags
& (ECF_CONST
| ECF_PURE
))));
9939 /* A subroutine of build_common_builtin_nodes. Define a builtin function. */
9942 local_define_builtin (const char *name
, tree type
, enum built_in_function code
,
9943 const char *library_name
, int ecf_flags
)
9947 decl
= add_builtin_function (name
, type
, code
, BUILT_IN_NORMAL
,
9948 library_name
, NULL_TREE
);
9949 set_call_expr_flags (decl
, ecf_flags
);
9951 set_builtin_decl (code
, decl
, true);
9954 /* Call this function after instantiating all builtins that the language
9955 front end cares about. This will build the rest of the builtins
9956 and internal functions that are relied upon by the tree optimizers and
9960 build_common_builtin_nodes (void)
9965 if (!builtin_decl_explicit_p (BUILT_IN_UNREACHABLE
))
9967 ftype
= build_function_type (void_type_node
, void_list_node
);
9968 local_define_builtin ("__builtin_unreachable", ftype
, BUILT_IN_UNREACHABLE
,
9969 "__builtin_unreachable",
9970 ECF_NOTHROW
| ECF_LEAF
| ECF_NORETURN
9974 if (!builtin_decl_explicit_p (BUILT_IN_MEMCPY
)
9975 || !builtin_decl_explicit_p (BUILT_IN_MEMMOVE
))
9977 ftype
= build_function_type_list (ptr_type_node
,
9978 ptr_type_node
, const_ptr_type_node
,
9979 size_type_node
, NULL_TREE
);
9981 if (!builtin_decl_explicit_p (BUILT_IN_MEMCPY
))
9982 local_define_builtin ("__builtin_memcpy", ftype
, BUILT_IN_MEMCPY
,
9983 "memcpy", ECF_NOTHROW
| ECF_LEAF
);
9984 if (!builtin_decl_explicit_p (BUILT_IN_MEMMOVE
))
9985 local_define_builtin ("__builtin_memmove", ftype
, BUILT_IN_MEMMOVE
,
9986 "memmove", ECF_NOTHROW
| ECF_LEAF
);
9989 if (!builtin_decl_explicit_p (BUILT_IN_MEMCMP
))
9991 ftype
= build_function_type_list (integer_type_node
, const_ptr_type_node
,
9992 const_ptr_type_node
, size_type_node
,
9994 local_define_builtin ("__builtin_memcmp", ftype
, BUILT_IN_MEMCMP
,
9995 "memcmp", ECF_PURE
| ECF_NOTHROW
| ECF_LEAF
);
9998 if (!builtin_decl_explicit_p (BUILT_IN_MEMSET
))
10000 ftype
= build_function_type_list (ptr_type_node
,
10001 ptr_type_node
, integer_type_node
,
10002 size_type_node
, NULL_TREE
);
10003 local_define_builtin ("__builtin_memset", ftype
, BUILT_IN_MEMSET
,
10004 "memset", ECF_NOTHROW
| ECF_LEAF
);
10007 if (!builtin_decl_explicit_p (BUILT_IN_ALLOCA
))
10009 ftype
= build_function_type_list (ptr_type_node
,
10010 size_type_node
, NULL_TREE
);
10011 local_define_builtin ("__builtin_alloca", ftype
, BUILT_IN_ALLOCA
,
10012 "alloca", ECF_MALLOC
| ECF_NOTHROW
| ECF_LEAF
);
10015 ftype
= build_function_type_list (ptr_type_node
, size_type_node
,
10016 size_type_node
, NULL_TREE
);
10017 local_define_builtin ("__builtin_alloca_with_align", ftype
,
10018 BUILT_IN_ALLOCA_WITH_ALIGN
, "alloca",
10019 ECF_MALLOC
| ECF_NOTHROW
| ECF_LEAF
);
10021 /* If we're checking the stack, `alloca' can throw. */
10022 if (flag_stack_check
)
10024 TREE_NOTHROW (builtin_decl_explicit (BUILT_IN_ALLOCA
)) = 0;
10025 TREE_NOTHROW (builtin_decl_explicit (BUILT_IN_ALLOCA_WITH_ALIGN
)) = 0;
10028 ftype
= build_function_type_list (void_type_node
,
10029 ptr_type_node
, ptr_type_node
,
10030 ptr_type_node
, NULL_TREE
);
10031 local_define_builtin ("__builtin_init_trampoline", ftype
,
10032 BUILT_IN_INIT_TRAMPOLINE
,
10033 "__builtin_init_trampoline", ECF_NOTHROW
| ECF_LEAF
);
10034 local_define_builtin ("__builtin_init_heap_trampoline", ftype
,
10035 BUILT_IN_INIT_HEAP_TRAMPOLINE
,
10036 "__builtin_init_heap_trampoline",
10037 ECF_NOTHROW
| ECF_LEAF
);
10039 ftype
= build_function_type_list (ptr_type_node
, ptr_type_node
, NULL_TREE
);
10040 local_define_builtin ("__builtin_adjust_trampoline", ftype
,
10041 BUILT_IN_ADJUST_TRAMPOLINE
,
10042 "__builtin_adjust_trampoline",
10043 ECF_CONST
| ECF_NOTHROW
);
10045 ftype
= build_function_type_list (void_type_node
,
10046 ptr_type_node
, ptr_type_node
, NULL_TREE
);
10047 local_define_builtin ("__builtin_nonlocal_goto", ftype
,
10048 BUILT_IN_NONLOCAL_GOTO
,
10049 "__builtin_nonlocal_goto",
10050 ECF_NORETURN
| ECF_NOTHROW
);
10052 ftype
= build_function_type_list (void_type_node
,
10053 ptr_type_node
, ptr_type_node
, NULL_TREE
);
10054 local_define_builtin ("__builtin_setjmp_setup", ftype
,
10055 BUILT_IN_SETJMP_SETUP
,
10056 "__builtin_setjmp_setup", ECF_NOTHROW
);
10058 ftype
= build_function_type_list (void_type_node
, ptr_type_node
, NULL_TREE
);
10059 local_define_builtin ("__builtin_setjmp_receiver", ftype
,
10060 BUILT_IN_SETJMP_RECEIVER
,
10061 "__builtin_setjmp_receiver", ECF_NOTHROW
| ECF_LEAF
);
10063 ftype
= build_function_type_list (ptr_type_node
, NULL_TREE
);
10064 local_define_builtin ("__builtin_stack_save", ftype
, BUILT_IN_STACK_SAVE
,
10065 "__builtin_stack_save", ECF_NOTHROW
| ECF_LEAF
);
10067 ftype
= build_function_type_list (void_type_node
, ptr_type_node
, NULL_TREE
);
10068 local_define_builtin ("__builtin_stack_restore", ftype
,
10069 BUILT_IN_STACK_RESTORE
,
10070 "__builtin_stack_restore", ECF_NOTHROW
| ECF_LEAF
);
10072 /* If there's a possibility that we might use the ARM EABI, build the
10073 alternate __cxa_end_cleanup node used to resume from C++ and Java. */
10074 if (targetm
.arm_eabi_unwinder
)
10076 ftype
= build_function_type_list (void_type_node
, NULL_TREE
);
10077 local_define_builtin ("__builtin_cxa_end_cleanup", ftype
,
10078 BUILT_IN_CXA_END_CLEANUP
,
10079 "__cxa_end_cleanup", ECF_NORETURN
| ECF_LEAF
);
10082 ftype
= build_function_type_list (void_type_node
, ptr_type_node
, NULL_TREE
);
10083 local_define_builtin ("__builtin_unwind_resume", ftype
,
10084 BUILT_IN_UNWIND_RESUME
,
10085 ((targetm_common
.except_unwind_info (&global_options
)
10087 ? "_Unwind_SjLj_Resume" : "_Unwind_Resume"),
10090 if (builtin_decl_explicit (BUILT_IN_RETURN_ADDRESS
) == NULL_TREE
)
10092 ftype
= build_function_type_list (ptr_type_node
, integer_type_node
,
10094 local_define_builtin ("__builtin_return_address", ftype
,
10095 BUILT_IN_RETURN_ADDRESS
,
10096 "__builtin_return_address",
10100 if (!builtin_decl_explicit_p (BUILT_IN_PROFILE_FUNC_ENTER
)
10101 || !builtin_decl_explicit_p (BUILT_IN_PROFILE_FUNC_EXIT
))
10103 ftype
= build_function_type_list (void_type_node
, ptr_type_node
,
10104 ptr_type_node
, NULL_TREE
);
10105 if (!builtin_decl_explicit_p (BUILT_IN_PROFILE_FUNC_ENTER
))
10106 local_define_builtin ("__cyg_profile_func_enter", ftype
,
10107 BUILT_IN_PROFILE_FUNC_ENTER
,
10108 "__cyg_profile_func_enter", 0);
10109 if (!builtin_decl_explicit_p (BUILT_IN_PROFILE_FUNC_EXIT
))
10110 local_define_builtin ("__cyg_profile_func_exit", ftype
,
10111 BUILT_IN_PROFILE_FUNC_EXIT
,
10112 "__cyg_profile_func_exit", 0);
10115 /* The exception object and filter values from the runtime. The argument
10116 must be zero before exception lowering, i.e. from the front end. After
10117 exception lowering, it will be the region number for the exception
10118 landing pad. These functions are PURE instead of CONST to prevent
10119 them from being hoisted past the exception edge that will initialize
10120 its value in the landing pad. */
10121 ftype
= build_function_type_list (ptr_type_node
,
10122 integer_type_node
, NULL_TREE
);
10123 ecf_flags
= ECF_PURE
| ECF_NOTHROW
| ECF_LEAF
;
10124 /* Only use TM_PURE if we we have TM language support. */
10125 if (builtin_decl_explicit_p (BUILT_IN_TM_LOAD_1
))
10126 ecf_flags
|= ECF_TM_PURE
;
10127 local_define_builtin ("__builtin_eh_pointer", ftype
, BUILT_IN_EH_POINTER
,
10128 "__builtin_eh_pointer", ecf_flags
);
10130 tmp
= lang_hooks
.types
.type_for_mode (targetm
.eh_return_filter_mode (), 0);
10131 ftype
= build_function_type_list (tmp
, integer_type_node
, NULL_TREE
);
10132 local_define_builtin ("__builtin_eh_filter", ftype
, BUILT_IN_EH_FILTER
,
10133 "__builtin_eh_filter", ECF_PURE
| ECF_NOTHROW
| ECF_LEAF
);
10135 ftype
= build_function_type_list (void_type_node
,
10136 integer_type_node
, integer_type_node
,
10138 local_define_builtin ("__builtin_eh_copy_values", ftype
,
10139 BUILT_IN_EH_COPY_VALUES
,
10140 "__builtin_eh_copy_values", ECF_NOTHROW
);
10142 /* Complex multiplication and division. These are handled as builtins
10143 rather than optabs because emit_library_call_value doesn't support
10144 complex. Further, we can do slightly better with folding these
10145 beasties if the real and complex parts of the arguments are separate. */
10149 for (mode
= MIN_MODE_COMPLEX_FLOAT
; mode
<= MAX_MODE_COMPLEX_FLOAT
; ++mode
)
10151 char mode_name_buf
[4], *q
;
10153 enum built_in_function mcode
, dcode
;
10154 tree type
, inner_type
;
10155 const char *prefix
= "__";
10157 if (targetm
.libfunc_gnu_prefix
)
10160 type
= lang_hooks
.types
.type_for_mode ((machine_mode
) mode
, 0);
10163 inner_type
= TREE_TYPE (type
);
10165 ftype
= build_function_type_list (type
, inner_type
, inner_type
,
10166 inner_type
, inner_type
, NULL_TREE
);
10168 mcode
= ((enum built_in_function
)
10169 (BUILT_IN_COMPLEX_MUL_MIN
+ mode
- MIN_MODE_COMPLEX_FLOAT
));
10170 dcode
= ((enum built_in_function
)
10171 (BUILT_IN_COMPLEX_DIV_MIN
+ mode
- MIN_MODE_COMPLEX_FLOAT
));
10173 for (p
= GET_MODE_NAME (mode
), q
= mode_name_buf
; *p
; p
++, q
++)
10177 built_in_names
[mcode
] = concat (prefix
, "mul", mode_name_buf
, "3",
10179 local_define_builtin (built_in_names
[mcode
], ftype
, mcode
,
10180 built_in_names
[mcode
],
10181 ECF_CONST
| ECF_NOTHROW
| ECF_LEAF
);
10183 built_in_names
[dcode
] = concat (prefix
, "div", mode_name_buf
, "3",
10185 local_define_builtin (built_in_names
[dcode
], ftype
, dcode
,
10186 built_in_names
[dcode
],
10187 ECF_CONST
| ECF_NOTHROW
| ECF_LEAF
);
10191 init_internal_fns ();
10194 /* HACK. GROSS. This is absolutely disgusting. I wish there was a
10197 If we requested a pointer to a vector, build up the pointers that
10198 we stripped off while looking for the inner type. Similarly for
10199 return values from functions.
10201 The argument TYPE is the top of the chain, and BOTTOM is the
10202 new type which we will point to. */
10205 reconstruct_complex_type (tree type
, tree bottom
)
10209 if (TREE_CODE (type
) == POINTER_TYPE
)
10211 inner
= reconstruct_complex_type (TREE_TYPE (type
), bottom
);
10212 outer
= build_pointer_type_for_mode (inner
, TYPE_MODE (type
),
10213 TYPE_REF_CAN_ALIAS_ALL (type
));
10215 else if (TREE_CODE (type
) == REFERENCE_TYPE
)
10217 inner
= reconstruct_complex_type (TREE_TYPE (type
), bottom
);
10218 outer
= build_reference_type_for_mode (inner
, TYPE_MODE (type
),
10219 TYPE_REF_CAN_ALIAS_ALL (type
));
10221 else if (TREE_CODE (type
) == ARRAY_TYPE
)
10223 inner
= reconstruct_complex_type (TREE_TYPE (type
), bottom
);
10224 outer
= build_array_type (inner
, TYPE_DOMAIN (type
));
10226 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
10228 inner
= reconstruct_complex_type (TREE_TYPE (type
), bottom
);
10229 outer
= build_function_type (inner
, TYPE_ARG_TYPES (type
));
10231 else if (TREE_CODE (type
) == METHOD_TYPE
)
10233 inner
= reconstruct_complex_type (TREE_TYPE (type
), bottom
);
10234 /* The build_method_type_directly() routine prepends 'this' to argument list,
10235 so we must compensate by getting rid of it. */
10237 = build_method_type_directly
10238 (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (type
))),
10240 TREE_CHAIN (TYPE_ARG_TYPES (type
)));
10242 else if (TREE_CODE (type
) == OFFSET_TYPE
)
10244 inner
= reconstruct_complex_type (TREE_TYPE (type
), bottom
);
10245 outer
= build_offset_type (TYPE_OFFSET_BASETYPE (type
), inner
);
10250 return build_type_attribute_qual_variant (outer
, TYPE_ATTRIBUTES (type
),
10251 TYPE_QUALS (type
));
10254 /* Returns a vector tree node given a mode (integer, vector, or BLKmode) and
10257 build_vector_type_for_mode (tree innertype
, machine_mode mode
)
10261 switch (GET_MODE_CLASS (mode
))
10263 case MODE_VECTOR_INT
:
10264 case MODE_VECTOR_FLOAT
:
10265 case MODE_VECTOR_FRACT
:
10266 case MODE_VECTOR_UFRACT
:
10267 case MODE_VECTOR_ACCUM
:
10268 case MODE_VECTOR_UACCUM
:
10269 nunits
= GET_MODE_NUNITS (mode
);
10273 /* Check that there are no leftover bits. */
10274 gcc_assert (GET_MODE_BITSIZE (mode
)
10275 % TREE_INT_CST_LOW (TYPE_SIZE (innertype
)) == 0);
10277 nunits
= GET_MODE_BITSIZE (mode
)
10278 / TREE_INT_CST_LOW (TYPE_SIZE (innertype
));
10282 gcc_unreachable ();
10285 return make_vector_type (innertype
, nunits
, mode
);
10288 /* Similarly, but takes the inner type and number of units, which must be
10292 build_vector_type (tree innertype
, int nunits
)
10294 return make_vector_type (innertype
, nunits
, VOIDmode
);
10297 /* Similarly, but builds a variant type with TYPE_VECTOR_OPAQUE set. */
10300 build_opaque_vector_type (tree innertype
, int nunits
)
10302 tree t
= make_vector_type (innertype
, nunits
, VOIDmode
);
10304 /* We always build the non-opaque variant before the opaque one,
10305 so if it already exists, it is TYPE_NEXT_VARIANT of this one. */
10306 cand
= TYPE_NEXT_VARIANT (t
);
10308 && TYPE_VECTOR_OPAQUE (cand
)
10309 && check_qualified_type (cand
, t
, TYPE_QUALS (t
)))
10311 /* Othewise build a variant type and make sure to queue it after
10312 the non-opaque type. */
10313 cand
= build_distinct_type_copy (t
);
10314 TYPE_VECTOR_OPAQUE (cand
) = true;
10315 TYPE_CANONICAL (cand
) = TYPE_CANONICAL (t
);
10316 TYPE_NEXT_VARIANT (cand
) = TYPE_NEXT_VARIANT (t
);
10317 TYPE_NEXT_VARIANT (t
) = cand
;
10318 TYPE_MAIN_VARIANT (cand
) = TYPE_MAIN_VARIANT (t
);
10323 /* Given an initializer INIT, return TRUE if INIT is zero or some
10324 aggregate of zeros. Otherwise return FALSE. */
10326 initializer_zerop (const_tree init
)
10332 switch (TREE_CODE (init
))
10335 return integer_zerop (init
);
10338 /* ??? Note that this is not correct for C4X float formats. There,
10339 a bit pattern of all zeros is 1.0; 0.0 is encoded with the most
10340 negative exponent. */
10341 return real_zerop (init
)
10342 && ! REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (init
));
10345 return fixed_zerop (init
);
10348 return integer_zerop (init
)
10349 || (real_zerop (init
)
10350 && ! REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (TREE_REALPART (init
)))
10351 && ! REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (TREE_IMAGPART (init
))));
10356 for (i
= 0; i
< VECTOR_CST_NELTS (init
); ++i
)
10357 if (!initializer_zerop (VECTOR_CST_ELT (init
, i
)))
10364 unsigned HOST_WIDE_INT idx
;
10366 if (TREE_CLOBBER_P (init
))
10368 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (init
), idx
, elt
)
10369 if (!initializer_zerop (elt
))
10378 /* We need to loop through all elements to handle cases like
10379 "\0" and "\0foobar". */
10380 for (i
= 0; i
< TREE_STRING_LENGTH (init
); ++i
)
10381 if (TREE_STRING_POINTER (init
)[i
] != '\0')
10392 /* Check if vector VEC consists of all the equal elements and
10393 that the number of elements corresponds to the type of VEC.
10394 The function returns first element of the vector
10395 or NULL_TREE if the vector is not uniform. */
10397 uniform_vector_p (const_tree vec
)
10402 if (vec
== NULL_TREE
)
10405 gcc_assert (VECTOR_TYPE_P (TREE_TYPE (vec
)));
10407 if (TREE_CODE (vec
) == VECTOR_CST
)
10409 first
= VECTOR_CST_ELT (vec
, 0);
10410 for (i
= 1; i
< VECTOR_CST_NELTS (vec
); ++i
)
10411 if (!operand_equal_p (first
, VECTOR_CST_ELT (vec
, i
), 0))
10417 else if (TREE_CODE (vec
) == CONSTRUCTOR
)
10419 first
= error_mark_node
;
10421 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (vec
), i
, t
)
10428 if (!operand_equal_p (first
, t
, 0))
10431 if (i
!= TYPE_VECTOR_SUBPARTS (TREE_TYPE (vec
)))
10440 /* Build an empty statement at location LOC. */
10443 build_empty_stmt (location_t loc
)
10445 tree t
= build1 (NOP_EXPR
, void_type_node
, size_zero_node
);
10446 SET_EXPR_LOCATION (t
, loc
);
10451 /* Build an OpenMP clause with code CODE. LOC is the location of the
10455 build_omp_clause (location_t loc
, enum omp_clause_code code
)
10460 length
= omp_clause_num_ops
[code
];
10461 size
= (sizeof (struct tree_omp_clause
) + (length
- 1) * sizeof (tree
));
10463 record_node_allocation_statistics (OMP_CLAUSE
, size
);
10465 t
= (tree
) ggc_internal_alloc (size
);
10466 memset (t
, 0, size
);
10467 TREE_SET_CODE (t
, OMP_CLAUSE
);
10468 OMP_CLAUSE_SET_CODE (t
, code
);
10469 OMP_CLAUSE_LOCATION (t
) = loc
;
10474 /* Build a tcc_vl_exp object with code CODE and room for LEN operands. LEN
10475 includes the implicit operand count in TREE_OPERAND 0, and so must be >= 1.
10476 Except for the CODE and operand count field, other storage for the
10477 object is initialized to zeros. */
10480 build_vl_exp_stat (enum tree_code code
, int len MEM_STAT_DECL
)
10483 int length
= (len
- 1) * sizeof (tree
) + sizeof (struct tree_exp
);
10485 gcc_assert (TREE_CODE_CLASS (code
) == tcc_vl_exp
);
10486 gcc_assert (len
>= 1);
10488 record_node_allocation_statistics (code
, length
);
10490 t
= ggc_alloc_cleared_tree_node_stat (length PASS_MEM_STAT
);
10492 TREE_SET_CODE (t
, code
);
10494 /* Can't use TREE_OPERAND to store the length because if checking is
10495 enabled, it will try to check the length before we store it. :-P */
10496 t
->exp
.operands
[0] = build_int_cst (sizetype
, len
);
10501 /* Helper function for build_call_* functions; build a CALL_EXPR with
10502 indicated RETURN_TYPE, FN, and NARGS, but do not initialize any of
10503 the argument slots. */
10506 build_call_1 (tree return_type
, tree fn
, int nargs
)
10510 t
= build_vl_exp (CALL_EXPR
, nargs
+ 3);
10511 TREE_TYPE (t
) = return_type
;
10512 CALL_EXPR_FN (t
) = fn
;
10513 CALL_EXPR_STATIC_CHAIN (t
) = NULL
;
10518 /* Build a CALL_EXPR of class tcc_vl_exp with the indicated RETURN_TYPE and
10519 FN and a null static chain slot. NARGS is the number of call arguments
10520 which are specified as "..." arguments. */
10523 build_call_nary (tree return_type
, tree fn
, int nargs
, ...)
10527 va_start (args
, nargs
);
10528 ret
= build_call_valist (return_type
, fn
, nargs
, args
);
10533 /* Build a CALL_EXPR of class tcc_vl_exp with the indicated RETURN_TYPE and
10534 FN and a null static chain slot. NARGS is the number of call arguments
10535 which are specified as a va_list ARGS. */
10538 build_call_valist (tree return_type
, tree fn
, int nargs
, va_list args
)
10543 t
= build_call_1 (return_type
, fn
, nargs
);
10544 for (i
= 0; i
< nargs
; i
++)
10545 CALL_EXPR_ARG (t
, i
) = va_arg (args
, tree
);
10546 process_call_operands (t
);
10550 /* Build a CALL_EXPR of class tcc_vl_exp with the indicated RETURN_TYPE and
10551 FN and a null static chain slot. NARGS is the number of call arguments
10552 which are specified as a tree array ARGS. */
10555 build_call_array_loc (location_t loc
, tree return_type
, tree fn
,
10556 int nargs
, const tree
*args
)
10561 t
= build_call_1 (return_type
, fn
, nargs
);
10562 for (i
= 0; i
< nargs
; i
++)
10563 CALL_EXPR_ARG (t
, i
) = args
[i
];
10564 process_call_operands (t
);
10565 SET_EXPR_LOCATION (t
, loc
);
10569 /* Like build_call_array, but takes a vec. */
10572 build_call_vec (tree return_type
, tree fn
, vec
<tree
, va_gc
> *args
)
10577 ret
= build_call_1 (return_type
, fn
, vec_safe_length (args
));
10578 FOR_EACH_VEC_SAFE_ELT (args
, ix
, t
)
10579 CALL_EXPR_ARG (ret
, ix
) = t
;
10580 process_call_operands (ret
);
10584 /* Conveniently construct a function call expression. FNDECL names the
10585 function to be called and N arguments are passed in the array
10589 build_call_expr_loc_array (location_t loc
, tree fndecl
, int n
, tree
*argarray
)
10591 tree fntype
= TREE_TYPE (fndecl
);
10592 tree fn
= build1 (ADDR_EXPR
, build_pointer_type (fntype
), fndecl
);
10594 return fold_builtin_call_array (loc
, TREE_TYPE (fntype
), fn
, n
, argarray
);
10597 /* Conveniently construct a function call expression. FNDECL names the
10598 function to be called and the arguments are passed in the vector
10602 build_call_expr_loc_vec (location_t loc
, tree fndecl
, vec
<tree
, va_gc
> *vec
)
10604 return build_call_expr_loc_array (loc
, fndecl
, vec_safe_length (vec
),
10605 vec_safe_address (vec
));
10609 /* Conveniently construct a function call expression. FNDECL names the
10610 function to be called, N is the number of arguments, and the "..."
10611 parameters are the argument expressions. */
10614 build_call_expr_loc (location_t loc
, tree fndecl
, int n
, ...)
10617 tree
*argarray
= XALLOCAVEC (tree
, n
);
10621 for (i
= 0; i
< n
; i
++)
10622 argarray
[i
] = va_arg (ap
, tree
);
10624 return build_call_expr_loc_array (loc
, fndecl
, n
, argarray
);
10627 /* Like build_call_expr_loc (UNKNOWN_LOCATION, ...). Duplicated because
10628 varargs macros aren't supported by all bootstrap compilers. */
10631 build_call_expr (tree fndecl
, int n
, ...)
10634 tree
*argarray
= XALLOCAVEC (tree
, n
);
10638 for (i
= 0; i
< n
; i
++)
10639 argarray
[i
] = va_arg (ap
, tree
);
10641 return build_call_expr_loc_array (UNKNOWN_LOCATION
, fndecl
, n
, argarray
);
10644 /* Build internal call expression. This is just like CALL_EXPR, except
10645 its CALL_EXPR_FN is NULL. It will get gimplified later into ordinary
10646 internal function. */
10649 build_call_expr_internal_loc (location_t loc
, enum internal_fn ifn
,
10650 tree type
, int n
, ...)
10655 tree fn
= build_call_1 (type
, NULL_TREE
, n
);
10657 for (i
= 0; i
< n
; i
++)
10658 CALL_EXPR_ARG (fn
, i
) = va_arg (ap
, tree
);
10660 SET_EXPR_LOCATION (fn
, loc
);
10661 CALL_EXPR_IFN (fn
) = ifn
;
10665 /* Create a new constant string literal and return a char* pointer to it.
10666 The STRING_CST value is the LEN characters at STR. */
10668 build_string_literal (int len
, const char *str
)
10670 tree t
, elem
, index
, type
;
10672 t
= build_string (len
, str
);
10673 elem
= build_type_variant (char_type_node
, 1, 0);
10674 index
= build_index_type (size_int (len
- 1));
10675 type
= build_array_type (elem
, index
);
10676 TREE_TYPE (t
) = type
;
10677 TREE_CONSTANT (t
) = 1;
10678 TREE_READONLY (t
) = 1;
10679 TREE_STATIC (t
) = 1;
10681 type
= build_pointer_type (elem
);
10682 t
= build1 (ADDR_EXPR
, type
,
10683 build4 (ARRAY_REF
, elem
,
10684 t
, integer_zero_node
, NULL_TREE
, NULL_TREE
));
10690 /* Return true if T (assumed to be a DECL) must be assigned a memory
10694 needs_to_live_in_memory (const_tree t
)
10696 return (TREE_ADDRESSABLE (t
)
10697 || is_global_var (t
)
10698 || (TREE_CODE (t
) == RESULT_DECL
10699 && !DECL_BY_REFERENCE (t
)
10700 && aggregate_value_p (t
, current_function_decl
)));
10703 /* Return value of a constant X and sign-extend it. */
10706 int_cst_value (const_tree x
)
10708 unsigned bits
= TYPE_PRECISION (TREE_TYPE (x
));
10709 unsigned HOST_WIDE_INT val
= TREE_INT_CST_LOW (x
);
10711 /* Make sure the sign-extended value will fit in a HOST_WIDE_INT. */
10712 gcc_assert (cst_and_fits_in_hwi (x
));
10714 if (bits
< HOST_BITS_PER_WIDE_INT
)
10716 bool negative
= ((val
>> (bits
- 1)) & 1) != 0;
10718 val
|= (~(unsigned HOST_WIDE_INT
) 0) << (bits
- 1) << 1;
10720 val
&= ~((~(unsigned HOST_WIDE_INT
) 0) << (bits
- 1) << 1);
10726 /* If TYPE is an integral or pointer type, return an integer type with
10727 the same precision which is unsigned iff UNSIGNEDP is true, or itself
10728 if TYPE is already an integer type of signedness UNSIGNEDP. */
10731 signed_or_unsigned_type_for (int unsignedp
, tree type
)
10733 if (TREE_CODE (type
) == INTEGER_TYPE
&& TYPE_UNSIGNED (type
) == unsignedp
)
10736 if (TREE_CODE (type
) == VECTOR_TYPE
)
10738 tree inner
= TREE_TYPE (type
);
10739 tree inner2
= signed_or_unsigned_type_for (unsignedp
, inner
);
10742 if (inner
== inner2
)
10744 return build_vector_type (inner2
, TYPE_VECTOR_SUBPARTS (type
));
10747 if (!INTEGRAL_TYPE_P (type
)
10748 && !POINTER_TYPE_P (type
)
10749 && TREE_CODE (type
) != OFFSET_TYPE
)
10752 return build_nonstandard_integer_type (TYPE_PRECISION (type
), unsignedp
);
10755 /* If TYPE is an integral or pointer type, return an integer type with
10756 the same precision which is unsigned, or itself if TYPE is already an
10757 unsigned integer type. */
10760 unsigned_type_for (tree type
)
10762 return signed_or_unsigned_type_for (1, type
);
10765 /* If TYPE is an integral or pointer type, return an integer type with
10766 the same precision which is signed, or itself if TYPE is already a
10767 signed integer type. */
10770 signed_type_for (tree type
)
10772 return signed_or_unsigned_type_for (0, type
);
10775 /* If TYPE is a vector type, return a signed integer vector type with the
10776 same width and number of subparts. Otherwise return boolean_type_node. */
10779 truth_type_for (tree type
)
10781 if (TREE_CODE (type
) == VECTOR_TYPE
)
10783 tree elem
= lang_hooks
.types
.type_for_size
10784 (GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (type
))), 0);
10785 return build_opaque_vector_type (elem
, TYPE_VECTOR_SUBPARTS (type
));
10788 return boolean_type_node
;
10791 /* Returns the largest value obtainable by casting something in INNER type to
10795 upper_bound_in_type (tree outer
, tree inner
)
10797 unsigned int det
= 0;
10798 unsigned oprec
= TYPE_PRECISION (outer
);
10799 unsigned iprec
= TYPE_PRECISION (inner
);
10802 /* Compute a unique number for every combination. */
10803 det
|= (oprec
> iprec
) ? 4 : 0;
10804 det
|= TYPE_UNSIGNED (outer
) ? 2 : 0;
10805 det
|= TYPE_UNSIGNED (inner
) ? 1 : 0;
10807 /* Determine the exponent to use. */
10812 /* oprec <= iprec, outer: signed, inner: don't care. */
10817 /* oprec <= iprec, outer: unsigned, inner: don't care. */
10821 /* oprec > iprec, outer: signed, inner: signed. */
10825 /* oprec > iprec, outer: signed, inner: unsigned. */
10829 /* oprec > iprec, outer: unsigned, inner: signed. */
10833 /* oprec > iprec, outer: unsigned, inner: unsigned. */
10837 gcc_unreachable ();
10840 return wide_int_to_tree (outer
,
10841 wi::mask (prec
, false, TYPE_PRECISION (outer
)));
10844 /* Returns the smallest value obtainable by casting something in INNER type to
10848 lower_bound_in_type (tree outer
, tree inner
)
10850 unsigned oprec
= TYPE_PRECISION (outer
);
10851 unsigned iprec
= TYPE_PRECISION (inner
);
10853 /* If OUTER type is unsigned, we can definitely cast 0 to OUTER type
10855 if (TYPE_UNSIGNED (outer
)
10856 /* If we are widening something of an unsigned type, OUTER type
10857 contains all values of INNER type. In particular, both INNER
10858 and OUTER types have zero in common. */
10859 || (oprec
> iprec
&& TYPE_UNSIGNED (inner
)))
10860 return build_int_cst (outer
, 0);
10863 /* If we are widening a signed type to another signed type, we
10864 want to obtain -2^^(iprec-1). If we are keeping the
10865 precision or narrowing to a signed type, we want to obtain
10867 unsigned prec
= oprec
> iprec
? iprec
: oprec
;
10868 return wide_int_to_tree (outer
,
10869 wi::mask (prec
- 1, true,
10870 TYPE_PRECISION (outer
)));
10874 /* Return nonzero if two operands that are suitable for PHI nodes are
10875 necessarily equal. Specifically, both ARG0 and ARG1 must be either
10876 SSA_NAME or invariant. Note that this is strictly an optimization.
10877 That is, callers of this function can directly call operand_equal_p
10878 and get the same result, only slower. */
10881 operand_equal_for_phi_arg_p (const_tree arg0
, const_tree arg1
)
10885 if (TREE_CODE (arg0
) == SSA_NAME
|| TREE_CODE (arg1
) == SSA_NAME
)
10887 return operand_equal_p (arg0
, arg1
, 0);
10890 /* Returns number of zeros at the end of binary representation of X. */
10893 num_ending_zeros (const_tree x
)
10895 return build_int_cst (TREE_TYPE (x
), wi::ctz (x
));
10899 #define WALK_SUBTREE(NODE) \
10902 result = walk_tree_1 (&(NODE), func, data, pset, lh); \
10908 /* This is a subroutine of walk_tree that walks field of TYPE that are to
10909 be walked whenever a type is seen in the tree. Rest of operands and return
10910 value are as for walk_tree. */
10913 walk_type_fields (tree type
, walk_tree_fn func
, void *data
,
10914 hash_set
<tree
> *pset
, walk_tree_lh lh
)
10916 tree result
= NULL_TREE
;
10918 switch (TREE_CODE (type
))
10921 case REFERENCE_TYPE
:
10923 /* We have to worry about mutually recursive pointers. These can't
10924 be written in C. They can in Ada. It's pathological, but
10925 there's an ACATS test (c38102a) that checks it. Deal with this
10926 by checking if we're pointing to another pointer, that one
10927 points to another pointer, that one does too, and we have no htab.
10928 If so, get a hash table. We check three levels deep to avoid
10929 the cost of the hash table if we don't need one. */
10930 if (POINTER_TYPE_P (TREE_TYPE (type
))
10931 && POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (type
)))
10932 && POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (TREE_TYPE (type
))))
10935 result
= walk_tree_without_duplicates (&TREE_TYPE (type
),
10943 /* ... fall through ... */
10946 WALK_SUBTREE (TREE_TYPE (type
));
10950 WALK_SUBTREE (TYPE_METHOD_BASETYPE (type
));
10952 /* Fall through. */
10954 case FUNCTION_TYPE
:
10955 WALK_SUBTREE (TREE_TYPE (type
));
10959 /* We never want to walk into default arguments. */
10960 for (arg
= TYPE_ARG_TYPES (type
); arg
; arg
= TREE_CHAIN (arg
))
10961 WALK_SUBTREE (TREE_VALUE (arg
));
10966 /* Don't follow this nodes's type if a pointer for fear that
10967 we'll have infinite recursion. If we have a PSET, then we
10970 || (!POINTER_TYPE_P (TREE_TYPE (type
))
10971 && TREE_CODE (TREE_TYPE (type
)) != OFFSET_TYPE
))
10972 WALK_SUBTREE (TREE_TYPE (type
));
10973 WALK_SUBTREE (TYPE_DOMAIN (type
));
10977 WALK_SUBTREE (TREE_TYPE (type
));
10978 WALK_SUBTREE (TYPE_OFFSET_BASETYPE (type
));
10988 /* Apply FUNC to all the sub-trees of TP in a pre-order traversal. FUNC is
10989 called with the DATA and the address of each sub-tree. If FUNC returns a
10990 non-NULL value, the traversal is stopped, and the value returned by FUNC
10991 is returned. If PSET is non-NULL it is used to record the nodes visited,
10992 and to avoid visiting a node more than once. */
10995 walk_tree_1 (tree
*tp
, walk_tree_fn func
, void *data
,
10996 hash_set
<tree
> *pset
, walk_tree_lh lh
)
10998 enum tree_code code
;
11002 #define WALK_SUBTREE_TAIL(NODE) \
11006 goto tail_recurse; \
11011 /* Skip empty subtrees. */
11015 /* Don't walk the same tree twice, if the user has requested
11016 that we avoid doing so. */
11017 if (pset
&& pset
->add (*tp
))
11020 /* Call the function. */
11022 result
= (*func
) (tp
, &walk_subtrees
, data
);
11024 /* If we found something, return it. */
11028 code
= TREE_CODE (*tp
);
11030 /* Even if we didn't, FUNC may have decided that there was nothing
11031 interesting below this point in the tree. */
11032 if (!walk_subtrees
)
11034 /* But we still need to check our siblings. */
11035 if (code
== TREE_LIST
)
11036 WALK_SUBTREE_TAIL (TREE_CHAIN (*tp
));
11037 else if (code
== OMP_CLAUSE
)
11038 WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp
));
11045 result
= (*lh
) (tp
, &walk_subtrees
, func
, data
, pset
);
11046 if (result
|| !walk_subtrees
)
11053 case IDENTIFIER_NODE
:
11060 case PLACEHOLDER_EXPR
:
11064 /* None of these have subtrees other than those already walked
11069 WALK_SUBTREE (TREE_VALUE (*tp
));
11070 WALK_SUBTREE_TAIL (TREE_CHAIN (*tp
));
11075 int len
= TREE_VEC_LENGTH (*tp
);
11080 /* Walk all elements but the first. */
11082 WALK_SUBTREE (TREE_VEC_ELT (*tp
, len
));
11084 /* Now walk the first one as a tail call. */
11085 WALK_SUBTREE_TAIL (TREE_VEC_ELT (*tp
, 0));
11089 WALK_SUBTREE (TREE_REALPART (*tp
));
11090 WALK_SUBTREE_TAIL (TREE_IMAGPART (*tp
));
11094 unsigned HOST_WIDE_INT idx
;
11095 constructor_elt
*ce
;
11097 for (idx
= 0; vec_safe_iterate (CONSTRUCTOR_ELTS (*tp
), idx
, &ce
);
11099 WALK_SUBTREE (ce
->value
);
11104 WALK_SUBTREE_TAIL (TREE_OPERAND (*tp
, 0));
11109 for (decl
= BIND_EXPR_VARS (*tp
); decl
; decl
= DECL_CHAIN (decl
))
11111 /* Walk the DECL_INITIAL and DECL_SIZE. We don't want to walk
11112 into declarations that are just mentioned, rather than
11113 declared; they don't really belong to this part of the tree.
11114 And, we can see cycles: the initializer for a declaration
11115 can refer to the declaration itself. */
11116 WALK_SUBTREE (DECL_INITIAL (decl
));
11117 WALK_SUBTREE (DECL_SIZE (decl
));
11118 WALK_SUBTREE (DECL_SIZE_UNIT (decl
));
11120 WALK_SUBTREE_TAIL (BIND_EXPR_BODY (*tp
));
11123 case STATEMENT_LIST
:
11125 tree_stmt_iterator i
;
11126 for (i
= tsi_start (*tp
); !tsi_end_p (i
); tsi_next (&i
))
11127 WALK_SUBTREE (*tsi_stmt_ptr (i
));
11132 switch (OMP_CLAUSE_CODE (*tp
))
11134 case OMP_CLAUSE_PRIVATE
:
11135 case OMP_CLAUSE_SHARED
:
11136 case OMP_CLAUSE_FIRSTPRIVATE
:
11137 case OMP_CLAUSE_COPYIN
:
11138 case OMP_CLAUSE_COPYPRIVATE
:
11139 case OMP_CLAUSE_FINAL
:
11140 case OMP_CLAUSE_IF
:
11141 case OMP_CLAUSE_NUM_THREADS
:
11142 case OMP_CLAUSE_SCHEDULE
:
11143 case OMP_CLAUSE_UNIFORM
:
11144 case OMP_CLAUSE_DEPEND
:
11145 case OMP_CLAUSE_NUM_TEAMS
:
11146 case OMP_CLAUSE_THREAD_LIMIT
:
11147 case OMP_CLAUSE_DEVICE
:
11148 case OMP_CLAUSE_DIST_SCHEDULE
:
11149 case OMP_CLAUSE_SAFELEN
:
11150 case OMP_CLAUSE_SIMDLEN
:
11151 case OMP_CLAUSE__LOOPTEMP_
:
11152 case OMP_CLAUSE__SIMDUID_
:
11153 case OMP_CLAUSE__CILK_FOR_COUNT_
:
11154 WALK_SUBTREE (OMP_CLAUSE_OPERAND (*tp
, 0));
11157 case OMP_CLAUSE_NOWAIT
:
11158 case OMP_CLAUSE_ORDERED
:
11159 case OMP_CLAUSE_DEFAULT
:
11160 case OMP_CLAUSE_UNTIED
:
11161 case OMP_CLAUSE_MERGEABLE
:
11162 case OMP_CLAUSE_PROC_BIND
:
11163 case OMP_CLAUSE_INBRANCH
:
11164 case OMP_CLAUSE_NOTINBRANCH
:
11165 case OMP_CLAUSE_FOR
:
11166 case OMP_CLAUSE_PARALLEL
:
11167 case OMP_CLAUSE_SECTIONS
:
11168 case OMP_CLAUSE_TASKGROUP
:
11169 WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp
));
11171 case OMP_CLAUSE_LASTPRIVATE
:
11172 WALK_SUBTREE (OMP_CLAUSE_DECL (*tp
));
11173 WALK_SUBTREE (OMP_CLAUSE_LASTPRIVATE_STMT (*tp
));
11174 WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp
));
11176 case OMP_CLAUSE_COLLAPSE
:
11179 for (i
= 0; i
< 3; i
++)
11180 WALK_SUBTREE (OMP_CLAUSE_OPERAND (*tp
, i
));
11181 WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp
));
11184 case OMP_CLAUSE_LINEAR
:
11185 WALK_SUBTREE (OMP_CLAUSE_DECL (*tp
));
11186 WALK_SUBTREE (OMP_CLAUSE_LINEAR_STEP (*tp
));
11187 WALK_SUBTREE (OMP_CLAUSE_LINEAR_STMT (*tp
));
11188 WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp
));
11190 case OMP_CLAUSE_ALIGNED
:
11191 case OMP_CLAUSE_FROM
:
11192 case OMP_CLAUSE_TO
:
11193 case OMP_CLAUSE_MAP
:
11194 WALK_SUBTREE (OMP_CLAUSE_DECL (*tp
));
11195 WALK_SUBTREE (OMP_CLAUSE_OPERAND (*tp
, 1));
11196 WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp
));
11198 case OMP_CLAUSE_REDUCTION
:
11201 for (i
= 0; i
< 4; i
++)
11202 WALK_SUBTREE (OMP_CLAUSE_OPERAND (*tp
, i
));
11203 WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp
));
11207 gcc_unreachable ();
11215 /* TARGET_EXPRs are peculiar: operands 1 and 3 can be the same.
11216 But, we only want to walk once. */
11217 len
= (TREE_OPERAND (*tp
, 3) == TREE_OPERAND (*tp
, 1)) ? 2 : 3;
11218 for (i
= 0; i
< len
; ++i
)
11219 WALK_SUBTREE (TREE_OPERAND (*tp
, i
));
11220 WALK_SUBTREE_TAIL (TREE_OPERAND (*tp
, len
));
11224 /* If this is a TYPE_DECL, walk into the fields of the type that it's
11225 defining. We only want to walk into these fields of a type in this
11226 case and not in the general case of a mere reference to the type.
11228 The criterion is as follows: if the field can be an expression, it
11229 must be walked only here. This should be in keeping with the fields
11230 that are directly gimplified in gimplify_type_sizes in order for the
11231 mark/copy-if-shared/unmark machinery of the gimplifier to work with
11232 variable-sized types.
11234 Note that DECLs get walked as part of processing the BIND_EXPR. */
11235 if (TREE_CODE (DECL_EXPR_DECL (*tp
)) == TYPE_DECL
)
11237 tree
*type_p
= &TREE_TYPE (DECL_EXPR_DECL (*tp
));
11238 if (TREE_CODE (*type_p
) == ERROR_MARK
)
11241 /* Call the function for the type. See if it returns anything or
11242 doesn't want us to continue. If we are to continue, walk both
11243 the normal fields and those for the declaration case. */
11244 result
= (*func
) (type_p
, &walk_subtrees
, data
);
11245 if (result
|| !walk_subtrees
)
11248 /* But do not walk a pointed-to type since it may itself need to
11249 be walked in the declaration case if it isn't anonymous. */
11250 if (!POINTER_TYPE_P (*type_p
))
11252 result
= walk_type_fields (*type_p
, func
, data
, pset
, lh
);
11257 /* If this is a record type, also walk the fields. */
11258 if (RECORD_OR_UNION_TYPE_P (*type_p
))
11262 for (field
= TYPE_FIELDS (*type_p
); field
;
11263 field
= DECL_CHAIN (field
))
11265 /* We'd like to look at the type of the field, but we can
11266 easily get infinite recursion. So assume it's pointed
11267 to elsewhere in the tree. Also, ignore things that
11269 if (TREE_CODE (field
) != FIELD_DECL
)
11272 WALK_SUBTREE (DECL_FIELD_OFFSET (field
));
11273 WALK_SUBTREE (DECL_SIZE (field
));
11274 WALK_SUBTREE (DECL_SIZE_UNIT (field
));
11275 if (TREE_CODE (*type_p
) == QUAL_UNION_TYPE
)
11276 WALK_SUBTREE (DECL_QUALIFIER (field
));
11280 /* Same for scalar types. */
11281 else if (TREE_CODE (*type_p
) == BOOLEAN_TYPE
11282 || TREE_CODE (*type_p
) == ENUMERAL_TYPE
11283 || TREE_CODE (*type_p
) == INTEGER_TYPE
11284 || TREE_CODE (*type_p
) == FIXED_POINT_TYPE
11285 || TREE_CODE (*type_p
) == REAL_TYPE
)
11287 WALK_SUBTREE (TYPE_MIN_VALUE (*type_p
));
11288 WALK_SUBTREE (TYPE_MAX_VALUE (*type_p
));
11291 WALK_SUBTREE (TYPE_SIZE (*type_p
));
11292 WALK_SUBTREE_TAIL (TYPE_SIZE_UNIT (*type_p
));
11297 if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (code
)))
11301 /* Walk over all the sub-trees of this operand. */
11302 len
= TREE_OPERAND_LENGTH (*tp
);
11304 /* Go through the subtrees. We need to do this in forward order so
11305 that the scope of a FOR_EXPR is handled properly. */
11308 for (i
= 0; i
< len
- 1; ++i
)
11309 WALK_SUBTREE (TREE_OPERAND (*tp
, i
));
11310 WALK_SUBTREE_TAIL (TREE_OPERAND (*tp
, len
- 1));
11313 /* If this is a type, walk the needed fields in the type. */
11314 else if (TYPE_P (*tp
))
11315 return walk_type_fields (*tp
, func
, data
, pset
, lh
);
11319 /* We didn't find what we were looking for. */
11322 #undef WALK_SUBTREE_TAIL
11324 #undef WALK_SUBTREE
11326 /* Like walk_tree, but does not walk duplicate nodes more than once. */
11329 walk_tree_without_duplicates_1 (tree
*tp
, walk_tree_fn func
, void *data
,
11334 hash_set
<tree
> pset
;
11335 result
= walk_tree_1 (tp
, func
, data
, &pset
, lh
);
11341 tree_block (tree t
)
11343 const enum tree_code_class c
= TREE_CODE_CLASS (TREE_CODE (t
));
11345 if (IS_EXPR_CODE_CLASS (c
))
11346 return LOCATION_BLOCK (t
->exp
.locus
);
11347 gcc_unreachable ();
11352 tree_set_block (tree t
, tree b
)
11354 const enum tree_code_class c
= TREE_CODE_CLASS (TREE_CODE (t
));
11356 if (IS_EXPR_CODE_CLASS (c
))
11359 t
->exp
.locus
= COMBINE_LOCATION_DATA (line_table
, t
->exp
.locus
, b
);
11361 t
->exp
.locus
= LOCATION_LOCUS (t
->exp
.locus
);
11364 gcc_unreachable ();
11367 /* Create a nameless artificial label and put it in the current
11368 function context. The label has a location of LOC. Returns the
11369 newly created label. */
11372 create_artificial_label (location_t loc
)
11374 tree lab
= build_decl (loc
,
11375 LABEL_DECL
, NULL_TREE
, void_type_node
);
11377 DECL_ARTIFICIAL (lab
) = 1;
11378 DECL_IGNORED_P (lab
) = 1;
11379 DECL_CONTEXT (lab
) = current_function_decl
;
11383 /* Given a tree, try to return a useful variable name that we can use
11384 to prefix a temporary that is being assigned the value of the tree.
11385 I.E. given <temp> = &A, return A. */
11390 tree stripped_decl
;
11393 STRIP_NOPS (stripped_decl
);
11394 if (DECL_P (stripped_decl
) && DECL_NAME (stripped_decl
))
11395 return IDENTIFIER_POINTER (DECL_NAME (stripped_decl
));
11396 else if (TREE_CODE (stripped_decl
) == SSA_NAME
)
11398 tree name
= SSA_NAME_IDENTIFIER (stripped_decl
);
11401 return IDENTIFIER_POINTER (name
);
11405 switch (TREE_CODE (stripped_decl
))
11408 return get_name (TREE_OPERAND (stripped_decl
, 0));
11415 /* Return true if TYPE has a variable argument list. */
11418 stdarg_p (const_tree fntype
)
11420 function_args_iterator args_iter
;
11421 tree n
= NULL_TREE
, t
;
11426 FOREACH_FUNCTION_ARGS (fntype
, t
, args_iter
)
11431 return n
!= NULL_TREE
&& n
!= void_type_node
;
11434 /* Return true if TYPE has a prototype. */
11437 prototype_p (tree fntype
)
11441 gcc_assert (fntype
!= NULL_TREE
);
11443 t
= TYPE_ARG_TYPES (fntype
);
11444 return (t
!= NULL_TREE
);
11447 /* If BLOCK is inlined from an __attribute__((__artificial__))
11448 routine, return pointer to location from where it has been
11451 block_nonartificial_location (tree block
)
11453 location_t
*ret
= NULL
;
11455 while (block
&& TREE_CODE (block
) == BLOCK
11456 && BLOCK_ABSTRACT_ORIGIN (block
))
11458 tree ao
= BLOCK_ABSTRACT_ORIGIN (block
);
11460 while (TREE_CODE (ao
) == BLOCK
11461 && BLOCK_ABSTRACT_ORIGIN (ao
)
11462 && BLOCK_ABSTRACT_ORIGIN (ao
) != ao
)
11463 ao
= BLOCK_ABSTRACT_ORIGIN (ao
);
11465 if (TREE_CODE (ao
) == FUNCTION_DECL
)
11467 /* If AO is an artificial inline, point RET to the
11468 call site locus at which it has been inlined and continue
11469 the loop, in case AO's caller is also an artificial
11471 if (DECL_DECLARED_INLINE_P (ao
)
11472 && lookup_attribute ("artificial", DECL_ATTRIBUTES (ao
)))
11473 ret
= &BLOCK_SOURCE_LOCATION (block
);
11477 else if (TREE_CODE (ao
) != BLOCK
)
11480 block
= BLOCK_SUPERCONTEXT (block
);
11486 /* If EXP is inlined from an __attribute__((__artificial__))
11487 function, return the location of the original call expression. */
11490 tree_nonartificial_location (tree exp
)
11492 location_t
*loc
= block_nonartificial_location (TREE_BLOCK (exp
));
11497 return EXPR_LOCATION (exp
);
11501 /* These are the hash table functions for the hash table of OPTIMIZATION_NODEq
11504 /* Return the hash code code X, an OPTIMIZATION_NODE or TARGET_OPTION code. */
11507 cl_option_hasher::hash (tree x
)
11509 const_tree
const t
= x
;
11513 hashval_t hash
= 0;
11515 if (TREE_CODE (t
) == OPTIMIZATION_NODE
)
11517 p
= (const char *)TREE_OPTIMIZATION (t
);
11518 len
= sizeof (struct cl_optimization
);
11521 else if (TREE_CODE (t
) == TARGET_OPTION_NODE
)
11522 return cl_target_option_hash (TREE_TARGET_OPTION (t
));
11525 gcc_unreachable ();
11527 /* assume most opt flags are just 0/1, some are 2-3, and a few might be
11529 for (i
= 0; i
< len
; i
++)
11531 hash
= (hash
<< 4) ^ ((i
<< 2) | p
[i
]);
11536 /* Return nonzero if the value represented by *X (an OPTIMIZATION or
11537 TARGET_OPTION tree node) is the same as that given by *Y, which is the
11541 cl_option_hasher::equal (tree x
, tree y
)
11543 const_tree
const xt
= x
;
11544 const_tree
const yt
= y
;
11549 if (TREE_CODE (xt
) != TREE_CODE (yt
))
11552 if (TREE_CODE (xt
) == OPTIMIZATION_NODE
)
11554 xp
= (const char *)TREE_OPTIMIZATION (xt
);
11555 yp
= (const char *)TREE_OPTIMIZATION (yt
);
11556 len
= sizeof (struct cl_optimization
);
11559 else if (TREE_CODE (xt
) == TARGET_OPTION_NODE
)
11561 return cl_target_option_eq (TREE_TARGET_OPTION (xt
),
11562 TREE_TARGET_OPTION (yt
));
11566 gcc_unreachable ();
11568 return (memcmp (xp
, yp
, len
) == 0);
11571 /* Build an OPTIMIZATION_NODE based on the options in OPTS. */
11574 build_optimization_node (struct gcc_options
*opts
)
11578 /* Use the cache of optimization nodes. */
11580 cl_optimization_save (TREE_OPTIMIZATION (cl_optimization_node
),
11583 tree
*slot
= cl_option_hash_table
->find_slot (cl_optimization_node
, INSERT
);
11587 /* Insert this one into the hash table. */
11588 t
= cl_optimization_node
;
11591 /* Make a new node for next time round. */
11592 cl_optimization_node
= make_node (OPTIMIZATION_NODE
);
11598 /* Build a TARGET_OPTION_NODE based on the options in OPTS. */
11601 build_target_option_node (struct gcc_options
*opts
)
11605 /* Use the cache of optimization nodes. */
11607 cl_target_option_save (TREE_TARGET_OPTION (cl_target_option_node
),
11610 tree
*slot
= cl_option_hash_table
->find_slot (cl_target_option_node
, INSERT
);
11614 /* Insert this one into the hash table. */
11615 t
= cl_target_option_node
;
11618 /* Make a new node for next time round. */
11619 cl_target_option_node
= make_node (TARGET_OPTION_NODE
);
11625 /* Clear TREE_TARGET_GLOBALS of all TARGET_OPTION_NODE trees,
11626 so that they aren't saved during PCH writing. */
11629 prepare_target_option_nodes_for_pch (void)
11631 hash_table
<cl_option_hasher
>::iterator iter
= cl_option_hash_table
->begin ();
11632 for (; iter
!= cl_option_hash_table
->end (); ++iter
)
11633 if (TREE_CODE (*iter
) == TARGET_OPTION_NODE
)
11634 TREE_TARGET_GLOBALS (*iter
) = NULL
;
11637 /* Determine the "ultimate origin" of a block. The block may be an inlined
11638 instance of an inlined instance of a block which is local to an inline
11639 function, so we have to trace all of the way back through the origin chain
11640 to find out what sort of node actually served as the original seed for the
11644 block_ultimate_origin (const_tree block
)
11646 tree immediate_origin
= BLOCK_ABSTRACT_ORIGIN (block
);
11648 /* BLOCK_ABSTRACT_ORIGIN can point to itself; ignore that if
11649 we're trying to output the abstract instance of this function. */
11650 if (BLOCK_ABSTRACT (block
) && immediate_origin
== block
)
11653 if (immediate_origin
== NULL_TREE
)
11658 tree lookahead
= immediate_origin
;
11662 ret_val
= lookahead
;
11663 lookahead
= (TREE_CODE (ret_val
) == BLOCK
11664 ? BLOCK_ABSTRACT_ORIGIN (ret_val
) : NULL
);
11666 while (lookahead
!= NULL
&& lookahead
!= ret_val
);
11668 /* The block's abstract origin chain may not be the *ultimate* origin of
11669 the block. It could lead to a DECL that has an abstract origin set.
11670 If so, we want that DECL's abstract origin (which is what DECL_ORIGIN
11671 will give us if it has one). Note that DECL's abstract origins are
11672 supposed to be the most distant ancestor (or so decl_ultimate_origin
11673 claims), so we don't need to loop following the DECL origins. */
11674 if (DECL_P (ret_val
))
11675 return DECL_ORIGIN (ret_val
);
11681 /* Return true iff conversion from INNER_TYPE to OUTER_TYPE generates
11685 tree_nop_conversion_p (const_tree outer_type
, const_tree inner_type
)
11687 /* Use precision rather then machine mode when we can, which gives
11688 the correct answer even for submode (bit-field) types. */
11689 if ((INTEGRAL_TYPE_P (outer_type
)
11690 || POINTER_TYPE_P (outer_type
)
11691 || TREE_CODE (outer_type
) == OFFSET_TYPE
)
11692 && (INTEGRAL_TYPE_P (inner_type
)
11693 || POINTER_TYPE_P (inner_type
)
11694 || TREE_CODE (inner_type
) == OFFSET_TYPE
))
11695 return TYPE_PRECISION (outer_type
) == TYPE_PRECISION (inner_type
);
11697 /* Otherwise fall back on comparing machine modes (e.g. for
11698 aggregate types, floats). */
11699 return TYPE_MODE (outer_type
) == TYPE_MODE (inner_type
);
11702 /* Return true iff conversion in EXP generates no instruction. Mark
11703 it inline so that we fully inline into the stripping functions even
11704 though we have two uses of this function. */
11707 tree_nop_conversion (const_tree exp
)
11709 tree outer_type
, inner_type
;
11711 if (!CONVERT_EXPR_P (exp
)
11712 && TREE_CODE (exp
) != NON_LVALUE_EXPR
)
11714 if (TREE_OPERAND (exp
, 0) == error_mark_node
)
11717 outer_type
= TREE_TYPE (exp
);
11718 inner_type
= TREE_TYPE (TREE_OPERAND (exp
, 0));
11723 return tree_nop_conversion_p (outer_type
, inner_type
);
11726 /* Return true iff conversion in EXP generates no instruction. Don't
11727 consider conversions changing the signedness. */
11730 tree_sign_nop_conversion (const_tree exp
)
11732 tree outer_type
, inner_type
;
11734 if (!tree_nop_conversion (exp
))
11737 outer_type
= TREE_TYPE (exp
);
11738 inner_type
= TREE_TYPE (TREE_OPERAND (exp
, 0));
11740 return (TYPE_UNSIGNED (outer_type
) == TYPE_UNSIGNED (inner_type
)
11741 && POINTER_TYPE_P (outer_type
) == POINTER_TYPE_P (inner_type
));
11744 /* Strip conversions from EXP according to tree_nop_conversion and
11745 return the resulting expression. */
11748 tree_strip_nop_conversions (tree exp
)
11750 while (tree_nop_conversion (exp
))
11751 exp
= TREE_OPERAND (exp
, 0);
11755 /* Strip conversions from EXP according to tree_sign_nop_conversion
11756 and return the resulting expression. */
11759 tree_strip_sign_nop_conversions (tree exp
)
11761 while (tree_sign_nop_conversion (exp
))
11762 exp
= TREE_OPERAND (exp
, 0);
11766 /* Avoid any floating point extensions from EXP. */
11768 strip_float_extensions (tree exp
)
11770 tree sub
, expt
, subt
;
11772 /* For floating point constant look up the narrowest type that can hold
11773 it properly and handle it like (type)(narrowest_type)constant.
11774 This way we can optimize for instance a=a*2.0 where "a" is float
11775 but 2.0 is double constant. */
11776 if (TREE_CODE (exp
) == REAL_CST
&& !DECIMAL_FLOAT_TYPE_P (TREE_TYPE (exp
)))
11778 REAL_VALUE_TYPE orig
;
11781 orig
= TREE_REAL_CST (exp
);
11782 if (TYPE_PRECISION (TREE_TYPE (exp
)) > TYPE_PRECISION (float_type_node
)
11783 && exact_real_truncate (TYPE_MODE (float_type_node
), &orig
))
11784 type
= float_type_node
;
11785 else if (TYPE_PRECISION (TREE_TYPE (exp
))
11786 > TYPE_PRECISION (double_type_node
)
11787 && exact_real_truncate (TYPE_MODE (double_type_node
), &orig
))
11788 type
= double_type_node
;
11790 return build_real (type
, real_value_truncate (TYPE_MODE (type
), orig
));
11793 if (!CONVERT_EXPR_P (exp
))
11796 sub
= TREE_OPERAND (exp
, 0);
11797 subt
= TREE_TYPE (sub
);
11798 expt
= TREE_TYPE (exp
);
11800 if (!FLOAT_TYPE_P (subt
))
11803 if (DECIMAL_FLOAT_TYPE_P (expt
) != DECIMAL_FLOAT_TYPE_P (subt
))
11806 if (TYPE_PRECISION (subt
) > TYPE_PRECISION (expt
))
11809 return strip_float_extensions (sub
);
11812 /* Strip out all handled components that produce invariant
11816 strip_invariant_refs (const_tree op
)
11818 while (handled_component_p (op
))
11820 switch (TREE_CODE (op
))
11823 case ARRAY_RANGE_REF
:
11824 if (!is_gimple_constant (TREE_OPERAND (op
, 1))
11825 || TREE_OPERAND (op
, 2) != NULL_TREE
11826 || TREE_OPERAND (op
, 3) != NULL_TREE
)
11830 case COMPONENT_REF
:
11831 if (TREE_OPERAND (op
, 2) != NULL_TREE
)
11837 op
= TREE_OPERAND (op
, 0);
11843 static GTY(()) tree gcc_eh_personality_decl
;
11845 /* Return the GCC personality function decl. */
11848 lhd_gcc_personality (void)
11850 if (!gcc_eh_personality_decl
)
11851 gcc_eh_personality_decl
= build_personality_function ("gcc");
11852 return gcc_eh_personality_decl
;
11855 /* TARGET is a call target of GIMPLE call statement
11856 (obtained by gimple_call_fn). Return true if it is
11857 OBJ_TYPE_REF representing an virtual call of C++ method.
11858 (As opposed to OBJ_TYPE_REF representing objc calls
11859 through a cast where middle-end devirtualization machinery
11863 virtual_method_call_p (tree target
)
11865 if (TREE_CODE (target
) != OBJ_TYPE_REF
)
11867 target
= TREE_TYPE (target
);
11868 gcc_checking_assert (TREE_CODE (target
) == POINTER_TYPE
);
11869 target
= TREE_TYPE (target
);
11870 if (TREE_CODE (target
) == FUNCTION_TYPE
)
11872 gcc_checking_assert (TREE_CODE (target
) == METHOD_TYPE
);
11876 /* REF is OBJ_TYPE_REF, return the class the ref corresponds to. */
11879 obj_type_ref_class (tree ref
)
11881 gcc_checking_assert (TREE_CODE (ref
) == OBJ_TYPE_REF
);
11882 ref
= TREE_TYPE (ref
);
11883 gcc_checking_assert (TREE_CODE (ref
) == POINTER_TYPE
);
11884 ref
= TREE_TYPE (ref
);
11885 /* We look for type THIS points to. ObjC also builds
11886 OBJ_TYPE_REF with non-method calls, Their first parameter
11887 ID however also corresponds to class type. */
11888 gcc_checking_assert (TREE_CODE (ref
) == METHOD_TYPE
11889 || TREE_CODE (ref
) == FUNCTION_TYPE
);
11890 ref
= TREE_VALUE (TYPE_ARG_TYPES (ref
));
11891 gcc_checking_assert (TREE_CODE (ref
) == POINTER_TYPE
);
11892 return TREE_TYPE (ref
);
11895 /* Return true if T is in anonymous namespace. */
11898 type_in_anonymous_namespace_p (const_tree t
)
11900 /* TREE_PUBLIC of TYPE_STUB_DECL may not be properly set for
11901 bulitin types; those have CONTEXT NULL. */
11902 if (!TYPE_CONTEXT (t
))
11904 return (TYPE_STUB_DECL (t
) && !TREE_PUBLIC (TYPE_STUB_DECL (t
)));
11907 /* Try to find a base info of BINFO that would have its field decl at offset
11908 OFFSET within the BINFO type and which is of EXPECTED_TYPE. If it can be
11909 found, return, otherwise return NULL_TREE. */
11912 get_binfo_at_offset (tree binfo
, HOST_WIDE_INT offset
, tree expected_type
)
11914 tree type
= BINFO_TYPE (binfo
);
11918 HOST_WIDE_INT pos
, size
;
11922 if (types_same_for_odr (type
, expected_type
))
11927 for (fld
= TYPE_FIELDS (type
); fld
; fld
= DECL_CHAIN (fld
))
11929 if (TREE_CODE (fld
) != FIELD_DECL
|| !DECL_ARTIFICIAL (fld
))
11932 pos
= int_bit_position (fld
);
11933 size
= tree_to_uhwi (DECL_SIZE (fld
));
11934 if (pos
<= offset
&& (pos
+ size
) > offset
)
11937 if (!fld
|| TREE_CODE (TREE_TYPE (fld
)) != RECORD_TYPE
)
11940 /* Offset 0 indicates the primary base, whose vtable contents are
11941 represented in the binfo for the derived class. */
11942 else if (offset
!= 0)
11944 tree base_binfo
, binfo2
= binfo
;
11946 /* Find BINFO corresponding to FLD. This is bit harder
11947 by a fact that in virtual inheritance we may need to walk down
11948 the non-virtual inheritance chain. */
11951 tree containing_binfo
= NULL
, found_binfo
= NULL
;
11952 for (i
= 0; BINFO_BASE_ITERATE (binfo2
, i
, base_binfo
); i
++)
11953 if (types_same_for_odr (TREE_TYPE (base_binfo
), TREE_TYPE (fld
)))
11955 found_binfo
= base_binfo
;
11959 if ((tree_to_shwi (BINFO_OFFSET (base_binfo
))
11960 - tree_to_shwi (BINFO_OFFSET (binfo
)))
11961 * BITS_PER_UNIT
< pos
11962 /* Rule out types with no virtual methods or we can get confused
11963 here by zero sized bases. */
11964 && TYPE_BINFO (BINFO_TYPE (base_binfo
))
11965 && BINFO_VTABLE (TYPE_BINFO (BINFO_TYPE (base_binfo
)))
11966 && (!containing_binfo
11967 || (tree_to_shwi (BINFO_OFFSET (containing_binfo
))
11968 < tree_to_shwi (BINFO_OFFSET (base_binfo
)))))
11969 containing_binfo
= base_binfo
;
11972 binfo
= found_binfo
;
11975 if (!containing_binfo
)
11977 binfo2
= containing_binfo
;
11981 type
= TREE_TYPE (fld
);
11986 /* Returns true if X is a typedef decl. */
11989 is_typedef_decl (tree x
)
11991 return (x
&& TREE_CODE (x
) == TYPE_DECL
11992 && DECL_ORIGINAL_TYPE (x
) != NULL_TREE
);
11995 /* Returns true iff TYPE is a type variant created for a typedef. */
11998 typedef_variant_p (tree type
)
12000 return is_typedef_decl (TYPE_NAME (type
));
12003 /* Warn about a use of an identifier which was marked deprecated. */
12005 warn_deprecated_use (tree node
, tree attr
)
12009 if (node
== 0 || !warn_deprecated_decl
)
12015 attr
= DECL_ATTRIBUTES (node
);
12016 else if (TYPE_P (node
))
12018 tree decl
= TYPE_STUB_DECL (node
);
12020 attr
= lookup_attribute ("deprecated",
12021 TYPE_ATTRIBUTES (TREE_TYPE (decl
)));
12026 attr
= lookup_attribute ("deprecated", attr
);
12029 msg
= TREE_STRING_POINTER (TREE_VALUE (TREE_VALUE (attr
)));
12037 w
= warning (OPT_Wdeprecated_declarations
,
12038 "%qD is deprecated: %s", node
, msg
);
12040 w
= warning (OPT_Wdeprecated_declarations
,
12041 "%qD is deprecated", node
);
12043 inform (DECL_SOURCE_LOCATION (node
), "declared here");
12045 else if (TYPE_P (node
))
12047 tree what
= NULL_TREE
;
12048 tree decl
= TYPE_STUB_DECL (node
);
12050 if (TYPE_NAME (node
))
12052 if (TREE_CODE (TYPE_NAME (node
)) == IDENTIFIER_NODE
)
12053 what
= TYPE_NAME (node
);
12054 else if (TREE_CODE (TYPE_NAME (node
)) == TYPE_DECL
12055 && DECL_NAME (TYPE_NAME (node
)))
12056 what
= DECL_NAME (TYPE_NAME (node
));
12064 w
= warning (OPT_Wdeprecated_declarations
,
12065 "%qE is deprecated: %s", what
, msg
);
12067 w
= warning (OPT_Wdeprecated_declarations
,
12068 "%qE is deprecated", what
);
12073 w
= warning (OPT_Wdeprecated_declarations
,
12074 "type is deprecated: %s", msg
);
12076 w
= warning (OPT_Wdeprecated_declarations
,
12077 "type is deprecated");
12080 inform (DECL_SOURCE_LOCATION (decl
), "declared here");
12087 warning (OPT_Wdeprecated_declarations
, "%qE is deprecated: %s",
12090 warning (OPT_Wdeprecated_declarations
, "%qE is deprecated", what
);
12095 warning (OPT_Wdeprecated_declarations
, "type is deprecated: %s",
12098 warning (OPT_Wdeprecated_declarations
, "type is deprecated");
12104 /* Return true if REF has a COMPONENT_REF with a bit-field field declaration
12105 somewhere in it. */
12108 contains_bitfld_component_ref_p (const_tree ref
)
12110 while (handled_component_p (ref
))
12112 if (TREE_CODE (ref
) == COMPONENT_REF
12113 && DECL_BIT_FIELD (TREE_OPERAND (ref
, 1)))
12115 ref
= TREE_OPERAND (ref
, 0);
12121 /* Try to determine whether a TRY_CATCH expression can fall through.
12122 This is a subroutine of block_may_fallthru. */
12125 try_catch_may_fallthru (const_tree stmt
)
12127 tree_stmt_iterator i
;
12129 /* If the TRY block can fall through, the whole TRY_CATCH can
12131 if (block_may_fallthru (TREE_OPERAND (stmt
, 0)))
12134 i
= tsi_start (TREE_OPERAND (stmt
, 1));
12135 switch (TREE_CODE (tsi_stmt (i
)))
12138 /* We expect to see a sequence of CATCH_EXPR trees, each with a
12139 catch expression and a body. The whole TRY_CATCH may fall
12140 through iff any of the catch bodies falls through. */
12141 for (; !tsi_end_p (i
); tsi_next (&i
))
12143 if (block_may_fallthru (CATCH_BODY (tsi_stmt (i
))))
12148 case EH_FILTER_EXPR
:
12149 /* The exception filter expression only matters if there is an
12150 exception. If the exception does not match EH_FILTER_TYPES,
12151 we will execute EH_FILTER_FAILURE, and we will fall through
12152 if that falls through. If the exception does match
12153 EH_FILTER_TYPES, the stack unwinder will continue up the
12154 stack, so we will not fall through. We don't know whether we
12155 will throw an exception which matches EH_FILTER_TYPES or not,
12156 so we just ignore EH_FILTER_TYPES and assume that we might
12157 throw an exception which doesn't match. */
12158 return block_may_fallthru (EH_FILTER_FAILURE (tsi_stmt (i
)));
12161 /* This case represents statements to be executed when an
12162 exception occurs. Those statements are implicitly followed
12163 by a RESX statement to resume execution after the exception.
12164 So in this case the TRY_CATCH never falls through. */
12169 /* Try to determine if we can fall out of the bottom of BLOCK. This guess
12170 need not be 100% accurate; simply be conservative and return true if we
12171 don't know. This is used only to avoid stupidly generating extra code.
12172 If we're wrong, we'll just delete the extra code later. */
12175 block_may_fallthru (const_tree block
)
12177 /* This CONST_CAST is okay because expr_last returns its argument
12178 unmodified and we assign it to a const_tree. */
12179 const_tree stmt
= expr_last (CONST_CAST_TREE (block
));
12181 switch (stmt
? TREE_CODE (stmt
) : ERROR_MARK
)
12185 /* Easy cases. If the last statement of the block implies
12186 control transfer, then we can't fall through. */
12190 /* If SWITCH_LABELS is set, this is lowered, and represents a
12191 branch to a selected label and hence can not fall through.
12192 Otherwise SWITCH_BODY is set, and the switch can fall
12194 return SWITCH_LABELS (stmt
) == NULL_TREE
;
12197 if (block_may_fallthru (COND_EXPR_THEN (stmt
)))
12199 return block_may_fallthru (COND_EXPR_ELSE (stmt
));
12202 return block_may_fallthru (BIND_EXPR_BODY (stmt
));
12204 case TRY_CATCH_EXPR
:
12205 return try_catch_may_fallthru (stmt
);
12207 case TRY_FINALLY_EXPR
:
12208 /* The finally clause is always executed after the try clause,
12209 so if it does not fall through, then the try-finally will not
12210 fall through. Otherwise, if the try clause does not fall
12211 through, then when the finally clause falls through it will
12212 resume execution wherever the try clause was going. So the
12213 whole try-finally will only fall through if both the try
12214 clause and the finally clause fall through. */
12215 return (block_may_fallthru (TREE_OPERAND (stmt
, 0))
12216 && block_may_fallthru (TREE_OPERAND (stmt
, 1)));
12219 if (TREE_CODE (TREE_OPERAND (stmt
, 1)) == CALL_EXPR
)
12220 stmt
= TREE_OPERAND (stmt
, 1);
12226 /* Functions that do not return do not fall through. */
12227 return (call_expr_flags (stmt
) & ECF_NORETURN
) == 0;
12229 case CLEANUP_POINT_EXPR
:
12230 return block_may_fallthru (TREE_OPERAND (stmt
, 0));
12233 return block_may_fallthru (TREE_OPERAND (stmt
, 1));
12239 return lang_hooks
.block_may_fallthru (stmt
);
12243 /* True if we are using EH to handle cleanups. */
12244 static bool using_eh_for_cleanups_flag
= false;
12246 /* This routine is called from front ends to indicate eh should be used for
12249 using_eh_for_cleanups (void)
12251 using_eh_for_cleanups_flag
= true;
12254 /* Query whether EH is used for cleanups. */
12256 using_eh_for_cleanups_p (void)
12258 return using_eh_for_cleanups_flag
;
12261 /* Wrapper for tree_code_name to ensure that tree code is valid */
12263 get_tree_code_name (enum tree_code code
)
12265 const char *invalid
= "<invalid tree code>";
12267 if (code
>= MAX_TREE_CODES
)
12270 return tree_code_name
[code
];
12273 /* Drops the TREE_OVERFLOW flag from T. */
12276 drop_tree_overflow (tree t
)
12278 gcc_checking_assert (TREE_OVERFLOW (t
));
12280 /* For tree codes with a sharing machinery re-build the result. */
12281 if (TREE_CODE (t
) == INTEGER_CST
)
12282 return wide_int_to_tree (TREE_TYPE (t
), t
);
12284 /* Otherwise, as all tcc_constants are possibly shared, copy the node
12285 and drop the flag. */
12287 TREE_OVERFLOW (t
) = 0;
12291 /* Given a memory reference expression T, return its base address.
12292 The base address of a memory reference expression is the main
12293 object being referenced. For instance, the base address for
12294 'array[i].fld[j]' is 'array'. You can think of this as stripping
12295 away the offset part from a memory address.
12297 This function calls handled_component_p to strip away all the inner
12298 parts of the memory reference until it reaches the base object. */
12301 get_base_address (tree t
)
12303 while (handled_component_p (t
))
12304 t
= TREE_OPERAND (t
, 0);
12306 if ((TREE_CODE (t
) == MEM_REF
12307 || TREE_CODE (t
) == TARGET_MEM_REF
)
12308 && TREE_CODE (TREE_OPERAND (t
, 0)) == ADDR_EXPR
)
12309 t
= TREE_OPERAND (TREE_OPERAND (t
, 0), 0);
12311 /* ??? Either the alias oracle or all callers need to properly deal
12312 with WITH_SIZE_EXPRs before we can look through those. */
12313 if (TREE_CODE (t
) == WITH_SIZE_EXPR
)
12319 /* Return the machine mode of T. For vectors, returns the mode of the
12320 inner type. The main use case is to feed the result to HONOR_NANS,
12321 avoiding the BLKmode that a direct TYPE_MODE (T) might return. */
12324 element_mode (const_tree t
)
12328 if (VECTOR_TYPE_P (t
) || TREE_CODE (t
) == COMPLEX_TYPE
)
12330 return TYPE_MODE (t
);
12333 #include "gt-tree.h"