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 ttype global_types
[TPI_MAX
];
294 tree integer_types
[itk_none
];
296 bool int_n_enabled_p
[NUM_INT_N_ENTS
];
297 struct int_n_trees_t int_n_trees
[NUM_INT_N_ENTS
];
299 unsigned char tree_contains_struct
[MAX_TREE_CODES
][64];
301 /* Number of operands for each OpenMP clause. */
302 unsigned const char omp_clause_num_ops
[] =
304 0, /* OMP_CLAUSE_ERROR */
305 1, /* OMP_CLAUSE_PRIVATE */
306 1, /* OMP_CLAUSE_SHARED */
307 1, /* OMP_CLAUSE_FIRSTPRIVATE */
308 2, /* OMP_CLAUSE_LASTPRIVATE */
309 4, /* OMP_CLAUSE_REDUCTION */
310 1, /* OMP_CLAUSE_COPYIN */
311 1, /* OMP_CLAUSE_COPYPRIVATE */
312 3, /* OMP_CLAUSE_LINEAR */
313 2, /* OMP_CLAUSE_ALIGNED */
314 1, /* OMP_CLAUSE_DEPEND */
315 1, /* OMP_CLAUSE_UNIFORM */
316 2, /* OMP_CLAUSE_FROM */
317 2, /* OMP_CLAUSE_TO */
318 2, /* OMP_CLAUSE_MAP */
319 1, /* OMP_CLAUSE__LOOPTEMP_ */
320 1, /* OMP_CLAUSE_IF */
321 1, /* OMP_CLAUSE_NUM_THREADS */
322 1, /* OMP_CLAUSE_SCHEDULE */
323 0, /* OMP_CLAUSE_NOWAIT */
324 0, /* OMP_CLAUSE_ORDERED */
325 0, /* OMP_CLAUSE_DEFAULT */
326 3, /* OMP_CLAUSE_COLLAPSE */
327 0, /* OMP_CLAUSE_UNTIED */
328 1, /* OMP_CLAUSE_FINAL */
329 0, /* OMP_CLAUSE_MERGEABLE */
330 1, /* OMP_CLAUSE_DEVICE */
331 1, /* OMP_CLAUSE_DIST_SCHEDULE */
332 0, /* OMP_CLAUSE_INBRANCH */
333 0, /* OMP_CLAUSE_NOTINBRANCH */
334 1, /* OMP_CLAUSE_NUM_TEAMS */
335 1, /* OMP_CLAUSE_THREAD_LIMIT */
336 0, /* OMP_CLAUSE_PROC_BIND */
337 1, /* OMP_CLAUSE_SAFELEN */
338 1, /* OMP_CLAUSE_SIMDLEN */
339 0, /* OMP_CLAUSE_FOR */
340 0, /* OMP_CLAUSE_PARALLEL */
341 0, /* OMP_CLAUSE_SECTIONS */
342 0, /* OMP_CLAUSE_TASKGROUP */
343 1, /* OMP_CLAUSE__SIMDUID_ */
344 1, /* OMP_CLAUSE__CILK_FOR_COUNT_ */
347 const char * const omp_clause_code_name
[] =
393 /* Return the tree node structure used by tree code CODE. */
395 static inline enum tree_node_structure_enum
396 tree_node_structure_for_code (enum tree_code code
)
398 switch (TREE_CODE_CLASS (code
))
400 case tcc_declaration
:
405 return TS_FIELD_DECL
;
411 return TS_LABEL_DECL
;
413 return TS_RESULT_DECL
;
414 case DEBUG_EXPR_DECL
:
417 return TS_CONST_DECL
;
421 return TS_FUNCTION_DECL
;
422 case TRANSLATION_UNIT_DECL
:
423 return TS_TRANSLATION_UNIT_DECL
;
425 return TS_DECL_NON_COMMON
;
429 return TS_TYPE_COMMON
;
438 default: /* tcc_constant and tcc_exceptional */
443 /* tcc_constant cases. */
444 case VOID_CST
: return TS_TYPED
;
445 case INTEGER_CST
: return TS_INT_CST
;
446 case REAL_CST
: return TS_REAL_CST
;
447 case FIXED_CST
: return TS_FIXED_CST
;
448 case COMPLEX_CST
: return TS_COMPLEX
;
449 case VECTOR_CST
: return TS_VECTOR
;
450 case STRING_CST
: return TS_STRING
;
451 /* tcc_exceptional cases. */
452 case ERROR_MARK
: return TS_COMMON
;
453 case IDENTIFIER_NODE
: return TS_IDENTIFIER
;
454 case TREE_LIST
: return TS_LIST
;
455 case TREE_VEC
: return TS_VEC
;
456 case SSA_NAME
: return TS_SSA_NAME
;
457 case PLACEHOLDER_EXPR
: return TS_COMMON
;
458 case STATEMENT_LIST
: return TS_STATEMENT_LIST
;
459 case BLOCK
: return TS_BLOCK
;
460 case CONSTRUCTOR
: return TS_CONSTRUCTOR
;
461 case TREE_BINFO
: return TS_BINFO
;
462 case OMP_CLAUSE
: return TS_OMP_CLAUSE
;
463 case OPTIMIZATION_NODE
: return TS_OPTIMIZATION
;
464 case TARGET_OPTION_NODE
: return TS_TARGET_OPTION
;
472 /* Initialize tree_contains_struct to describe the hierarchy of tree
476 initialize_tree_contains_struct (void)
480 for (i
= ERROR_MARK
; i
< LAST_AND_UNUSED_TREE_CODE
; i
++)
483 enum tree_node_structure_enum ts_code
;
485 code
= (enum tree_code
) i
;
486 ts_code
= tree_node_structure_for_code (code
);
488 /* Mark the TS structure itself. */
489 tree_contains_struct
[code
][ts_code
] = 1;
491 /* Mark all the structures that TS is derived from. */
509 case TS_STATEMENT_LIST
:
510 MARK_TS_TYPED (code
);
514 case TS_DECL_MINIMAL
:
520 case TS_OPTIMIZATION
:
521 case TS_TARGET_OPTION
:
522 MARK_TS_COMMON (code
);
526 MARK_TS_DECL_MINIMAL (code
);
531 MARK_TS_DECL_COMMON (code
);
534 case TS_DECL_NON_COMMON
:
535 MARK_TS_DECL_WITH_VIS (code
);
538 case TS_DECL_WITH_VIS
:
542 MARK_TS_DECL_WRTL (code
);
546 MARK_TS_DECL_COMMON (code
);
550 MARK_TS_DECL_WITH_VIS (code
);
554 case TS_FUNCTION_DECL
:
555 MARK_TS_DECL_NON_COMMON (code
);
558 case TS_TRANSLATION_UNIT_DECL
:
559 MARK_TS_DECL_COMMON (code
);
567 /* Basic consistency checks for attributes used in fold. */
568 gcc_assert (tree_contains_struct
[FUNCTION_DECL
][TS_DECL_NON_COMMON
]);
569 gcc_assert (tree_contains_struct
[TYPE_DECL
][TS_DECL_NON_COMMON
]);
570 gcc_assert (tree_contains_struct
[CONST_DECL
][TS_DECL_COMMON
]);
571 gcc_assert (tree_contains_struct
[VAR_DECL
][TS_DECL_COMMON
]);
572 gcc_assert (tree_contains_struct
[PARM_DECL
][TS_DECL_COMMON
]);
573 gcc_assert (tree_contains_struct
[RESULT_DECL
][TS_DECL_COMMON
]);
574 gcc_assert (tree_contains_struct
[FUNCTION_DECL
][TS_DECL_COMMON
]);
575 gcc_assert (tree_contains_struct
[TYPE_DECL
][TS_DECL_COMMON
]);
576 gcc_assert (tree_contains_struct
[TRANSLATION_UNIT_DECL
][TS_DECL_COMMON
]);
577 gcc_assert (tree_contains_struct
[LABEL_DECL
][TS_DECL_COMMON
]);
578 gcc_assert (tree_contains_struct
[FIELD_DECL
][TS_DECL_COMMON
]);
579 gcc_assert (tree_contains_struct
[VAR_DECL
][TS_DECL_WRTL
]);
580 gcc_assert (tree_contains_struct
[PARM_DECL
][TS_DECL_WRTL
]);
581 gcc_assert (tree_contains_struct
[RESULT_DECL
][TS_DECL_WRTL
]);
582 gcc_assert (tree_contains_struct
[FUNCTION_DECL
][TS_DECL_WRTL
]);
583 gcc_assert (tree_contains_struct
[LABEL_DECL
][TS_DECL_WRTL
]);
584 gcc_assert (tree_contains_struct
[CONST_DECL
][TS_DECL_MINIMAL
]);
585 gcc_assert (tree_contains_struct
[VAR_DECL
][TS_DECL_MINIMAL
]);
586 gcc_assert (tree_contains_struct
[PARM_DECL
][TS_DECL_MINIMAL
]);
587 gcc_assert (tree_contains_struct
[RESULT_DECL
][TS_DECL_MINIMAL
]);
588 gcc_assert (tree_contains_struct
[FUNCTION_DECL
][TS_DECL_MINIMAL
]);
589 gcc_assert (tree_contains_struct
[TYPE_DECL
][TS_DECL_MINIMAL
]);
590 gcc_assert (tree_contains_struct
[TRANSLATION_UNIT_DECL
][TS_DECL_MINIMAL
]);
591 gcc_assert (tree_contains_struct
[LABEL_DECL
][TS_DECL_MINIMAL
]);
592 gcc_assert (tree_contains_struct
[FIELD_DECL
][TS_DECL_MINIMAL
]);
593 gcc_assert (tree_contains_struct
[VAR_DECL
][TS_DECL_WITH_VIS
]);
594 gcc_assert (tree_contains_struct
[FUNCTION_DECL
][TS_DECL_WITH_VIS
]);
595 gcc_assert (tree_contains_struct
[TYPE_DECL
][TS_DECL_WITH_VIS
]);
596 gcc_assert (tree_contains_struct
[VAR_DECL
][TS_VAR_DECL
]);
597 gcc_assert (tree_contains_struct
[FIELD_DECL
][TS_FIELD_DECL
]);
598 gcc_assert (tree_contains_struct
[PARM_DECL
][TS_PARM_DECL
]);
599 gcc_assert (tree_contains_struct
[LABEL_DECL
][TS_LABEL_DECL
]);
600 gcc_assert (tree_contains_struct
[RESULT_DECL
][TS_RESULT_DECL
]);
601 gcc_assert (tree_contains_struct
[CONST_DECL
][TS_CONST_DECL
]);
602 gcc_assert (tree_contains_struct
[TYPE_DECL
][TS_TYPE_DECL
]);
603 gcc_assert (tree_contains_struct
[FUNCTION_DECL
][TS_FUNCTION_DECL
]);
604 gcc_assert (tree_contains_struct
[IMPORTED_DECL
][TS_DECL_MINIMAL
]);
605 gcc_assert (tree_contains_struct
[IMPORTED_DECL
][TS_DECL_COMMON
]);
606 gcc_assert (tree_contains_struct
[NAMELIST_DECL
][TS_DECL_MINIMAL
]);
607 gcc_assert (tree_contains_struct
[NAMELIST_DECL
][TS_DECL_COMMON
]);
616 /* Initialize the hash table of types. */
618 = hash_table
<type_cache_hasher
>::create_ggc (TYPE_HASH_INITIAL_SIZE
);
621 = hash_table
<tree_decl_map_cache_hasher
>::create_ggc (512);
624 = hash_table
<tree_decl_map_cache_hasher
>::create_ggc (512);
626 int_cst_hash_table
= hash_table
<int_cst_hasher
>::create_ggc (1024);
628 int_cst_node
= make_int_cst (1, 1);
630 cl_option_hash_table
= hash_table
<cl_option_hasher
>::create_ggc (64);
632 cl_optimization_node
= make_node (OPTIMIZATION_NODE
);
633 cl_target_option_node
= make_node (TARGET_OPTION_NODE
);
635 /* Initialize the tree_contains_struct array. */
636 initialize_tree_contains_struct ();
637 lang_hooks
.init_ts ();
641 /* The name of the object as the assembler will see it (but before any
642 translations made by ASM_OUTPUT_LABELREF). Often this is the same
643 as DECL_NAME. It is an IDENTIFIER_NODE. */
645 decl_assembler_name (tree decl
)
647 if (!DECL_ASSEMBLER_NAME_SET_P (decl
))
648 lang_hooks
.set_decl_assembler_name (decl
);
649 return DECL_WITH_VIS_CHECK (decl
)->decl_with_vis
.assembler_name
;
652 /* When the target supports COMDAT groups, this indicates which group the
653 DECL is associated with. This can be either an IDENTIFIER_NODE or a
654 decl, in which case its DECL_ASSEMBLER_NAME identifies the group. */
656 decl_comdat_group (const_tree node
)
658 struct symtab_node
*snode
= symtab_node::get (node
);
661 return snode
->get_comdat_group ();
664 /* Likewise, but make sure it's been reduced to an IDENTIFIER_NODE. */
666 decl_comdat_group_id (const_tree node
)
668 struct symtab_node
*snode
= symtab_node::get (node
);
671 return snode
->get_comdat_group_id ();
674 /* When the target supports named section, return its name as IDENTIFIER_NODE
675 or NULL if it is in no section. */
677 decl_section_name (const_tree node
)
679 struct symtab_node
*snode
= symtab_node::get (node
);
682 return snode
->get_section ();
685 /* Set section section name of NODE to VALUE (that is expected to
686 be identifier node) */
688 set_decl_section_name (tree node
, const char *value
)
690 struct symtab_node
*snode
;
694 snode
= symtab_node::get (node
);
698 else if (TREE_CODE (node
) == VAR_DECL
)
699 snode
= varpool_node::get_create (node
);
701 snode
= cgraph_node::get_create (node
);
702 snode
->set_section (value
);
705 /* Return TLS model of a variable NODE. */
707 decl_tls_model (const_tree node
)
709 struct varpool_node
*snode
= varpool_node::get (node
);
711 return TLS_MODEL_NONE
;
712 return snode
->tls_model
;
715 /* Set TLS model of variable NODE to MODEL. */
717 set_decl_tls_model (tree node
, enum tls_model model
)
719 struct varpool_node
*vnode
;
721 if (model
== TLS_MODEL_NONE
)
723 vnode
= varpool_node::get (node
);
728 vnode
= varpool_node::get_create (node
);
729 vnode
->tls_model
= model
;
732 /* Compute the number of bytes occupied by a tree with code CODE.
733 This function cannot be used for nodes that have variable sizes,
734 including TREE_VEC, INTEGER_CST, STRING_CST, and CALL_EXPR. */
736 tree_code_size (enum tree_code code
)
738 switch (TREE_CODE_CLASS (code
))
740 case tcc_declaration
: /* A decl node */
745 return sizeof (struct tree_field_decl
);
747 return sizeof (struct tree_parm_decl
);
749 return sizeof (struct tree_var_decl
);
751 return sizeof (struct tree_label_decl
);
753 return sizeof (struct tree_result_decl
);
755 return sizeof (struct tree_const_decl
);
757 return sizeof (struct tree_type_decl
);
759 return sizeof (struct tree_function_decl
);
760 case DEBUG_EXPR_DECL
:
761 return sizeof (struct tree_decl_with_rtl
);
762 case TRANSLATION_UNIT_DECL
:
763 return sizeof (struct tree_translation_unit_decl
);
767 return sizeof (struct tree_decl_non_common
);
769 return lang_hooks
.tree_size (code
);
773 case tcc_type
: /* a type node */
774 return sizeof (struct tree_type_common
);
776 case tcc_reference
: /* a reference */
777 case tcc_expression
: /* an expression */
778 case tcc_statement
: /* an expression with side effects */
779 case tcc_comparison
: /* a comparison expression */
780 case tcc_unary
: /* a unary arithmetic expression */
781 case tcc_binary
: /* a binary arithmetic expression */
782 return (sizeof (struct tree_exp
)
783 + (TREE_CODE_LENGTH (code
) - 1) * sizeof (tree
));
785 case tcc_constant
: /* a constant */
788 case VOID_CST
: return sizeof (struct tree_typed
);
789 case INTEGER_CST
: gcc_unreachable ();
790 case REAL_CST
: return sizeof (struct tree_real_cst
);
791 case FIXED_CST
: return sizeof (struct tree_fixed_cst
);
792 case COMPLEX_CST
: return sizeof (struct tree_complex
);
793 case VECTOR_CST
: return sizeof (struct tree_vector
);
794 case STRING_CST
: gcc_unreachable ();
796 return lang_hooks
.tree_size (code
);
799 case tcc_exceptional
: /* something random, like an identifier. */
802 case IDENTIFIER_NODE
: return lang_hooks
.identifier_size
;
803 case TREE_LIST
: return sizeof (struct tree_list
);
806 case PLACEHOLDER_EXPR
: return sizeof (struct tree_common
);
809 case OMP_CLAUSE
: gcc_unreachable ();
811 case SSA_NAME
: return sizeof (struct tree_ssa_name
);
813 case STATEMENT_LIST
: return sizeof (struct tree_statement_list
);
814 case BLOCK
: return sizeof (struct tree_block
);
815 case CONSTRUCTOR
: return sizeof (struct tree_constructor
);
816 case OPTIMIZATION_NODE
: return sizeof (struct tree_optimization_option
);
817 case TARGET_OPTION_NODE
: return sizeof (struct tree_target_option
);
820 return lang_hooks
.tree_size (code
);
828 /* Compute the number of bytes occupied by NODE. This routine only
829 looks at TREE_CODE, except for those nodes that have variable sizes. */
831 tree_size (const_tree node
)
833 const enum tree_code code
= TREE_CODE (node
);
837 return (sizeof (struct tree_int_cst
)
838 + (TREE_INT_CST_EXT_NUNITS (node
) - 1) * sizeof (HOST_WIDE_INT
));
841 return (offsetof (struct tree_binfo
, base_binfos
)
843 ::embedded_size (BINFO_N_BASE_BINFOS (node
)));
846 return (sizeof (struct tree_vec
)
847 + (TREE_VEC_LENGTH (node
) - 1) * sizeof (tree
));
850 return (sizeof (struct tree_vector
)
851 + (TYPE_VECTOR_SUBPARTS (TREE_TYPE (node
)) - 1) * sizeof (tree
));
854 return TREE_STRING_LENGTH (node
) + offsetof (struct tree_string
, str
) + 1;
857 return (sizeof (struct tree_omp_clause
)
858 + (omp_clause_num_ops
[OMP_CLAUSE_CODE (node
)] - 1)
862 if (TREE_CODE_CLASS (code
) == tcc_vl_exp
)
863 return (sizeof (struct tree_exp
)
864 + (VL_EXP_OPERAND_LENGTH (node
) - 1) * sizeof (tree
));
866 return tree_code_size (code
);
870 /* Record interesting allocation statistics for a tree node with CODE
874 record_node_allocation_statistics (enum tree_code code ATTRIBUTE_UNUSED
,
875 size_t length ATTRIBUTE_UNUSED
)
877 enum tree_code_class type
= TREE_CODE_CLASS (code
);
880 if (!GATHER_STATISTICS
)
885 case tcc_declaration
: /* A decl node */
889 case tcc_type
: /* a type node */
893 case tcc_statement
: /* an expression with side effects */
897 case tcc_reference
: /* a reference */
901 case tcc_expression
: /* an expression */
902 case tcc_comparison
: /* a comparison expression */
903 case tcc_unary
: /* a unary arithmetic expression */
904 case tcc_binary
: /* a binary arithmetic expression */
908 case tcc_constant
: /* a constant */
912 case tcc_exceptional
: /* something random, like an identifier. */
915 case IDENTIFIER_NODE
:
928 kind
= ssa_name_kind
;
940 kind
= omp_clause_kind
;
957 tree_code_counts
[(int) code
]++;
958 tree_node_counts
[(int) kind
]++;
959 tree_node_sizes
[(int) kind
] += length
;
962 /* Allocate and return a new UID from the DECL_UID namespace. */
965 allocate_decl_uid (void)
967 return next_decl_uid
++;
970 /* Return a newly allocated node of code CODE. For decl and type
971 nodes, some other fields are initialized. The rest of the node is
972 initialized to zero. This function cannot be used for TREE_VEC,
973 INTEGER_CST or OMP_CLAUSE nodes, which is enforced by asserts in
976 Achoo! I got a code in the node. */
979 make_node_stat (enum tree_code code MEM_STAT_DECL
)
982 enum tree_code_class type
= TREE_CODE_CLASS (code
);
983 size_t length
= tree_code_size (code
);
985 record_node_allocation_statistics (code
, length
);
987 t
= ggc_alloc_cleared_tree_node_stat (length PASS_MEM_STAT
);
988 TREE_SET_CODE (t
, code
);
993 TREE_SIDE_EFFECTS (t
) = 1;
996 case tcc_declaration
:
997 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_COMMON
))
999 if (code
== FUNCTION_DECL
)
1001 DECL_ALIGN (t
) = FUNCTION_BOUNDARY
;
1002 DECL_MODE (t
) = FUNCTION_MODE
;
1007 DECL_SOURCE_LOCATION (t
) = input_location
;
1008 if (TREE_CODE (t
) == DEBUG_EXPR_DECL
)
1009 DECL_UID (t
) = --next_debug_decl_uid
;
1012 DECL_UID (t
) = allocate_decl_uid ();
1013 SET_DECL_PT_UID (t
, -1);
1015 if (TREE_CODE (t
) == LABEL_DECL
)
1016 LABEL_DECL_UID (t
) = -1;
1021 TYPE_UID (t
) = next_type_uid
++;
1022 TYPE_ALIGN (t
) = BITS_PER_UNIT
;
1023 TYPE_USER_ALIGN (t
) = 0;
1024 TYPE_MAIN_VARIANT (t
) = t
;
1025 TYPE_CANONICAL (t
) = t
;
1027 /* Default to no attributes for type, but let target change that. */
1028 TYPE_ATTRIBUTES (t
) = NULL_TREE
;
1029 targetm
.set_default_type_attributes (t
);
1031 /* We have not yet computed the alias set for this type. */
1032 TYPE_ALIAS_SET (t
) = -1;
1036 TREE_CONSTANT (t
) = 1;
1039 case tcc_expression
:
1045 case PREDECREMENT_EXPR
:
1046 case PREINCREMENT_EXPR
:
1047 case POSTDECREMENT_EXPR
:
1048 case POSTINCREMENT_EXPR
:
1049 /* All of these have side-effects, no matter what their
1051 TREE_SIDE_EFFECTS (t
) = 1;
1060 /* Other classes need no special treatment. */
1067 /* Return a new node with the same contents as NODE except that its
1068 TREE_CHAIN, if it has one, is zero and it has a fresh uid. */
1071 copy_node_stat (tree node MEM_STAT_DECL
)
1074 enum tree_code code
= TREE_CODE (node
);
1077 gcc_assert (code
!= STATEMENT_LIST
);
1079 length
= tree_size (node
);
1080 record_node_allocation_statistics (code
, length
);
1081 t
= ggc_alloc_tree_node_stat (length PASS_MEM_STAT
);
1082 memcpy (t
, node
, length
);
1084 if (CODE_CONTAINS_STRUCT (code
, TS_COMMON
))
1086 TREE_ASM_WRITTEN (t
) = 0;
1087 TREE_VISITED (t
) = 0;
1089 if (TREE_CODE_CLASS (code
) == tcc_declaration
)
1091 if (code
== DEBUG_EXPR_DECL
)
1092 DECL_UID (t
) = --next_debug_decl_uid
;
1095 DECL_UID (t
) = allocate_decl_uid ();
1096 if (DECL_PT_UID_SET_P (node
))
1097 SET_DECL_PT_UID (t
, DECL_PT_UID (node
));
1099 if ((TREE_CODE (node
) == PARM_DECL
|| TREE_CODE (node
) == VAR_DECL
)
1100 && DECL_HAS_VALUE_EXPR_P (node
))
1102 SET_DECL_VALUE_EXPR (t
, DECL_VALUE_EXPR (node
));
1103 DECL_HAS_VALUE_EXPR_P (t
) = 1;
1105 /* DECL_DEBUG_EXPR is copied explicitely by callers. */
1106 if (TREE_CODE (node
) == VAR_DECL
)
1108 DECL_HAS_DEBUG_EXPR_P (t
) = 0;
1109 t
->decl_with_vis
.symtab_node
= NULL
;
1111 if (TREE_CODE (node
) == VAR_DECL
&& DECL_HAS_INIT_PRIORITY_P (node
))
1113 SET_DECL_INIT_PRIORITY (t
, DECL_INIT_PRIORITY (node
));
1114 DECL_HAS_INIT_PRIORITY_P (t
) = 1;
1116 if (TREE_CODE (node
) == FUNCTION_DECL
)
1118 DECL_STRUCT_FUNCTION (t
) = NULL
;
1119 t
->decl_with_vis
.symtab_node
= NULL
;
1122 else if (TREE_CODE_CLASS (code
) == tcc_type
)
1124 TYPE_UID (t
) = next_type_uid
++;
1125 /* The following is so that the debug code for
1126 the copy is different from the original type.
1127 The two statements usually duplicate each other
1128 (because they clear fields of the same union),
1129 but the optimizer should catch that. */
1130 TYPE_SYMTAB_POINTER (t
) = 0;
1131 TYPE_SYMTAB_ADDRESS (t
) = 0;
1133 /* Do not copy the values cache. */
1134 if (TYPE_CACHED_VALUES_P (t
))
1136 TYPE_CACHED_VALUES_P (t
) = 0;
1137 TYPE_CACHED_VALUES (t
) = NULL_TREE
;
1144 /* Return a copy of a chain of nodes, chained through the TREE_CHAIN field.
1145 For example, this can copy a list made of TREE_LIST nodes. */
1148 copy_list (tree list
)
1156 head
= prev
= copy_node (list
);
1157 next
= TREE_CHAIN (list
);
1160 TREE_CHAIN (prev
) = copy_node (next
);
1161 prev
= TREE_CHAIN (prev
);
1162 next
= TREE_CHAIN (next
);
1168 /* Return the value that TREE_INT_CST_EXT_NUNITS should have for an
1169 INTEGER_CST with value CST and type TYPE. */
1172 get_int_cst_ext_nunits (tree type
, const wide_int
&cst
)
1174 gcc_checking_assert (cst
.get_precision () == TYPE_PRECISION (type
));
1175 /* We need an extra zero HWI if CST is an unsigned integer with its
1176 upper bit set, and if CST occupies a whole number of HWIs. */
1177 if (TYPE_UNSIGNED (type
)
1179 && (cst
.get_precision () % HOST_BITS_PER_WIDE_INT
) == 0)
1180 return cst
.get_precision () / HOST_BITS_PER_WIDE_INT
+ 1;
1181 return cst
.get_len ();
1184 /* Return a new INTEGER_CST with value CST and type TYPE. */
1187 build_new_int_cst (tree type
, const wide_int
&cst
)
1189 unsigned int len
= cst
.get_len ();
1190 unsigned int ext_len
= get_int_cst_ext_nunits (type
, cst
);
1191 tree nt
= make_int_cst (len
, ext_len
);
1196 TREE_INT_CST_ELT (nt
, ext_len
) = 0;
1197 for (unsigned int i
= len
; i
< ext_len
; ++i
)
1198 TREE_INT_CST_ELT (nt
, i
) = -1;
1200 else if (TYPE_UNSIGNED (type
)
1201 && cst
.get_precision () < len
* HOST_BITS_PER_WIDE_INT
)
1204 TREE_INT_CST_ELT (nt
, len
)
1205 = zext_hwi (cst
.elt (len
),
1206 cst
.get_precision () % HOST_BITS_PER_WIDE_INT
);
1209 for (unsigned int i
= 0; i
< len
; i
++)
1210 TREE_INT_CST_ELT (nt
, i
) = cst
.elt (i
);
1211 TREE_TYPE (nt
) = type
;
1215 /* Create an INT_CST node with a LOW value sign extended to TYPE. */
1218 build_int_cst (tree type
, HOST_WIDE_INT low
)
1220 /* Support legacy code. */
1222 type
= integer_type_node
;
1224 return wide_int_to_tree (type
, wi::shwi (low
, TYPE_PRECISION (type
)));
1228 build_int_cstu (tree type
, unsigned HOST_WIDE_INT cst
)
1230 return wide_int_to_tree (type
, wi::uhwi (cst
, TYPE_PRECISION (type
)));
1233 /* Create an INT_CST node with a LOW value sign extended to TYPE. */
1236 build_int_cst_type (tree type
, HOST_WIDE_INT low
)
1239 return wide_int_to_tree (type
, wi::shwi (low
, TYPE_PRECISION (type
)));
1242 /* Constructs tree in type TYPE from with value given by CST. Signedness
1243 of CST is assumed to be the same as the signedness of TYPE. */
1246 double_int_to_tree (tree type
, double_int cst
)
1248 return wide_int_to_tree (type
, widest_int::from (cst
, TYPE_SIGN (type
)));
1251 /* We force the wide_int CST to the range of the type TYPE by sign or
1252 zero extending it. OVERFLOWABLE indicates if we are interested in
1253 overflow of the value, when >0 we are only interested in signed
1254 overflow, for <0 we are interested in any overflow. OVERFLOWED
1255 indicates whether overflow has already occurred. CONST_OVERFLOWED
1256 indicates whether constant overflow has already occurred. We force
1257 T's value to be within range of T's type (by setting to 0 or 1 all
1258 the bits outside the type's range). We set TREE_OVERFLOWED if,
1259 OVERFLOWED is nonzero,
1260 or OVERFLOWABLE is >0 and signed overflow occurs
1261 or OVERFLOWABLE is <0 and any overflow occurs
1262 We return a new tree node for the extended wide_int. The node
1263 is shared if no overflow flags are set. */
1267 force_fit_type (tree type
, const wide_int_ref
&cst
,
1268 int overflowable
, bool overflowed
)
1270 signop sign
= TYPE_SIGN (type
);
1272 /* If we need to set overflow flags, return a new unshared node. */
1273 if (overflowed
|| !wi::fits_to_tree_p (cst
, type
))
1277 || (overflowable
> 0 && sign
== SIGNED
))
1279 wide_int tmp
= wide_int::from (cst
, TYPE_PRECISION (type
), sign
);
1280 tree t
= build_new_int_cst (type
, tmp
);
1281 TREE_OVERFLOW (t
) = 1;
1286 /* Else build a shared node. */
1287 return wide_int_to_tree (type
, cst
);
1290 /* These are the hash table functions for the hash table of INTEGER_CST
1291 nodes of a sizetype. */
1293 /* Return the hash code code X, an INTEGER_CST. */
1296 int_cst_hasher::hash (tree x
)
1298 const_tree
const t
= x
;
1299 hashval_t code
= TYPE_UID (TREE_TYPE (t
));
1302 for (i
= 0; i
< TREE_INT_CST_NUNITS (t
); i
++)
1303 code
^= TREE_INT_CST_ELT (t
, i
);
1308 /* Return nonzero if the value represented by *X (an INTEGER_CST tree node)
1309 is the same as that given by *Y, which is the same. */
1312 int_cst_hasher::equal (tree x
, tree y
)
1314 const_tree
const xt
= x
;
1315 const_tree
const yt
= y
;
1317 if (TREE_TYPE (xt
) != TREE_TYPE (yt
)
1318 || TREE_INT_CST_NUNITS (xt
) != TREE_INT_CST_NUNITS (yt
)
1319 || TREE_INT_CST_EXT_NUNITS (xt
) != TREE_INT_CST_EXT_NUNITS (yt
))
1322 for (int i
= 0; i
< TREE_INT_CST_NUNITS (xt
); i
++)
1323 if (TREE_INT_CST_ELT (xt
, i
) != TREE_INT_CST_ELT (yt
, i
))
1329 /* Create an INT_CST node of TYPE and value CST.
1330 The returned node is always shared. For small integers we use a
1331 per-type vector cache, for larger ones we use a single hash table.
1332 The value is extended from its precision according to the sign of
1333 the type to be a multiple of HOST_BITS_PER_WIDE_INT. This defines
1334 the upper bits and ensures that hashing and value equality based
1335 upon the underlying HOST_WIDE_INTs works without masking. */
1338 wide_int_to_tree (tree type
, const wide_int_ref
&pcst
)
1345 unsigned int prec
= TYPE_PRECISION (type
);
1346 signop sgn
= TYPE_SIGN (type
);
1348 /* Verify that everything is canonical. */
1349 int l
= pcst
.get_len ();
1352 if (pcst
.elt (l
- 1) == 0)
1353 gcc_checking_assert (pcst
.elt (l
- 2) < 0);
1354 if (pcst
.elt (l
- 1) == (HOST_WIDE_INT
) -1)
1355 gcc_checking_assert (pcst
.elt (l
- 2) >= 0);
1358 wide_int cst
= wide_int::from (pcst
, prec
, sgn
);
1359 unsigned int ext_len
= get_int_cst_ext_nunits (type
, cst
);
1363 /* We just need to store a single HOST_WIDE_INT. */
1365 if (TYPE_UNSIGNED (type
))
1366 hwi
= cst
.to_uhwi ();
1368 hwi
= cst
.to_shwi ();
1370 switch (TREE_CODE (type
))
1373 gcc_assert (hwi
== 0);
1377 case REFERENCE_TYPE
:
1378 case POINTER_BOUNDS_TYPE
:
1379 /* Cache NULL pointer and zero bounds. */
1388 /* Cache false or true. */
1396 if (TYPE_SIGN (type
) == UNSIGNED
)
1399 limit
= INTEGER_SHARE_LIMIT
;
1400 if (IN_RANGE (hwi
, 0, INTEGER_SHARE_LIMIT
- 1))
1405 /* Cache [-1, N). */
1406 limit
= INTEGER_SHARE_LIMIT
+ 1;
1407 if (IN_RANGE (hwi
, -1, INTEGER_SHARE_LIMIT
- 1))
1421 /* Look for it in the type's vector of small shared ints. */
1422 if (!TYPE_CACHED_VALUES_P (type
))
1424 TYPE_CACHED_VALUES_P (type
) = 1;
1425 TYPE_CACHED_VALUES (type
) = make_tree_vec (limit
);
1428 t
= TREE_VEC_ELT (TYPE_CACHED_VALUES (type
), ix
);
1430 /* Make sure no one is clobbering the shared constant. */
1431 gcc_checking_assert (TREE_TYPE (t
) == type
1432 && TREE_INT_CST_NUNITS (t
) == 1
1433 && TREE_INT_CST_OFFSET_NUNITS (t
) == 1
1434 && TREE_INT_CST_EXT_NUNITS (t
) == 1
1435 && TREE_INT_CST_ELT (t
, 0) == hwi
);
1438 /* Create a new shared int. */
1439 t
= build_new_int_cst (type
, cst
);
1440 TREE_VEC_ELT (TYPE_CACHED_VALUES (type
), ix
) = t
;
1445 /* Use the cache of larger shared ints, using int_cst_node as
1448 TREE_INT_CST_ELT (int_cst_node
, 0) = hwi
;
1449 TREE_TYPE (int_cst_node
) = type
;
1451 tree
*slot
= int_cst_hash_table
->find_slot (int_cst_node
, INSERT
);
1455 /* Insert this one into the hash table. */
1458 /* Make a new node for next time round. */
1459 int_cst_node
= make_int_cst (1, 1);
1465 /* The value either hashes properly or we drop it on the floor
1466 for the gc to take care of. There will not be enough of them
1469 tree nt
= build_new_int_cst (type
, cst
);
1470 tree
*slot
= int_cst_hash_table
->find_slot (nt
, INSERT
);
1474 /* Insert this one into the hash table. */
1484 cache_integer_cst (tree t
)
1486 tree type
= TREE_TYPE (t
);
1489 int prec
= TYPE_PRECISION (type
);
1491 gcc_assert (!TREE_OVERFLOW (t
));
1493 switch (TREE_CODE (type
))
1496 gcc_assert (integer_zerop (t
));
1500 case REFERENCE_TYPE
:
1501 /* Cache NULL pointer. */
1502 if (integer_zerop (t
))
1510 /* Cache false or true. */
1512 if (wi::ltu_p (t
, 2))
1513 ix
= TREE_INT_CST_ELT (t
, 0);
1518 if (TYPE_UNSIGNED (type
))
1521 limit
= INTEGER_SHARE_LIMIT
;
1523 /* This is a little hokie, but if the prec is smaller than
1524 what is necessary to hold INTEGER_SHARE_LIMIT, then the
1525 obvious test will not get the correct answer. */
1526 if (prec
< HOST_BITS_PER_WIDE_INT
)
1528 if (tree_to_uhwi (t
) < (unsigned HOST_WIDE_INT
) INTEGER_SHARE_LIMIT
)
1529 ix
= tree_to_uhwi (t
);
1531 else if (wi::ltu_p (t
, INTEGER_SHARE_LIMIT
))
1532 ix
= tree_to_uhwi (t
);
1537 limit
= INTEGER_SHARE_LIMIT
+ 1;
1539 if (integer_minus_onep (t
))
1541 else if (!wi::neg_p (t
))
1543 if (prec
< HOST_BITS_PER_WIDE_INT
)
1545 if (tree_to_shwi (t
) < INTEGER_SHARE_LIMIT
)
1546 ix
= tree_to_shwi (t
) + 1;
1548 else if (wi::ltu_p (t
, INTEGER_SHARE_LIMIT
))
1549 ix
= tree_to_shwi (t
) + 1;
1563 /* Look for it in the type's vector of small shared ints. */
1564 if (!TYPE_CACHED_VALUES_P (type
))
1566 TYPE_CACHED_VALUES_P (type
) = 1;
1567 TYPE_CACHED_VALUES (type
) = make_tree_vec (limit
);
1570 gcc_assert (TREE_VEC_ELT (TYPE_CACHED_VALUES (type
), ix
) == NULL_TREE
);
1571 TREE_VEC_ELT (TYPE_CACHED_VALUES (type
), ix
) = t
;
1575 /* Use the cache of larger shared ints. */
1576 tree
*slot
= int_cst_hash_table
->find_slot (t
, INSERT
);
1577 /* If there is already an entry for the number verify it's the
1580 gcc_assert (wi::eq_p (tree (*slot
), t
));
1582 /* Otherwise insert this one into the hash table. */
1588 /* Builds an integer constant in TYPE such that lowest BITS bits are ones
1589 and the rest are zeros. */
1592 build_low_bits_mask (tree type
, unsigned bits
)
1594 gcc_assert (bits
<= TYPE_PRECISION (type
));
1596 return wide_int_to_tree (type
, wi::mask (bits
, false,
1597 TYPE_PRECISION (type
)));
1600 /* Checks that X is integer constant that can be expressed in (unsigned)
1601 HOST_WIDE_INT without loss of precision. */
1604 cst_and_fits_in_hwi (const_tree x
)
1606 if (TREE_CODE (x
) != INTEGER_CST
)
1609 if (TYPE_PRECISION (TREE_TYPE (x
)) > HOST_BITS_PER_WIDE_INT
)
1612 return TREE_INT_CST_NUNITS (x
) == 1;
1615 /* Build a newly constructed TREE_VEC node of length LEN. */
1618 make_vector_stat (unsigned len MEM_STAT_DECL
)
1621 unsigned length
= (len
- 1) * sizeof (tree
) + sizeof (struct tree_vector
);
1623 record_node_allocation_statistics (VECTOR_CST
, length
);
1625 t
= ggc_alloc_cleared_tree_node_stat (length PASS_MEM_STAT
);
1627 TREE_SET_CODE (t
, VECTOR_CST
);
1628 TREE_CONSTANT (t
) = 1;
1633 /* Return a new VECTOR_CST node whose type is TYPE and whose values
1634 are in a list pointed to by VALS. */
1637 build_vector_stat (tree type
, tree
*vals MEM_STAT_DECL
)
1641 tree v
= make_vector (TYPE_VECTOR_SUBPARTS (type
));
1642 TREE_TYPE (v
) = type
;
1644 /* Iterate through elements and check for overflow. */
1645 for (cnt
= 0; cnt
< TYPE_VECTOR_SUBPARTS (type
); ++cnt
)
1647 tree value
= vals
[cnt
];
1649 VECTOR_CST_ELT (v
, cnt
) = value
;
1651 /* Don't crash if we get an address constant. */
1652 if (!CONSTANT_CLASS_P (value
))
1655 over
|= TREE_OVERFLOW (value
);
1658 TREE_OVERFLOW (v
) = over
;
1662 /* Return a new VECTOR_CST node whose type is TYPE and whose values
1663 are extracted from V, a vector of CONSTRUCTOR_ELT. */
1666 build_vector_from_ctor (tree type
, vec
<constructor_elt
, va_gc
> *v
)
1668 tree
*vec
= XALLOCAVEC (tree
, TYPE_VECTOR_SUBPARTS (type
));
1669 unsigned HOST_WIDE_INT idx
;
1672 FOR_EACH_CONSTRUCTOR_VALUE (v
, idx
, value
)
1674 for (; idx
< TYPE_VECTOR_SUBPARTS (type
); ++idx
)
1675 vec
[idx
] = build_zero_cst (TREE_TYPE (type
));
1677 return build_vector (type
, vec
);
1680 /* Build a vector of type VECTYPE where all the elements are SCs. */
1682 build_vector_from_val (tree vectype
, tree sc
)
1684 int i
, nunits
= TYPE_VECTOR_SUBPARTS (vectype
);
1686 if (sc
== error_mark_node
)
1689 /* Verify that the vector type is suitable for SC. Note that there
1690 is some inconsistency in the type-system with respect to restrict
1691 qualifications of pointers. Vector types always have a main-variant
1692 element type and the qualification is applied to the vector-type.
1693 So TREE_TYPE (vector-type) does not return a properly qualified
1694 vector element-type. */
1695 gcc_checking_assert (types_compatible_p (TYPE_MAIN_VARIANT (TREE_TYPE (sc
)),
1696 TREE_TYPE (vectype
)));
1698 if (CONSTANT_CLASS_P (sc
))
1700 tree
*v
= XALLOCAVEC (tree
, nunits
);
1701 for (i
= 0; i
< nunits
; ++i
)
1703 return build_vector (vectype
, v
);
1707 vec
<constructor_elt
, va_gc
> *v
;
1708 vec_alloc (v
, nunits
);
1709 for (i
= 0; i
< nunits
; ++i
)
1710 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, sc
);
1711 return build_constructor (vectype
, v
);
1715 /* Return a new CONSTRUCTOR node whose type is TYPE and whose values
1716 are in the vec pointed to by VALS. */
1718 build_constructor (tree type
, vec
<constructor_elt
, va_gc
> *vals
)
1720 tree c
= make_node (CONSTRUCTOR
);
1722 constructor_elt
*elt
;
1723 bool constant_p
= true;
1724 bool side_effects_p
= false;
1726 TREE_TYPE (c
) = type
;
1727 CONSTRUCTOR_ELTS (c
) = vals
;
1729 FOR_EACH_VEC_SAFE_ELT (vals
, i
, elt
)
1731 /* Mostly ctors will have elts that don't have side-effects, so
1732 the usual case is to scan all the elements. Hence a single
1733 loop for both const and side effects, rather than one loop
1734 each (with early outs). */
1735 if (!TREE_CONSTANT (elt
->value
))
1737 if (TREE_SIDE_EFFECTS (elt
->value
))
1738 side_effects_p
= true;
1741 TREE_SIDE_EFFECTS (c
) = side_effects_p
;
1742 TREE_CONSTANT (c
) = constant_p
;
1747 /* Build a CONSTRUCTOR node made of a single initializer, with the specified
1750 build_constructor_single (tree type
, tree index
, tree value
)
1752 vec
<constructor_elt
, va_gc
> *v
;
1753 constructor_elt elt
= {index
, value
};
1756 v
->quick_push (elt
);
1758 return build_constructor (type
, v
);
1762 /* Return a new CONSTRUCTOR node whose type is TYPE and whose values
1763 are in a list pointed to by VALS. */
1765 build_constructor_from_list (tree type
, tree vals
)
1768 vec
<constructor_elt
, va_gc
> *v
= NULL
;
1772 vec_alloc (v
, list_length (vals
));
1773 for (t
= vals
; t
; t
= TREE_CHAIN (t
))
1774 CONSTRUCTOR_APPEND_ELT (v
, TREE_PURPOSE (t
), TREE_VALUE (t
));
1777 return build_constructor (type
, v
);
1780 /* Return a new CONSTRUCTOR node whose type is TYPE. NELTS is the number
1781 of elements, provided as index/value pairs. */
1784 build_constructor_va (tree type
, int nelts
, ...)
1786 vec
<constructor_elt
, va_gc
> *v
= NULL
;
1789 va_start (p
, nelts
);
1790 vec_alloc (v
, nelts
);
1793 tree index
= va_arg (p
, tree
);
1794 tree value
= va_arg (p
, tree
);
1795 CONSTRUCTOR_APPEND_ELT (v
, index
, value
);
1798 return build_constructor (type
, v
);
1801 /* Return a new FIXED_CST node whose type is TYPE and value is F. */
1804 build_fixed (tree type
, FIXED_VALUE_TYPE f
)
1807 FIXED_VALUE_TYPE
*fp
;
1809 v
= make_node (FIXED_CST
);
1810 fp
= ggc_alloc
<fixed_value
> ();
1811 memcpy (fp
, &f
, sizeof (FIXED_VALUE_TYPE
));
1813 TREE_TYPE (v
) = type
;
1814 TREE_FIXED_CST_PTR (v
) = fp
;
1818 /* Return a new REAL_CST node whose type is TYPE and value is D. */
1821 build_real (tree type
, REAL_VALUE_TYPE d
)
1824 REAL_VALUE_TYPE
*dp
;
1827 /* ??? Used to check for overflow here via CHECK_FLOAT_TYPE.
1828 Consider doing it via real_convert now. */
1830 v
= make_node (REAL_CST
);
1831 dp
= ggc_alloc
<real_value
> ();
1832 memcpy (dp
, &d
, sizeof (REAL_VALUE_TYPE
));
1834 TREE_TYPE (v
) = type
;
1835 TREE_REAL_CST_PTR (v
) = dp
;
1836 TREE_OVERFLOW (v
) = overflow
;
1840 /* Return a new REAL_CST node whose type is TYPE
1841 and whose value is the integer value of the INTEGER_CST node I. */
1844 real_value_from_int_cst (const_tree type
, const_tree i
)
1848 /* Clear all bits of the real value type so that we can later do
1849 bitwise comparisons to see if two values are the same. */
1850 memset (&d
, 0, sizeof d
);
1852 real_from_integer (&d
, type
? TYPE_MODE (type
) : VOIDmode
, i
,
1853 TYPE_SIGN (TREE_TYPE (i
)));
1857 /* Given a tree representing an integer constant I, return a tree
1858 representing the same value as a floating-point constant of type TYPE. */
1861 build_real_from_int_cst (tree type
, const_tree i
)
1864 int overflow
= TREE_OVERFLOW (i
);
1866 v
= build_real (type
, real_value_from_int_cst (type
, i
));
1868 TREE_OVERFLOW (v
) |= overflow
;
1872 /* Return a newly constructed STRING_CST node whose value is
1873 the LEN characters at STR.
1874 Note that for a C string literal, LEN should include the trailing NUL.
1875 The TREE_TYPE is not initialized. */
1878 build_string (int len
, const char *str
)
1883 /* Do not waste bytes provided by padding of struct tree_string. */
1884 length
= len
+ offsetof (struct tree_string
, str
) + 1;
1886 record_node_allocation_statistics (STRING_CST
, length
);
1888 s
= (tree
) ggc_internal_alloc (length
);
1890 memset (s
, 0, sizeof (struct tree_typed
));
1891 TREE_SET_CODE (s
, STRING_CST
);
1892 TREE_CONSTANT (s
) = 1;
1893 TREE_STRING_LENGTH (s
) = len
;
1894 memcpy (s
->string
.str
, str
, len
);
1895 s
->string
.str
[len
] = '\0';
1900 /* Return a newly constructed COMPLEX_CST node whose value is
1901 specified by the real and imaginary parts REAL and IMAG.
1902 Both REAL and IMAG should be constant nodes. TYPE, if specified,
1903 will be the type of the COMPLEX_CST; otherwise a new type will be made. */
1906 build_complex (tree type
, tree real
, tree imag
)
1908 tree t
= make_node (COMPLEX_CST
);
1910 TREE_REALPART (t
) = real
;
1911 TREE_IMAGPART (t
) = imag
;
1912 TREE_TYPE (t
) = type
? type
: build_complex_type (TREE_TYPE (real
));
1913 TREE_OVERFLOW (t
) = TREE_OVERFLOW (real
) | TREE_OVERFLOW (imag
);
1917 /* Return a constant of arithmetic type TYPE which is the
1918 multiplicative identity of the set TYPE. */
1921 build_one_cst (tree type
)
1923 switch (TREE_CODE (type
))
1925 case INTEGER_TYPE
: case ENUMERAL_TYPE
: case BOOLEAN_TYPE
:
1926 case POINTER_TYPE
: case REFERENCE_TYPE
:
1928 return build_int_cst (type
, 1);
1931 return build_real (type
, dconst1
);
1933 case FIXED_POINT_TYPE
:
1934 /* We can only generate 1 for accum types. */
1935 gcc_assert (ALL_SCALAR_ACCUM_MODE_P (TYPE_MODE (type
)));
1936 return build_fixed (type
, FCONST1 (TYPE_MODE (type
)));
1940 tree scalar
= build_one_cst (TREE_TYPE (type
));
1942 return build_vector_from_val (type
, scalar
);
1946 return build_complex (type
,
1947 build_one_cst (TREE_TYPE (type
)),
1948 build_zero_cst (TREE_TYPE (type
)));
1955 /* Return an integer of type TYPE containing all 1's in as much precision as
1956 it contains, or a complex or vector whose subparts are such integers. */
1959 build_all_ones_cst (tree type
)
1961 if (TREE_CODE (type
) == COMPLEX_TYPE
)
1963 tree scalar
= build_all_ones_cst (TREE_TYPE (type
));
1964 return build_complex (type
, scalar
, scalar
);
1967 return build_minus_one_cst (type
);
1970 /* Return a constant of arithmetic type TYPE which is the
1971 opposite of the multiplicative identity of the set TYPE. */
1974 build_minus_one_cst (tree type
)
1976 switch (TREE_CODE (type
))
1978 case INTEGER_TYPE
: case ENUMERAL_TYPE
: case BOOLEAN_TYPE
:
1979 case POINTER_TYPE
: case REFERENCE_TYPE
:
1981 return build_int_cst (type
, -1);
1984 return build_real (type
, dconstm1
);
1986 case FIXED_POINT_TYPE
:
1987 /* We can only generate 1 for accum types. */
1988 gcc_assert (ALL_SCALAR_ACCUM_MODE_P (TYPE_MODE (type
)));
1989 return build_fixed (type
, fixed_from_double_int (double_int_minus_one
,
1994 tree scalar
= build_minus_one_cst (TREE_TYPE (type
));
1996 return build_vector_from_val (type
, scalar
);
2000 return build_complex (type
,
2001 build_minus_one_cst (TREE_TYPE (type
)),
2002 build_zero_cst (TREE_TYPE (type
)));
2009 /* Build 0 constant of type TYPE. This is used by constructor folding
2010 and thus the constant should be represented in memory by
2014 build_zero_cst (tree type
)
2016 switch (TREE_CODE (type
))
2018 case INTEGER_TYPE
: case ENUMERAL_TYPE
: case BOOLEAN_TYPE
:
2019 case POINTER_TYPE
: case REFERENCE_TYPE
:
2020 case OFFSET_TYPE
: case NULLPTR_TYPE
:
2021 return build_int_cst (type
, 0);
2024 return build_real (type
, dconst0
);
2026 case FIXED_POINT_TYPE
:
2027 return build_fixed (type
, FCONST0 (TYPE_MODE (type
)));
2031 tree scalar
= build_zero_cst (TREE_TYPE (type
));
2033 return build_vector_from_val (type
, scalar
);
2038 tree zero
= build_zero_cst (TREE_TYPE (type
));
2040 return build_complex (type
, zero
, zero
);
2044 if (!AGGREGATE_TYPE_P (type
))
2045 return fold_convert (type
, integer_zero_node
);
2046 return build_constructor (type
, NULL
);
2051 /* Build a BINFO with LEN language slots. */
2054 make_tree_binfo_stat (unsigned base_binfos MEM_STAT_DECL
)
2057 size_t length
= (offsetof (struct tree_binfo
, base_binfos
)
2058 + vec
<tree
, va_gc
>::embedded_size (base_binfos
));
2060 record_node_allocation_statistics (TREE_BINFO
, length
);
2062 t
= ggc_alloc_tree_node_stat (length PASS_MEM_STAT
);
2064 memset (t
, 0, offsetof (struct tree_binfo
, base_binfos
));
2066 TREE_SET_CODE (t
, TREE_BINFO
);
2068 BINFO_BASE_BINFOS (t
)->embedded_init (base_binfos
);
2073 /* Create a CASE_LABEL_EXPR tree node and return it. */
2076 build_case_label (tree low_value
, tree high_value
, tree label_decl
)
2078 tree t
= make_node (CASE_LABEL_EXPR
);
2080 TREE_TYPE (t
) = void_type_node
;
2081 SET_EXPR_LOCATION (t
, DECL_SOURCE_LOCATION (label_decl
));
2083 CASE_LOW (t
) = low_value
;
2084 CASE_HIGH (t
) = high_value
;
2085 CASE_LABEL (t
) = label_decl
;
2086 CASE_CHAIN (t
) = NULL_TREE
;
2091 /* Build a newly constructed INTEGER_CST node. LEN and EXT_LEN are the
2092 values of TREE_INT_CST_NUNITS and TREE_INT_CST_EXT_NUNITS respectively.
2093 The latter determines the length of the HOST_WIDE_INT vector. */
2096 make_int_cst_stat (int len
, int ext_len MEM_STAT_DECL
)
2099 int length
= ((ext_len
- 1) * sizeof (HOST_WIDE_INT
)
2100 + sizeof (struct tree_int_cst
));
2103 record_node_allocation_statistics (INTEGER_CST
, length
);
2105 t
= ggc_alloc_cleared_tree_node_stat (length PASS_MEM_STAT
);
2107 TREE_SET_CODE (t
, INTEGER_CST
);
2108 TREE_INT_CST_NUNITS (t
) = len
;
2109 TREE_INT_CST_EXT_NUNITS (t
) = ext_len
;
2110 /* to_offset can only be applied to trees that are offset_int-sized
2111 or smaller. EXT_LEN is correct if it fits, otherwise the constant
2112 must be exactly the precision of offset_int and so LEN is correct. */
2113 if (ext_len
<= OFFSET_INT_ELTS
)
2114 TREE_INT_CST_OFFSET_NUNITS (t
) = ext_len
;
2116 TREE_INT_CST_OFFSET_NUNITS (t
) = len
;
2118 TREE_CONSTANT (t
) = 1;
2123 /* Build a newly constructed TREE_VEC node of length LEN. */
2126 make_tree_vec_stat (int len MEM_STAT_DECL
)
2129 int length
= (len
- 1) * sizeof (tree
) + sizeof (struct tree_vec
);
2131 record_node_allocation_statistics (TREE_VEC
, length
);
2133 t
= ggc_alloc_cleared_tree_node_stat (length PASS_MEM_STAT
);
2135 TREE_SET_CODE (t
, TREE_VEC
);
2136 TREE_VEC_LENGTH (t
) = len
;
2141 /* Grow a TREE_VEC node to new length LEN. */
2144 grow_tree_vec_stat (tree v
, int len MEM_STAT_DECL
)
2146 gcc_assert (TREE_CODE (v
) == TREE_VEC
);
2148 int oldlen
= TREE_VEC_LENGTH (v
);
2149 gcc_assert (len
> oldlen
);
2151 int oldlength
= (oldlen
- 1) * sizeof (tree
) + sizeof (struct tree_vec
);
2152 int length
= (len
- 1) * sizeof (tree
) + sizeof (struct tree_vec
);
2154 record_node_allocation_statistics (TREE_VEC
, length
- oldlength
);
2156 v
= (tree
) ggc_realloc (v
, length PASS_MEM_STAT
);
2158 TREE_VEC_LENGTH (v
) = len
;
2163 /* Return 1 if EXPR is the integer constant zero or a complex constant
2167 integer_zerop (const_tree expr
)
2171 switch (TREE_CODE (expr
))
2174 return wi::eq_p (expr
, 0);
2176 return (integer_zerop (TREE_REALPART (expr
))
2177 && integer_zerop (TREE_IMAGPART (expr
)));
2181 for (i
= 0; i
< VECTOR_CST_NELTS (expr
); ++i
)
2182 if (!integer_zerop (VECTOR_CST_ELT (expr
, i
)))
2191 /* Return 1 if EXPR is the integer constant one or the corresponding
2192 complex constant. */
2195 integer_onep (const_tree expr
)
2199 switch (TREE_CODE (expr
))
2202 return wi::eq_p (wi::to_widest (expr
), 1);
2204 return (integer_onep (TREE_REALPART (expr
))
2205 && integer_zerop (TREE_IMAGPART (expr
)));
2209 for (i
= 0; i
< VECTOR_CST_NELTS (expr
); ++i
)
2210 if (!integer_onep (VECTOR_CST_ELT (expr
, i
)))
2219 /* Return 1 if EXPR is the integer constant one. For complex and vector,
2220 return 1 if every piece is the integer constant one. */
2223 integer_each_onep (const_tree expr
)
2227 if (TREE_CODE (expr
) == COMPLEX_CST
)
2228 return (integer_onep (TREE_REALPART (expr
))
2229 && integer_onep (TREE_IMAGPART (expr
)));
2231 return integer_onep (expr
);
2234 /* Return 1 if EXPR is an integer containing all 1's in as much precision as
2235 it contains, or a complex or vector whose subparts are such integers. */
2238 integer_all_onesp (const_tree expr
)
2242 if (TREE_CODE (expr
) == COMPLEX_CST
2243 && integer_all_onesp (TREE_REALPART (expr
))
2244 && integer_all_onesp (TREE_IMAGPART (expr
)))
2247 else if (TREE_CODE (expr
) == VECTOR_CST
)
2250 for (i
= 0; i
< VECTOR_CST_NELTS (expr
); ++i
)
2251 if (!integer_all_onesp (VECTOR_CST_ELT (expr
, i
)))
2256 else if (TREE_CODE (expr
) != INTEGER_CST
)
2259 return wi::max_value (TYPE_PRECISION (TREE_TYPE (expr
)), UNSIGNED
) == expr
;
2262 /* Return 1 if EXPR is the integer constant minus one. */
2265 integer_minus_onep (const_tree expr
)
2269 if (TREE_CODE (expr
) == COMPLEX_CST
)
2270 return (integer_all_onesp (TREE_REALPART (expr
))
2271 && integer_zerop (TREE_IMAGPART (expr
)));
2273 return integer_all_onesp (expr
);
2276 /* Return 1 if EXPR is an integer constant that is a power of 2 (i.e., has only
2280 integer_pow2p (const_tree expr
)
2284 if (TREE_CODE (expr
) == COMPLEX_CST
2285 && integer_pow2p (TREE_REALPART (expr
))
2286 && integer_zerop (TREE_IMAGPART (expr
)))
2289 if (TREE_CODE (expr
) != INTEGER_CST
)
2292 return wi::popcount (expr
) == 1;
2295 /* Return 1 if EXPR is an integer constant other than zero or a
2296 complex constant other than zero. */
2299 integer_nonzerop (const_tree expr
)
2303 return ((TREE_CODE (expr
) == INTEGER_CST
2304 && !wi::eq_p (expr
, 0))
2305 || (TREE_CODE (expr
) == COMPLEX_CST
2306 && (integer_nonzerop (TREE_REALPART (expr
))
2307 || integer_nonzerop (TREE_IMAGPART (expr
)))));
2310 /* Return 1 if EXPR is the integer constant one. For vector,
2311 return 1 if every piece is the integer constant minus one
2312 (representing the value TRUE). */
2315 integer_truep (const_tree expr
)
2319 if (TREE_CODE (expr
) == VECTOR_CST
)
2320 return integer_all_onesp (expr
);
2321 return integer_onep (expr
);
2324 /* Return 1 if EXPR is the fixed-point constant zero. */
2327 fixed_zerop (const_tree expr
)
2329 return (TREE_CODE (expr
) == FIXED_CST
2330 && TREE_FIXED_CST (expr
).data
.is_zero ());
2333 /* Return the power of two represented by a tree node known to be a
2337 tree_log2 (const_tree expr
)
2341 if (TREE_CODE (expr
) == COMPLEX_CST
)
2342 return tree_log2 (TREE_REALPART (expr
));
2344 return wi::exact_log2 (expr
);
2347 /* Similar, but return the largest integer Y such that 2 ** Y is less
2348 than or equal to EXPR. */
2351 tree_floor_log2 (const_tree expr
)
2355 if (TREE_CODE (expr
) == COMPLEX_CST
)
2356 return tree_log2 (TREE_REALPART (expr
));
2358 return wi::floor_log2 (expr
);
2361 /* Return number of known trailing zero bits in EXPR, or, if the value of
2362 EXPR is known to be zero, the precision of it's type. */
2365 tree_ctz (const_tree expr
)
2367 if (!INTEGRAL_TYPE_P (TREE_TYPE (expr
))
2368 && !POINTER_TYPE_P (TREE_TYPE (expr
)))
2371 unsigned int ret1
, ret2
, prec
= TYPE_PRECISION (TREE_TYPE (expr
));
2372 switch (TREE_CODE (expr
))
2375 ret1
= wi::ctz (expr
);
2376 return MIN (ret1
, prec
);
2378 ret1
= wi::ctz (get_nonzero_bits (expr
));
2379 return MIN (ret1
, prec
);
2386 ret1
= tree_ctz (TREE_OPERAND (expr
, 0));
2389 ret2
= tree_ctz (TREE_OPERAND (expr
, 1));
2390 return MIN (ret1
, ret2
);
2391 case POINTER_PLUS_EXPR
:
2392 ret1
= tree_ctz (TREE_OPERAND (expr
, 0));
2393 ret2
= tree_ctz (TREE_OPERAND (expr
, 1));
2394 /* Second operand is sizetype, which could be in theory
2395 wider than pointer's precision. Make sure we never
2396 return more than prec. */
2397 ret2
= MIN (ret2
, prec
);
2398 return MIN (ret1
, ret2
);
2400 ret1
= tree_ctz (TREE_OPERAND (expr
, 0));
2401 ret2
= tree_ctz (TREE_OPERAND (expr
, 1));
2402 return MAX (ret1
, ret2
);
2404 ret1
= tree_ctz (TREE_OPERAND (expr
, 0));
2405 ret2
= tree_ctz (TREE_OPERAND (expr
, 1));
2406 return MIN (ret1
+ ret2
, prec
);
2408 ret1
= tree_ctz (TREE_OPERAND (expr
, 0));
2409 if (tree_fits_uhwi_p (TREE_OPERAND (expr
, 1))
2410 && (tree_to_uhwi (TREE_OPERAND (expr
, 1)) < prec
))
2412 ret2
= tree_to_uhwi (TREE_OPERAND (expr
, 1));
2413 return MIN (ret1
+ ret2
, prec
);
2417 if (tree_fits_uhwi_p (TREE_OPERAND (expr
, 1))
2418 && (tree_to_uhwi (TREE_OPERAND (expr
, 1)) < prec
))
2420 ret1
= tree_ctz (TREE_OPERAND (expr
, 0));
2421 ret2
= tree_to_uhwi (TREE_OPERAND (expr
, 1));
2426 case TRUNC_DIV_EXPR
:
2428 case FLOOR_DIV_EXPR
:
2429 case ROUND_DIV_EXPR
:
2430 case EXACT_DIV_EXPR
:
2431 if (TREE_CODE (TREE_OPERAND (expr
, 1)) == INTEGER_CST
2432 && tree_int_cst_sgn (TREE_OPERAND (expr
, 1)) == 1)
2434 int l
= tree_log2 (TREE_OPERAND (expr
, 1));
2437 ret1
= tree_ctz (TREE_OPERAND (expr
, 0));
2445 ret1
= tree_ctz (TREE_OPERAND (expr
, 0));
2446 if (ret1
&& ret1
== TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (expr
, 0))))
2448 return MIN (ret1
, prec
);
2450 return tree_ctz (TREE_OPERAND (expr
, 0));
2452 ret1
= tree_ctz (TREE_OPERAND (expr
, 1));
2455 ret2
= tree_ctz (TREE_OPERAND (expr
, 2));
2456 return MIN (ret1
, ret2
);
2458 return tree_ctz (TREE_OPERAND (expr
, 1));
2460 ret1
= get_pointer_alignment (CONST_CAST_TREE (expr
));
2461 if (ret1
> BITS_PER_UNIT
)
2463 ret1
= ctz_hwi (ret1
/ BITS_PER_UNIT
);
2464 return MIN (ret1
, prec
);
2472 /* Return 1 if EXPR is the real constant zero. Trailing zeroes matter for
2473 decimal float constants, so don't return 1 for them. */
2476 real_zerop (const_tree expr
)
2480 switch (TREE_CODE (expr
))
2483 return REAL_VALUES_EQUAL (TREE_REAL_CST (expr
), dconst0
)
2484 && !(DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (expr
))));
2486 return real_zerop (TREE_REALPART (expr
))
2487 && real_zerop (TREE_IMAGPART (expr
));
2491 for (i
= 0; i
< VECTOR_CST_NELTS (expr
); ++i
)
2492 if (!real_zerop (VECTOR_CST_ELT (expr
, i
)))
2501 /* Return 1 if EXPR is the real constant one in real or complex form.
2502 Trailing zeroes matter for decimal float constants, so don't return
2506 real_onep (const_tree expr
)
2510 switch (TREE_CODE (expr
))
2513 return REAL_VALUES_EQUAL (TREE_REAL_CST (expr
), dconst1
)
2514 && !(DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (expr
))));
2516 return real_onep (TREE_REALPART (expr
))
2517 && real_zerop (TREE_IMAGPART (expr
));
2521 for (i
= 0; i
< VECTOR_CST_NELTS (expr
); ++i
)
2522 if (!real_onep (VECTOR_CST_ELT (expr
, i
)))
2531 /* Return 1 if EXPR is the real constant minus one. Trailing zeroes
2532 matter for decimal float constants, so don't return 1 for them. */
2535 real_minus_onep (const_tree expr
)
2539 switch (TREE_CODE (expr
))
2542 return REAL_VALUES_EQUAL (TREE_REAL_CST (expr
), dconstm1
)
2543 && !(DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (expr
))));
2545 return real_minus_onep (TREE_REALPART (expr
))
2546 && real_zerop (TREE_IMAGPART (expr
));
2550 for (i
= 0; i
< VECTOR_CST_NELTS (expr
); ++i
)
2551 if (!real_minus_onep (VECTOR_CST_ELT (expr
, i
)))
2560 /* Nonzero if EXP is a constant or a cast of a constant. */
2563 really_constant_p (const_tree exp
)
2565 /* This is not quite the same as STRIP_NOPS. It does more. */
2566 while (CONVERT_EXPR_P (exp
)
2567 || TREE_CODE (exp
) == NON_LVALUE_EXPR
)
2568 exp
= TREE_OPERAND (exp
, 0);
2569 return TREE_CONSTANT (exp
);
2572 /* Return first list element whose TREE_VALUE is ELEM.
2573 Return 0 if ELEM is not in LIST. */
2576 value_member (tree elem
, tree list
)
2580 if (elem
== TREE_VALUE (list
))
2582 list
= TREE_CHAIN (list
);
2587 /* Return first list element whose TREE_PURPOSE is ELEM.
2588 Return 0 if ELEM is not in LIST. */
2591 purpose_member (const_tree elem
, tree list
)
2595 if (elem
== TREE_PURPOSE (list
))
2597 list
= TREE_CHAIN (list
);
2602 /* Return true if ELEM is in V. */
2605 vec_member (const_tree elem
, vec
<tree
, va_gc
> *v
)
2609 FOR_EACH_VEC_SAFE_ELT (v
, ix
, t
)
2615 /* Returns element number IDX (zero-origin) of chain CHAIN, or
2619 chain_index (int idx
, tree chain
)
2621 for (; chain
&& idx
> 0; --idx
)
2622 chain
= TREE_CHAIN (chain
);
2626 /* Return nonzero if ELEM is part of the chain CHAIN. */
2629 chain_member (const_tree elem
, const_tree chain
)
2635 chain
= DECL_CHAIN (chain
);
2641 /* Return the length of a chain of nodes chained through TREE_CHAIN.
2642 We expect a null pointer to mark the end of the chain.
2643 This is the Lisp primitive `length'. */
2646 list_length (const_tree t
)
2649 #ifdef ENABLE_TREE_CHECKING
2657 #ifdef ENABLE_TREE_CHECKING
2660 gcc_assert (p
!= q
);
2668 /* Returns the first FIELD_DECL in the TYPE_FIELDS of the RECORD_TYPE or
2669 UNION_TYPE TYPE, or NULL_TREE if none. */
2672 first_field (const_tree type
)
2674 tree t
= TYPE_FIELDS (type
);
2675 while (t
&& TREE_CODE (t
) != FIELD_DECL
)
2680 /* Concatenate two chains of nodes (chained through TREE_CHAIN)
2681 by modifying the last node in chain 1 to point to chain 2.
2682 This is the Lisp primitive `nconc'. */
2685 chainon (tree op1
, tree op2
)
2694 for (t1
= op1
; TREE_CHAIN (t1
); t1
= TREE_CHAIN (t1
))
2696 TREE_CHAIN (t1
) = op2
;
2698 #ifdef ENABLE_TREE_CHECKING
2701 for (t2
= op2
; t2
; t2
= TREE_CHAIN (t2
))
2702 gcc_assert (t2
!= t1
);
2709 /* Return the last node in a chain of nodes (chained through TREE_CHAIN). */
2712 tree_last (tree chain
)
2716 while ((next
= TREE_CHAIN (chain
)))
2721 /* Reverse the order of elements in the chain T,
2722 and return the new head of the chain (old last element). */
2727 tree prev
= 0, decl
, next
;
2728 for (decl
= t
; decl
; decl
= next
)
2730 /* We shouldn't be using this function to reverse BLOCK chains; we
2731 have blocks_nreverse for that. */
2732 gcc_checking_assert (TREE_CODE (decl
) != BLOCK
);
2733 next
= TREE_CHAIN (decl
);
2734 TREE_CHAIN (decl
) = prev
;
2740 /* Return a newly created TREE_LIST node whose
2741 purpose and value fields are PARM and VALUE. */
2744 build_tree_list_stat (tree parm
, tree value MEM_STAT_DECL
)
2746 tree t
= make_node_stat (TREE_LIST PASS_MEM_STAT
);
2747 TREE_PURPOSE (t
) = parm
;
2748 TREE_VALUE (t
) = value
;
2752 /* Build a chain of TREE_LIST nodes from a vector. */
2755 build_tree_list_vec_stat (const vec
<tree
, va_gc
> *vec MEM_STAT_DECL
)
2757 tree ret
= NULL_TREE
;
2761 FOR_EACH_VEC_SAFE_ELT (vec
, i
, t
)
2763 *pp
= build_tree_list_stat (NULL
, t PASS_MEM_STAT
);
2764 pp
= &TREE_CHAIN (*pp
);
2769 /* Return a newly created TREE_LIST node whose
2770 purpose and value fields are PURPOSE and VALUE
2771 and whose TREE_CHAIN is CHAIN. */
2774 tree_cons_stat (tree purpose
, tree value
, tree chain MEM_STAT_DECL
)
2778 node
= ggc_alloc_tree_node_stat (sizeof (struct tree_list
) PASS_MEM_STAT
);
2779 memset (node
, 0, sizeof (struct tree_common
));
2781 record_node_allocation_statistics (TREE_LIST
, sizeof (struct tree_list
));
2783 TREE_SET_CODE (node
, TREE_LIST
);
2784 TREE_CHAIN (node
) = chain
;
2785 TREE_PURPOSE (node
) = purpose
;
2786 TREE_VALUE (node
) = value
;
2790 /* Return the values of the elements of a CONSTRUCTOR as a vector of
2794 ctor_to_vec (tree ctor
)
2796 vec
<tree
, va_gc
> *vec
;
2797 vec_alloc (vec
, CONSTRUCTOR_NELTS (ctor
));
2801 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (ctor
), ix
, val
)
2802 vec
->quick_push (val
);
2807 /* Return the size nominally occupied by an object of type TYPE
2808 when it resides in memory. The value is measured in units of bytes,
2809 and its data type is that normally used for type sizes
2810 (which is the first type created by make_signed_type or
2811 make_unsigned_type). */
2814 size_in_bytes (const_tree type
)
2818 if (type
== error_mark_node
)
2819 return integer_zero_node
;
2821 type
= TYPE_MAIN_VARIANT (type
);
2822 t
= TYPE_SIZE_UNIT (type
);
2826 lang_hooks
.types
.incomplete_type_error (NULL_TREE
, type
);
2827 return size_zero_node
;
2833 /* Return the size of TYPE (in bytes) as a wide integer
2834 or return -1 if the size can vary or is larger than an integer. */
2837 int_size_in_bytes (const_tree type
)
2841 if (type
== error_mark_node
)
2844 type
= TYPE_MAIN_VARIANT (type
);
2845 t
= TYPE_SIZE_UNIT (type
);
2847 if (t
&& tree_fits_uhwi_p (t
))
2848 return TREE_INT_CST_LOW (t
);
2853 /* Return the maximum size of TYPE (in bytes) as a wide integer
2854 or return -1 if the size can vary or is larger than an integer. */
2857 max_int_size_in_bytes (const_tree type
)
2859 HOST_WIDE_INT size
= -1;
2862 /* If this is an array type, check for a possible MAX_SIZE attached. */
2864 if (TREE_CODE (type
) == ARRAY_TYPE
)
2866 size_tree
= TYPE_ARRAY_MAX_SIZE (type
);
2868 if (size_tree
&& tree_fits_uhwi_p (size_tree
))
2869 size
= tree_to_uhwi (size_tree
);
2872 /* If we still haven't been able to get a size, see if the language
2873 can compute a maximum size. */
2877 size_tree
= lang_hooks
.types
.max_size (type
);
2879 if (size_tree
&& tree_fits_uhwi_p (size_tree
))
2880 size
= tree_to_uhwi (size_tree
);
2886 /* Return the bit position of FIELD, in bits from the start of the record.
2887 This is a tree of type bitsizetype. */
2890 bit_position (const_tree field
)
2892 return bit_from_pos (DECL_FIELD_OFFSET (field
),
2893 DECL_FIELD_BIT_OFFSET (field
));
2896 /* Return the byte position of FIELD, in bytes from the start of the record.
2897 This is a tree of type sizetype. */
2900 byte_position (const_tree field
)
2902 return byte_from_pos (DECL_FIELD_OFFSET (field
),
2903 DECL_FIELD_BIT_OFFSET (field
));
2906 /* Likewise, but return as an integer. It must be representable in
2907 that way (since it could be a signed value, we don't have the
2908 option of returning -1 like int_size_in_byte can. */
2911 int_byte_position (const_tree field
)
2913 return tree_to_shwi (byte_position (field
));
2916 /* Return the strictest alignment, in bits, that T is known to have. */
2919 expr_align (const_tree t
)
2921 unsigned int align0
, align1
;
2923 switch (TREE_CODE (t
))
2925 CASE_CONVERT
: case NON_LVALUE_EXPR
:
2926 /* If we have conversions, we know that the alignment of the
2927 object must meet each of the alignments of the types. */
2928 align0
= expr_align (TREE_OPERAND (t
, 0));
2929 align1
= TYPE_ALIGN (TREE_TYPE (t
));
2930 return MAX (align0
, align1
);
2932 case SAVE_EXPR
: case COMPOUND_EXPR
: case MODIFY_EXPR
:
2933 case INIT_EXPR
: case TARGET_EXPR
: case WITH_CLEANUP_EXPR
:
2934 case CLEANUP_POINT_EXPR
:
2935 /* These don't change the alignment of an object. */
2936 return expr_align (TREE_OPERAND (t
, 0));
2939 /* The best we can do is say that the alignment is the least aligned
2941 align0
= expr_align (TREE_OPERAND (t
, 1));
2942 align1
= expr_align (TREE_OPERAND (t
, 2));
2943 return MIN (align0
, align1
);
2945 /* FIXME: LABEL_DECL and CONST_DECL never have DECL_ALIGN set
2946 meaningfully, it's always 1. */
2947 case LABEL_DECL
: case CONST_DECL
:
2948 case VAR_DECL
: case PARM_DECL
: case RESULT_DECL
:
2950 gcc_assert (DECL_ALIGN (t
) != 0);
2951 return DECL_ALIGN (t
);
2957 /* Otherwise take the alignment from that of the type. */
2958 return TYPE_ALIGN (TREE_TYPE (t
));
2961 /* Return, as a tree node, the number of elements for TYPE (which is an
2962 ARRAY_TYPE) minus one. This counts only elements of the top array. */
2965 array_type_nelts (const_tree type
)
2967 tree index_type
, min
, max
;
2969 /* If they did it with unspecified bounds, then we should have already
2970 given an error about it before we got here. */
2971 if (! TYPE_DOMAIN (type
))
2972 return error_mark_node
;
2974 index_type
= TYPE_DOMAIN (type
);
2975 min
= TYPE_MIN_VALUE (index_type
);
2976 max
= TYPE_MAX_VALUE (index_type
);
2978 /* TYPE_MAX_VALUE may not be set if the array has unknown length. */
2980 return error_mark_node
;
2982 return (integer_zerop (min
)
2984 : fold_build2 (MINUS_EXPR
, TREE_TYPE (max
), max
, min
));
2987 /* If arg is static -- a reference to an object in static storage -- then
2988 return the object. This is not the same as the C meaning of `static'.
2989 If arg isn't static, return NULL. */
2994 switch (TREE_CODE (arg
))
2997 /* Nested functions are static, even though taking their address will
2998 involve a trampoline as we unnest the nested function and create
2999 the trampoline on the tree level. */
3003 return ((TREE_STATIC (arg
) || DECL_EXTERNAL (arg
))
3004 && ! DECL_THREAD_LOCAL_P (arg
)
3005 && ! DECL_DLLIMPORT_P (arg
)
3009 return ((TREE_STATIC (arg
) || DECL_EXTERNAL (arg
))
3013 return TREE_STATIC (arg
) ? arg
: NULL
;
3020 /* If the thing being referenced is not a field, then it is
3021 something language specific. */
3022 gcc_assert (TREE_CODE (TREE_OPERAND (arg
, 1)) == FIELD_DECL
);
3024 /* If we are referencing a bitfield, we can't evaluate an
3025 ADDR_EXPR at compile time and so it isn't a constant. */
3026 if (DECL_BIT_FIELD (TREE_OPERAND (arg
, 1)))
3029 return staticp (TREE_OPERAND (arg
, 0));
3035 return TREE_CONSTANT (TREE_OPERAND (arg
, 0)) ? arg
: NULL
;
3038 case ARRAY_RANGE_REF
:
3039 if (TREE_CODE (TYPE_SIZE (TREE_TYPE (arg
))) == INTEGER_CST
3040 && TREE_CODE (TREE_OPERAND (arg
, 1)) == INTEGER_CST
)
3041 return staticp (TREE_OPERAND (arg
, 0));
3045 case COMPOUND_LITERAL_EXPR
:
3046 return TREE_STATIC (COMPOUND_LITERAL_EXPR_DECL (arg
)) ? arg
: NULL
;
3056 /* Return whether OP is a DECL whose address is function-invariant. */
3059 decl_address_invariant_p (const_tree op
)
3061 /* The conditions below are slightly less strict than the one in
3064 switch (TREE_CODE (op
))
3073 if ((TREE_STATIC (op
) || DECL_EXTERNAL (op
))
3074 || DECL_THREAD_LOCAL_P (op
)
3075 || DECL_CONTEXT (op
) == current_function_decl
3076 || decl_function_context (op
) == current_function_decl
)
3081 if ((TREE_STATIC (op
) || DECL_EXTERNAL (op
))
3082 || decl_function_context (op
) == current_function_decl
)
3093 /* Return whether OP is a DECL whose address is interprocedural-invariant. */
3096 decl_address_ip_invariant_p (const_tree op
)
3098 /* The conditions below are slightly less strict than the one in
3101 switch (TREE_CODE (op
))
3109 if (((TREE_STATIC (op
) || DECL_EXTERNAL (op
))
3110 && !DECL_DLLIMPORT_P (op
))
3111 || DECL_THREAD_LOCAL_P (op
))
3116 if ((TREE_STATIC (op
) || DECL_EXTERNAL (op
)))
3128 /* Return true if T is function-invariant (internal function, does
3129 not handle arithmetic; that's handled in skip_simple_arithmetic and
3130 tree_invariant_p). */
3132 static bool tree_invariant_p (tree t
);
3135 tree_invariant_p_1 (tree t
)
3139 if (TREE_CONSTANT (t
)
3140 || (TREE_READONLY (t
) && !TREE_SIDE_EFFECTS (t
)))
3143 switch (TREE_CODE (t
))
3149 op
= TREE_OPERAND (t
, 0);
3150 while (handled_component_p (op
))
3152 switch (TREE_CODE (op
))
3155 case ARRAY_RANGE_REF
:
3156 if (!tree_invariant_p (TREE_OPERAND (op
, 1))
3157 || TREE_OPERAND (op
, 2) != NULL_TREE
3158 || TREE_OPERAND (op
, 3) != NULL_TREE
)
3163 if (TREE_OPERAND (op
, 2) != NULL_TREE
)
3169 op
= TREE_OPERAND (op
, 0);
3172 return CONSTANT_CLASS_P (op
) || decl_address_invariant_p (op
);
3181 /* Return true if T is function-invariant. */
3184 tree_invariant_p (tree t
)
3186 tree inner
= skip_simple_arithmetic (t
);
3187 return tree_invariant_p_1 (inner
);
3190 /* Wrap a SAVE_EXPR around EXPR, if appropriate.
3191 Do this to any expression which may be used in more than one place,
3192 but must be evaluated only once.
3194 Normally, expand_expr would reevaluate the expression each time.
3195 Calling save_expr produces something that is evaluated and recorded
3196 the first time expand_expr is called on it. Subsequent calls to
3197 expand_expr just reuse the recorded value.
3199 The call to expand_expr that generates code that actually computes
3200 the value is the first call *at compile time*. Subsequent calls
3201 *at compile time* generate code to use the saved value.
3202 This produces correct result provided that *at run time* control
3203 always flows through the insns made by the first expand_expr
3204 before reaching the other places where the save_expr was evaluated.
3205 You, the caller of save_expr, must make sure this is so.
3207 Constants, and certain read-only nodes, are returned with no
3208 SAVE_EXPR because that is safe. Expressions containing placeholders
3209 are not touched; see tree.def for an explanation of what these
3213 save_expr (tree expr
)
3215 tree t
= fold (expr
);
3218 /* If the tree evaluates to a constant, then we don't want to hide that
3219 fact (i.e. this allows further folding, and direct checks for constants).
3220 However, a read-only object that has side effects cannot be bypassed.
3221 Since it is no problem to reevaluate literals, we just return the
3223 inner
= skip_simple_arithmetic (t
);
3224 if (TREE_CODE (inner
) == ERROR_MARK
)
3227 if (tree_invariant_p_1 (inner
))
3230 /* If INNER contains a PLACEHOLDER_EXPR, we must evaluate it each time, since
3231 it means that the size or offset of some field of an object depends on
3232 the value within another field.
3234 Note that it must not be the case that T contains both a PLACEHOLDER_EXPR
3235 and some variable since it would then need to be both evaluated once and
3236 evaluated more than once. Front-ends must assure this case cannot
3237 happen by surrounding any such subexpressions in their own SAVE_EXPR
3238 and forcing evaluation at the proper time. */
3239 if (contains_placeholder_p (inner
))
3242 t
= build1 (SAVE_EXPR
, TREE_TYPE (expr
), t
);
3243 SET_EXPR_LOCATION (t
, EXPR_LOCATION (expr
));
3245 /* This expression might be placed ahead of a jump to ensure that the
3246 value was computed on both sides of the jump. So make sure it isn't
3247 eliminated as dead. */
3248 TREE_SIDE_EFFECTS (t
) = 1;
3252 /* Look inside EXPR into any simple arithmetic operations. Return the
3253 outermost non-arithmetic or non-invariant node. */
3256 skip_simple_arithmetic (tree expr
)
3258 /* We don't care about whether this can be used as an lvalue in this
3260 while (TREE_CODE (expr
) == NON_LVALUE_EXPR
)
3261 expr
= TREE_OPERAND (expr
, 0);
3263 /* If we have simple operations applied to a SAVE_EXPR or to a SAVE_EXPR and
3264 a constant, it will be more efficient to not make another SAVE_EXPR since
3265 it will allow better simplification and GCSE will be able to merge the
3266 computations if they actually occur. */
3269 if (UNARY_CLASS_P (expr
))
3270 expr
= TREE_OPERAND (expr
, 0);
3271 else if (BINARY_CLASS_P (expr
))
3273 if (tree_invariant_p (TREE_OPERAND (expr
, 1)))
3274 expr
= TREE_OPERAND (expr
, 0);
3275 else if (tree_invariant_p (TREE_OPERAND (expr
, 0)))
3276 expr
= TREE_OPERAND (expr
, 1);
3287 /* Look inside EXPR into simple arithmetic operations involving constants.
3288 Return the outermost non-arithmetic or non-constant node. */
3291 skip_simple_constant_arithmetic (tree expr
)
3293 while (TREE_CODE (expr
) == NON_LVALUE_EXPR
)
3294 expr
= TREE_OPERAND (expr
, 0);
3298 if (UNARY_CLASS_P (expr
))
3299 expr
= TREE_OPERAND (expr
, 0);
3300 else if (BINARY_CLASS_P (expr
))
3302 if (TREE_CONSTANT (TREE_OPERAND (expr
, 1)))
3303 expr
= TREE_OPERAND (expr
, 0);
3304 else if (TREE_CONSTANT (TREE_OPERAND (expr
, 0)))
3305 expr
= TREE_OPERAND (expr
, 1);
3316 /* Return which tree structure is used by T. */
3318 enum tree_node_structure_enum
3319 tree_node_structure (const_tree t
)
3321 const enum tree_code code
= TREE_CODE (t
);
3322 return tree_node_structure_for_code (code
);
3325 /* Set various status flags when building a CALL_EXPR object T. */
3328 process_call_operands (tree t
)
3330 bool side_effects
= TREE_SIDE_EFFECTS (t
);
3331 bool read_only
= false;
3332 int i
= call_expr_flags (t
);
3334 /* Calls have side-effects, except those to const or pure functions. */
3335 if ((i
& ECF_LOOPING_CONST_OR_PURE
) || !(i
& (ECF_CONST
| ECF_PURE
)))
3336 side_effects
= true;
3337 /* Propagate TREE_READONLY of arguments for const functions. */
3341 if (!side_effects
|| read_only
)
3342 for (i
= 1; i
< TREE_OPERAND_LENGTH (t
); i
++)
3344 tree op
= TREE_OPERAND (t
, i
);
3345 if (op
&& TREE_SIDE_EFFECTS (op
))
3346 side_effects
= true;
3347 if (op
&& !TREE_READONLY (op
) && !CONSTANT_CLASS_P (op
))
3351 TREE_SIDE_EFFECTS (t
) = side_effects
;
3352 TREE_READONLY (t
) = read_only
;
3355 /* Return true if EXP contains a PLACEHOLDER_EXPR, i.e. if it represents a
3356 size or offset that depends on a field within a record. */
3359 contains_placeholder_p (const_tree exp
)
3361 enum tree_code code
;
3366 code
= TREE_CODE (exp
);
3367 if (code
== PLACEHOLDER_EXPR
)
3370 switch (TREE_CODE_CLASS (code
))
3373 /* Don't look at any PLACEHOLDER_EXPRs that might be in index or bit
3374 position computations since they will be converted into a
3375 WITH_RECORD_EXPR involving the reference, which will assume
3376 here will be valid. */
3377 return CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp
, 0));
3379 case tcc_exceptional
:
3380 if (code
== TREE_LIST
)
3381 return (CONTAINS_PLACEHOLDER_P (TREE_VALUE (exp
))
3382 || CONTAINS_PLACEHOLDER_P (TREE_CHAIN (exp
)));
3387 case tcc_comparison
:
3388 case tcc_expression
:
3392 /* Ignoring the first operand isn't quite right, but works best. */
3393 return CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp
, 1));
3396 return (CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp
, 0))
3397 || CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp
, 1))
3398 || CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp
, 2)));
3401 /* The save_expr function never wraps anything containing
3402 a PLACEHOLDER_EXPR. */
3409 switch (TREE_CODE_LENGTH (code
))
3412 return CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp
, 0));
3414 return (CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp
, 0))
3415 || CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp
, 1)));
3426 const_call_expr_arg_iterator iter
;
3427 FOR_EACH_CONST_CALL_EXPR_ARG (arg
, iter
, exp
)
3428 if (CONTAINS_PLACEHOLDER_P (arg
))
3442 /* Return true if any part of the structure of TYPE involves a PLACEHOLDER_EXPR
3443 directly. This includes size, bounds, qualifiers (for QUAL_UNION_TYPE) and
3447 type_contains_placeholder_1 (const_tree type
)
3449 /* If the size contains a placeholder or the parent type (component type in
3450 the case of arrays) type involves a placeholder, this type does. */
3451 if (CONTAINS_PLACEHOLDER_P (TYPE_SIZE (type
))
3452 || CONTAINS_PLACEHOLDER_P (TYPE_SIZE_UNIT (type
))
3453 || (!POINTER_TYPE_P (type
)
3455 && type_contains_placeholder_p (TREE_TYPE (type
))))
3458 /* Now do type-specific checks. Note that the last part of the check above
3459 greatly limits what we have to do below. */
3460 switch (TREE_CODE (type
))
3463 case POINTER_BOUNDS_TYPE
:
3469 case REFERENCE_TYPE
:
3478 case FIXED_POINT_TYPE
:
3479 /* Here we just check the bounds. */
3480 return (CONTAINS_PLACEHOLDER_P (TYPE_MIN_VALUE (type
))
3481 || CONTAINS_PLACEHOLDER_P (TYPE_MAX_VALUE (type
)));
3484 /* We have already checked the component type above, so just check the
3486 return type_contains_placeholder_p (TYPE_DOMAIN (type
));
3490 case QUAL_UNION_TYPE
:
3494 for (field
= TYPE_FIELDS (type
); field
; field
= DECL_CHAIN (field
))
3495 if (TREE_CODE (field
) == FIELD_DECL
3496 && (CONTAINS_PLACEHOLDER_P (DECL_FIELD_OFFSET (field
))
3497 || (TREE_CODE (type
) == QUAL_UNION_TYPE
3498 && CONTAINS_PLACEHOLDER_P (DECL_QUALIFIER (field
)))
3499 || type_contains_placeholder_p (TREE_TYPE (field
))))
3510 /* Wrapper around above function used to cache its result. */
3513 type_contains_placeholder_p (tree type
)
3517 /* If the contains_placeholder_bits field has been initialized,
3518 then we know the answer. */
3519 if (TYPE_CONTAINS_PLACEHOLDER_INTERNAL (type
) > 0)
3520 return TYPE_CONTAINS_PLACEHOLDER_INTERNAL (type
) - 1;
3522 /* Indicate that we've seen this type node, and the answer is false.
3523 This is what we want to return if we run into recursion via fields. */
3524 TYPE_CONTAINS_PLACEHOLDER_INTERNAL (type
) = 1;
3526 /* Compute the real value. */
3527 result
= type_contains_placeholder_1 (type
);
3529 /* Store the real value. */
3530 TYPE_CONTAINS_PLACEHOLDER_INTERNAL (type
) = result
+ 1;
3535 /* Push tree EXP onto vector QUEUE if it is not already present. */
3538 push_without_duplicates (tree exp
, vec
<tree
> *queue
)
3543 FOR_EACH_VEC_ELT (*queue
, i
, iter
)
3544 if (simple_cst_equal (iter
, exp
) == 1)
3548 queue
->safe_push (exp
);
3551 /* Given a tree EXP, find all occurrences of references to fields
3552 in a PLACEHOLDER_EXPR and place them in vector REFS without
3553 duplicates. Also record VAR_DECLs and CONST_DECLs. Note that
3554 we assume here that EXP contains only arithmetic expressions
3555 or CALL_EXPRs with PLACEHOLDER_EXPRs occurring only in their
3559 find_placeholder_in_expr (tree exp
, vec
<tree
> *refs
)
3561 enum tree_code code
= TREE_CODE (exp
);
3565 /* We handle TREE_LIST and COMPONENT_REF separately. */
3566 if (code
== TREE_LIST
)
3568 FIND_PLACEHOLDER_IN_EXPR (TREE_CHAIN (exp
), refs
);
3569 FIND_PLACEHOLDER_IN_EXPR (TREE_VALUE (exp
), refs
);
3571 else if (code
== COMPONENT_REF
)
3573 for (inner
= TREE_OPERAND (exp
, 0);
3574 REFERENCE_CLASS_P (inner
);
3575 inner
= TREE_OPERAND (inner
, 0))
3578 if (TREE_CODE (inner
) == PLACEHOLDER_EXPR
)
3579 push_without_duplicates (exp
, refs
);
3581 FIND_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp
, 0), refs
);
3584 switch (TREE_CODE_CLASS (code
))
3589 case tcc_declaration
:
3590 /* Variables allocated to static storage can stay. */
3591 if (!TREE_STATIC (exp
))
3592 push_without_duplicates (exp
, refs
);
3595 case tcc_expression
:
3596 /* This is the pattern built in ada/make_aligning_type. */
3597 if (code
== ADDR_EXPR
3598 && TREE_CODE (TREE_OPERAND (exp
, 0)) == PLACEHOLDER_EXPR
)
3600 push_without_duplicates (exp
, refs
);
3604 /* Fall through... */
3606 case tcc_exceptional
:
3609 case tcc_comparison
:
3611 for (i
= 0; i
< TREE_CODE_LENGTH (code
); i
++)
3612 FIND_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp
, i
), refs
);
3616 for (i
= 1; i
< TREE_OPERAND_LENGTH (exp
); i
++)
3617 FIND_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp
, i
), refs
);
3625 /* Given a tree EXP, a FIELD_DECL F, and a replacement value R,
3626 return a tree with all occurrences of references to F in a
3627 PLACEHOLDER_EXPR replaced by R. Also handle VAR_DECLs and
3628 CONST_DECLs. Note that we assume here that EXP contains only
3629 arithmetic expressions or CALL_EXPRs with PLACEHOLDER_EXPRs
3630 occurring only in their argument list. */
3633 substitute_in_expr (tree exp
, tree f
, tree r
)
3635 enum tree_code code
= TREE_CODE (exp
);
3636 tree op0
, op1
, op2
, op3
;
3639 /* We handle TREE_LIST and COMPONENT_REF separately. */
3640 if (code
== TREE_LIST
)
3642 op0
= SUBSTITUTE_IN_EXPR (TREE_CHAIN (exp
), f
, r
);
3643 op1
= SUBSTITUTE_IN_EXPR (TREE_VALUE (exp
), f
, r
);
3644 if (op0
== TREE_CHAIN (exp
) && op1
== TREE_VALUE (exp
))
3647 return tree_cons (TREE_PURPOSE (exp
), op1
, op0
);
3649 else if (code
== COMPONENT_REF
)
3653 /* If this expression is getting a value from a PLACEHOLDER_EXPR
3654 and it is the right field, replace it with R. */
3655 for (inner
= TREE_OPERAND (exp
, 0);
3656 REFERENCE_CLASS_P (inner
);
3657 inner
= TREE_OPERAND (inner
, 0))
3661 op1
= TREE_OPERAND (exp
, 1);
3663 if (TREE_CODE (inner
) == PLACEHOLDER_EXPR
&& op1
== f
)
3666 /* If this expression hasn't been completed let, leave it alone. */
3667 if (TREE_CODE (inner
) == PLACEHOLDER_EXPR
&& !TREE_TYPE (inner
))
3670 op0
= SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp
, 0), f
, r
);
3671 if (op0
== TREE_OPERAND (exp
, 0))
3675 = fold_build3 (COMPONENT_REF
, TREE_TYPE (exp
), op0
, op1
, NULL_TREE
);
3678 switch (TREE_CODE_CLASS (code
))
3683 case tcc_declaration
:
3689 case tcc_expression
:
3693 /* Fall through... */
3695 case tcc_exceptional
:
3698 case tcc_comparison
:
3700 switch (TREE_CODE_LENGTH (code
))
3706 op0
= SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp
, 0), f
, r
);
3707 if (op0
== TREE_OPERAND (exp
, 0))
3710 new_tree
= fold_build1 (code
, TREE_TYPE (exp
), op0
);
3714 op0
= SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp
, 0), f
, r
);
3715 op1
= SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp
, 1), f
, r
);
3717 if (op0
== TREE_OPERAND (exp
, 0) && op1
== TREE_OPERAND (exp
, 1))
3720 new_tree
= fold_build2 (code
, TREE_TYPE (exp
), op0
, op1
);
3724 op0
= SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp
, 0), f
, r
);
3725 op1
= SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp
, 1), f
, r
);
3726 op2
= SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp
, 2), f
, r
);
3728 if (op0
== TREE_OPERAND (exp
, 0) && op1
== TREE_OPERAND (exp
, 1)
3729 && op2
== TREE_OPERAND (exp
, 2))
3732 new_tree
= fold_build3 (code
, TREE_TYPE (exp
), op0
, op1
, op2
);
3736 op0
= SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp
, 0), f
, r
);
3737 op1
= SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp
, 1), f
, r
);
3738 op2
= SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp
, 2), f
, r
);
3739 op3
= SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp
, 3), f
, r
);
3741 if (op0
== TREE_OPERAND (exp
, 0) && op1
== TREE_OPERAND (exp
, 1)
3742 && op2
== TREE_OPERAND (exp
, 2)
3743 && op3
== TREE_OPERAND (exp
, 3))
3747 = fold (build4 (code
, TREE_TYPE (exp
), op0
, op1
, op2
, op3
));
3759 new_tree
= NULL_TREE
;
3761 /* If we are trying to replace F with a constant, inline back
3762 functions which do nothing else than computing a value from
3763 the arguments they are passed. This makes it possible to
3764 fold partially or entirely the replacement expression. */
3765 if (CONSTANT_CLASS_P (r
) && code
== CALL_EXPR
)
3767 tree t
= maybe_inline_call_in_expr (exp
);
3769 return SUBSTITUTE_IN_EXPR (t
, f
, r
);
3772 for (i
= 1; i
< TREE_OPERAND_LENGTH (exp
); i
++)
3774 tree op
= TREE_OPERAND (exp
, i
);
3775 tree new_op
= SUBSTITUTE_IN_EXPR (op
, f
, r
);
3779 new_tree
= copy_node (exp
);
3780 TREE_OPERAND (new_tree
, i
) = new_op
;
3786 new_tree
= fold (new_tree
);
3787 if (TREE_CODE (new_tree
) == CALL_EXPR
)
3788 process_call_operands (new_tree
);
3799 TREE_READONLY (new_tree
) |= TREE_READONLY (exp
);
3801 if (code
== INDIRECT_REF
|| code
== ARRAY_REF
|| code
== ARRAY_RANGE_REF
)
3802 TREE_THIS_NOTRAP (new_tree
) |= TREE_THIS_NOTRAP (exp
);
3807 /* Similar, but look for a PLACEHOLDER_EXPR in EXP and find a replacement
3808 for it within OBJ, a tree that is an object or a chain of references. */
3811 substitute_placeholder_in_expr (tree exp
, tree obj
)
3813 enum tree_code code
= TREE_CODE (exp
);
3814 tree op0
, op1
, op2
, op3
;
3817 /* If this is a PLACEHOLDER_EXPR, see if we find a corresponding type
3818 in the chain of OBJ. */
3819 if (code
== PLACEHOLDER_EXPR
)
3821 tree need_type
= TYPE_MAIN_VARIANT (TREE_TYPE (exp
));
3824 for (elt
= obj
; elt
!= 0;
3825 elt
= ((TREE_CODE (elt
) == COMPOUND_EXPR
3826 || TREE_CODE (elt
) == COND_EXPR
)
3827 ? TREE_OPERAND (elt
, 1)
3828 : (REFERENCE_CLASS_P (elt
)
3829 || UNARY_CLASS_P (elt
)
3830 || BINARY_CLASS_P (elt
)
3831 || VL_EXP_CLASS_P (elt
)
3832 || EXPRESSION_CLASS_P (elt
))
3833 ? TREE_OPERAND (elt
, 0) : 0))
3834 if (TYPE_MAIN_VARIANT (TREE_TYPE (elt
)) == need_type
)
3837 for (elt
= obj
; elt
!= 0;
3838 elt
= ((TREE_CODE (elt
) == COMPOUND_EXPR
3839 || TREE_CODE (elt
) == COND_EXPR
)
3840 ? TREE_OPERAND (elt
, 1)
3841 : (REFERENCE_CLASS_P (elt
)
3842 || UNARY_CLASS_P (elt
)
3843 || BINARY_CLASS_P (elt
)
3844 || VL_EXP_CLASS_P (elt
)
3845 || EXPRESSION_CLASS_P (elt
))
3846 ? TREE_OPERAND (elt
, 0) : 0))
3847 if (POINTER_TYPE_P (TREE_TYPE (elt
))
3848 && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (elt
)))
3850 return fold_build1 (INDIRECT_REF
, need_type
, elt
);
3852 /* If we didn't find it, return the original PLACEHOLDER_EXPR. If it
3853 survives until RTL generation, there will be an error. */
3857 /* TREE_LIST is special because we need to look at TREE_VALUE
3858 and TREE_CHAIN, not TREE_OPERANDS. */
3859 else if (code
== TREE_LIST
)
3861 op0
= SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_CHAIN (exp
), obj
);
3862 op1
= SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_VALUE (exp
), obj
);
3863 if (op0
== TREE_CHAIN (exp
) && op1
== TREE_VALUE (exp
))
3866 return tree_cons (TREE_PURPOSE (exp
), op1
, op0
);
3869 switch (TREE_CODE_CLASS (code
))
3872 case tcc_declaration
:
3875 case tcc_exceptional
:
3878 case tcc_comparison
:
3879 case tcc_expression
:
3882 switch (TREE_CODE_LENGTH (code
))
3888 op0
= SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp
, 0), obj
);
3889 if (op0
== TREE_OPERAND (exp
, 0))
3892 new_tree
= fold_build1 (code
, TREE_TYPE (exp
), op0
);
3896 op0
= SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp
, 0), obj
);
3897 op1
= SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp
, 1), obj
);
3899 if (op0
== TREE_OPERAND (exp
, 0) && op1
== TREE_OPERAND (exp
, 1))
3902 new_tree
= fold_build2 (code
, TREE_TYPE (exp
), op0
, op1
);
3906 op0
= SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp
, 0), obj
);
3907 op1
= SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp
, 1), obj
);
3908 op2
= SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp
, 2), obj
);
3910 if (op0
== TREE_OPERAND (exp
, 0) && op1
== TREE_OPERAND (exp
, 1)
3911 && op2
== TREE_OPERAND (exp
, 2))
3914 new_tree
= fold_build3 (code
, TREE_TYPE (exp
), op0
, op1
, op2
);
3918 op0
= SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp
, 0), obj
);
3919 op1
= SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp
, 1), obj
);
3920 op2
= SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp
, 2), obj
);
3921 op3
= SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp
, 3), obj
);
3923 if (op0
== TREE_OPERAND (exp
, 0) && op1
== TREE_OPERAND (exp
, 1)
3924 && op2
== TREE_OPERAND (exp
, 2)
3925 && op3
== TREE_OPERAND (exp
, 3))
3929 = fold (build4 (code
, TREE_TYPE (exp
), op0
, op1
, op2
, op3
));
3941 new_tree
= NULL_TREE
;
3943 for (i
= 1; i
< TREE_OPERAND_LENGTH (exp
); i
++)
3945 tree op
= TREE_OPERAND (exp
, i
);
3946 tree new_op
= SUBSTITUTE_PLACEHOLDER_IN_EXPR (op
, obj
);
3950 new_tree
= copy_node (exp
);
3951 TREE_OPERAND (new_tree
, i
) = new_op
;
3957 new_tree
= fold (new_tree
);
3958 if (TREE_CODE (new_tree
) == CALL_EXPR
)
3959 process_call_operands (new_tree
);
3970 TREE_READONLY (new_tree
) |= TREE_READONLY (exp
);
3972 if (code
== INDIRECT_REF
|| code
== ARRAY_REF
|| code
== ARRAY_RANGE_REF
)
3973 TREE_THIS_NOTRAP (new_tree
) |= TREE_THIS_NOTRAP (exp
);
3979 /* Subroutine of stabilize_reference; this is called for subtrees of
3980 references. Any expression with side-effects must be put in a SAVE_EXPR
3981 to ensure that it is only evaluated once.
3983 We don't put SAVE_EXPR nodes around everything, because assigning very
3984 simple expressions to temporaries causes us to miss good opportunities
3985 for optimizations. Among other things, the opportunity to fold in the
3986 addition of a constant into an addressing mode often gets lost, e.g.
3987 "y[i+1] += x;". In general, we take the approach that we should not make
3988 an assignment unless we are forced into it - i.e., that any non-side effect
3989 operator should be allowed, and that cse should take care of coalescing
3990 multiple utterances of the same expression should that prove fruitful. */
3993 stabilize_reference_1 (tree e
)
3996 enum tree_code code
= TREE_CODE (e
);
3998 /* We cannot ignore const expressions because it might be a reference
3999 to a const array but whose index contains side-effects. But we can
4000 ignore things that are actual constant or that already have been
4001 handled by this function. */
4003 if (tree_invariant_p (e
))
4006 switch (TREE_CODE_CLASS (code
))
4008 case tcc_exceptional
:
4010 case tcc_declaration
:
4011 case tcc_comparison
:
4013 case tcc_expression
:
4016 /* If the expression has side-effects, then encase it in a SAVE_EXPR
4017 so that it will only be evaluated once. */
4018 /* The reference (r) and comparison (<) classes could be handled as
4019 below, but it is generally faster to only evaluate them once. */
4020 if (TREE_SIDE_EFFECTS (e
))
4021 return save_expr (e
);
4025 /* Constants need no processing. In fact, we should never reach
4030 /* Division is slow and tends to be compiled with jumps,
4031 especially the division by powers of 2 that is often
4032 found inside of an array reference. So do it just once. */
4033 if (code
== TRUNC_DIV_EXPR
|| code
== TRUNC_MOD_EXPR
4034 || code
== FLOOR_DIV_EXPR
|| code
== FLOOR_MOD_EXPR
4035 || code
== CEIL_DIV_EXPR
|| code
== CEIL_MOD_EXPR
4036 || code
== ROUND_DIV_EXPR
|| code
== ROUND_MOD_EXPR
)
4037 return save_expr (e
);
4038 /* Recursively stabilize each operand. */
4039 result
= build_nt (code
, stabilize_reference_1 (TREE_OPERAND (e
, 0)),
4040 stabilize_reference_1 (TREE_OPERAND (e
, 1)));
4044 /* Recursively stabilize each operand. */
4045 result
= build_nt (code
, stabilize_reference_1 (TREE_OPERAND (e
, 0)));
4052 TREE_TYPE (result
) = TREE_TYPE (e
);
4053 TREE_READONLY (result
) = TREE_READONLY (e
);
4054 TREE_SIDE_EFFECTS (result
) = TREE_SIDE_EFFECTS (e
);
4055 TREE_THIS_VOLATILE (result
) = TREE_THIS_VOLATILE (e
);
4060 /* Stabilize a reference so that we can use it any number of times
4061 without causing its operands to be evaluated more than once.
4062 Returns the stabilized reference. This works by means of save_expr,
4063 so see the caveats in the comments about save_expr.
4065 Also allows conversion expressions whose operands are references.
4066 Any other kind of expression is returned unchanged. */
4069 stabilize_reference (tree ref
)
4072 enum tree_code code
= TREE_CODE (ref
);
4079 /* No action is needed in this case. */
4084 case FIX_TRUNC_EXPR
:
4085 result
= build_nt (code
, stabilize_reference (TREE_OPERAND (ref
, 0)));
4089 result
= build_nt (INDIRECT_REF
,
4090 stabilize_reference_1 (TREE_OPERAND (ref
, 0)));
4094 result
= build_nt (COMPONENT_REF
,
4095 stabilize_reference (TREE_OPERAND (ref
, 0)),
4096 TREE_OPERAND (ref
, 1), NULL_TREE
);
4100 result
= build_nt (BIT_FIELD_REF
,
4101 stabilize_reference (TREE_OPERAND (ref
, 0)),
4102 TREE_OPERAND (ref
, 1), TREE_OPERAND (ref
, 2));
4106 result
= build_nt (ARRAY_REF
,
4107 stabilize_reference (TREE_OPERAND (ref
, 0)),
4108 stabilize_reference_1 (TREE_OPERAND (ref
, 1)),
4109 TREE_OPERAND (ref
, 2), TREE_OPERAND (ref
, 3));
4112 case ARRAY_RANGE_REF
:
4113 result
= build_nt (ARRAY_RANGE_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));
4120 /* We cannot wrap the first expression in a SAVE_EXPR, as then
4121 it wouldn't be ignored. This matters when dealing with
4123 return stabilize_reference_1 (ref
);
4125 /* If arg isn't a kind of lvalue we recognize, make no change.
4126 Caller should recognize the error for an invalid lvalue. */
4131 return error_mark_node
;
4134 TREE_TYPE (result
) = TREE_TYPE (ref
);
4135 TREE_READONLY (result
) = TREE_READONLY (ref
);
4136 TREE_SIDE_EFFECTS (result
) = TREE_SIDE_EFFECTS (ref
);
4137 TREE_THIS_VOLATILE (result
) = TREE_THIS_VOLATILE (ref
);
4142 /* Low-level constructors for expressions. */
4144 /* A helper function for build1 and constant folders. Set TREE_CONSTANT,
4145 and TREE_SIDE_EFFECTS for an ADDR_EXPR. */
4148 recompute_tree_invariant_for_addr_expr (tree t
)
4151 bool tc
= true, se
= false;
4153 /* We started out assuming this address is both invariant and constant, but
4154 does not have side effects. Now go down any handled components and see if
4155 any of them involve offsets that are either non-constant or non-invariant.
4156 Also check for side-effects.
4158 ??? Note that this code makes no attempt to deal with the case where
4159 taking the address of something causes a copy due to misalignment. */
4161 #define UPDATE_FLAGS(NODE) \
4162 do { tree _node = (NODE); \
4163 if (_node && !TREE_CONSTANT (_node)) tc = false; \
4164 if (_node && TREE_SIDE_EFFECTS (_node)) se = true; } while (0)
4166 for (node
= TREE_OPERAND (t
, 0); handled_component_p (node
);
4167 node
= TREE_OPERAND (node
, 0))
4169 /* If the first operand doesn't have an ARRAY_TYPE, this is a bogus
4170 array reference (probably made temporarily by the G++ front end),
4171 so ignore all the operands. */
4172 if ((TREE_CODE (node
) == ARRAY_REF
4173 || TREE_CODE (node
) == ARRAY_RANGE_REF
)
4174 && TREE_CODE (TREE_TYPE (TREE_OPERAND (node
, 0))) == ARRAY_TYPE
)
4176 UPDATE_FLAGS (TREE_OPERAND (node
, 1));
4177 if (TREE_OPERAND (node
, 2))
4178 UPDATE_FLAGS (TREE_OPERAND (node
, 2));
4179 if (TREE_OPERAND (node
, 3))
4180 UPDATE_FLAGS (TREE_OPERAND (node
, 3));
4182 /* Likewise, just because this is a COMPONENT_REF doesn't mean we have a
4183 FIELD_DECL, apparently. The G++ front end can put something else
4184 there, at least temporarily. */
4185 else if (TREE_CODE (node
) == COMPONENT_REF
4186 && TREE_CODE (TREE_OPERAND (node
, 1)) == FIELD_DECL
)
4188 if (TREE_OPERAND (node
, 2))
4189 UPDATE_FLAGS (TREE_OPERAND (node
, 2));
4193 node
= lang_hooks
.expr_to_decl (node
, &tc
, &se
);
4195 /* Now see what's inside. If it's an INDIRECT_REF, copy our properties from
4196 the address, since &(*a)->b is a form of addition. If it's a constant, the
4197 address is constant too. If it's a decl, its address is constant if the
4198 decl is static. Everything else is not constant and, furthermore,
4199 taking the address of a volatile variable is not volatile. */
4200 if (TREE_CODE (node
) == INDIRECT_REF
4201 || TREE_CODE (node
) == MEM_REF
)
4202 UPDATE_FLAGS (TREE_OPERAND (node
, 0));
4203 else if (CONSTANT_CLASS_P (node
))
4205 else if (DECL_P (node
))
4206 tc
&= (staticp (node
) != NULL_TREE
);
4210 se
|= TREE_SIDE_EFFECTS (node
);
4214 TREE_CONSTANT (t
) = tc
;
4215 TREE_SIDE_EFFECTS (t
) = se
;
4219 /* Build an expression of code CODE, data type TYPE, and operands as
4220 specified. Expressions and reference nodes can be created this way.
4221 Constants, decls, types and misc nodes cannot be.
4223 We define 5 non-variadic functions, from 0 to 4 arguments. This is
4224 enough for all extant tree codes. */
4227 build0_stat (enum tree_code code
, tree tt MEM_STAT_DECL
)
4231 gcc_assert (TREE_CODE_LENGTH (code
) == 0);
4233 t
= make_node_stat (code PASS_MEM_STAT
);
4240 build1_stat (enum tree_code code
, tree type
, tree node MEM_STAT_DECL
)
4242 int length
= sizeof (struct tree_exp
);
4245 record_node_allocation_statistics (code
, length
);
4247 gcc_assert (TREE_CODE_LENGTH (code
) == 1);
4249 t
= ggc_alloc_tree_node_stat (length PASS_MEM_STAT
);
4251 memset (t
, 0, sizeof (struct tree_common
));
4253 TREE_SET_CODE (t
, code
);
4255 TREE_TYPE (t
) = type
;
4256 SET_EXPR_LOCATION (t
, UNKNOWN_LOCATION
);
4257 TREE_OPERAND (t
, 0) = node
;
4258 if (node
&& !TYPE_P (node
))
4260 TREE_SIDE_EFFECTS (t
) = TREE_SIDE_EFFECTS (node
);
4261 TREE_READONLY (t
) = TREE_READONLY (node
);
4264 if (TREE_CODE_CLASS (code
) == tcc_statement
)
4265 TREE_SIDE_EFFECTS (t
) = 1;
4269 /* All of these have side-effects, no matter what their
4271 TREE_SIDE_EFFECTS (t
) = 1;
4272 TREE_READONLY (t
) = 0;
4276 /* Whether a dereference is readonly has nothing to do with whether
4277 its operand is readonly. */
4278 TREE_READONLY (t
) = 0;
4283 recompute_tree_invariant_for_addr_expr (t
);
4287 if ((TREE_CODE_CLASS (code
) == tcc_unary
|| code
== VIEW_CONVERT_EXPR
)
4288 && node
&& !TYPE_P (node
)
4289 && TREE_CONSTANT (node
))
4290 TREE_CONSTANT (t
) = 1;
4291 if (TREE_CODE_CLASS (code
) == tcc_reference
4292 && node
&& TREE_THIS_VOLATILE (node
))
4293 TREE_THIS_VOLATILE (t
) = 1;
4300 #define PROCESS_ARG(N) \
4302 TREE_OPERAND (t, N) = arg##N; \
4303 if (arg##N &&!TYPE_P (arg##N)) \
4305 if (TREE_SIDE_EFFECTS (arg##N)) \
4307 if (!TREE_READONLY (arg##N) \
4308 && !CONSTANT_CLASS_P (arg##N)) \
4309 (void) (read_only = 0); \
4310 if (!TREE_CONSTANT (arg##N)) \
4311 (void) (constant = 0); \
4316 build2_stat (enum tree_code code
, tree tt
, tree arg0
, tree arg1 MEM_STAT_DECL
)
4318 bool constant
, read_only
, side_effects
;
4321 gcc_assert (TREE_CODE_LENGTH (code
) == 2);
4323 if ((code
== MINUS_EXPR
|| code
== PLUS_EXPR
|| code
== MULT_EXPR
)
4324 && arg0
&& arg1
&& tt
&& POINTER_TYPE_P (tt
)
4325 /* When sizetype precision doesn't match that of pointers
4326 we need to be able to build explicit extensions or truncations
4327 of the offset argument. */
4328 && TYPE_PRECISION (sizetype
) == TYPE_PRECISION (tt
))
4329 gcc_assert (TREE_CODE (arg0
) == INTEGER_CST
4330 && TREE_CODE (arg1
) == INTEGER_CST
);
4332 if (code
== POINTER_PLUS_EXPR
&& arg0
&& arg1
&& tt
)
4333 gcc_assert (POINTER_TYPE_P (tt
) && POINTER_TYPE_P (TREE_TYPE (arg0
))
4334 && ptrofftype_p (TREE_TYPE (arg1
)));
4336 t
= make_node_stat (code PASS_MEM_STAT
);
4339 /* Below, we automatically set TREE_SIDE_EFFECTS and TREE_READONLY for the
4340 result based on those same flags for the arguments. But if the
4341 arguments aren't really even `tree' expressions, we shouldn't be trying
4344 /* Expressions without side effects may be constant if their
4345 arguments are as well. */
4346 constant
= (TREE_CODE_CLASS (code
) == tcc_comparison
4347 || TREE_CODE_CLASS (code
) == tcc_binary
);
4349 side_effects
= TREE_SIDE_EFFECTS (t
);
4354 TREE_READONLY (t
) = read_only
;
4355 TREE_CONSTANT (t
) = constant
;
4356 TREE_SIDE_EFFECTS (t
) = side_effects
;
4357 TREE_THIS_VOLATILE (t
)
4358 = (TREE_CODE_CLASS (code
) == tcc_reference
4359 && arg0
&& TREE_THIS_VOLATILE (arg0
));
4366 build3_stat (enum tree_code code
, tree tt
, tree arg0
, tree arg1
,
4367 tree arg2 MEM_STAT_DECL
)
4369 bool constant
, read_only
, side_effects
;
4372 gcc_assert (TREE_CODE_LENGTH (code
) == 3);
4373 gcc_assert (TREE_CODE_CLASS (code
) != tcc_vl_exp
);
4375 t
= make_node_stat (code PASS_MEM_STAT
);
4380 /* As a special exception, if COND_EXPR has NULL branches, we
4381 assume that it is a gimple statement and always consider
4382 it to have side effects. */
4383 if (code
== COND_EXPR
4384 && tt
== void_type_node
4385 && arg1
== NULL_TREE
4386 && arg2
== NULL_TREE
)
4387 side_effects
= true;
4389 side_effects
= TREE_SIDE_EFFECTS (t
);
4395 if (code
== COND_EXPR
)
4396 TREE_READONLY (t
) = read_only
;
4398 TREE_SIDE_EFFECTS (t
) = side_effects
;
4399 TREE_THIS_VOLATILE (t
)
4400 = (TREE_CODE_CLASS (code
) == tcc_reference
4401 && arg0
&& TREE_THIS_VOLATILE (arg0
));
4407 build4_stat (enum tree_code code
, tree tt
, tree arg0
, tree arg1
,
4408 tree arg2
, tree arg3 MEM_STAT_DECL
)
4410 bool constant
, read_only
, side_effects
;
4413 gcc_assert (TREE_CODE_LENGTH (code
) == 4);
4415 t
= make_node_stat (code PASS_MEM_STAT
);
4418 side_effects
= TREE_SIDE_EFFECTS (t
);
4425 TREE_SIDE_EFFECTS (t
) = side_effects
;
4426 TREE_THIS_VOLATILE (t
)
4427 = (TREE_CODE_CLASS (code
) == tcc_reference
4428 && arg0
&& TREE_THIS_VOLATILE (arg0
));
4434 build5_stat (enum tree_code code
, tree tt
, tree arg0
, tree arg1
,
4435 tree arg2
, tree arg3
, tree arg4 MEM_STAT_DECL
)
4437 bool constant
, read_only
, side_effects
;
4440 gcc_assert (TREE_CODE_LENGTH (code
) == 5);
4442 t
= make_node_stat (code PASS_MEM_STAT
);
4445 side_effects
= TREE_SIDE_EFFECTS (t
);
4453 TREE_SIDE_EFFECTS (t
) = side_effects
;
4454 TREE_THIS_VOLATILE (t
)
4455 = (TREE_CODE_CLASS (code
) == tcc_reference
4456 && arg0
&& TREE_THIS_VOLATILE (arg0
));
4461 /* Build a simple MEM_REF tree with the sematics of a plain INDIRECT_REF
4462 on the pointer PTR. */
4465 build_simple_mem_ref_loc (location_t loc
, tree ptr
)
4467 HOST_WIDE_INT offset
= 0;
4468 tree ptype
= TREE_TYPE (ptr
);
4470 /* For convenience allow addresses that collapse to a simple base
4472 if (TREE_CODE (ptr
) == ADDR_EXPR
4473 && (handled_component_p (TREE_OPERAND (ptr
, 0))
4474 || TREE_CODE (TREE_OPERAND (ptr
, 0)) == MEM_REF
))
4476 ptr
= get_addr_base_and_unit_offset (TREE_OPERAND (ptr
, 0), &offset
);
4478 ptr
= build_fold_addr_expr (ptr
);
4479 gcc_assert (is_gimple_reg (ptr
) || is_gimple_min_invariant (ptr
));
4481 tem
= build2 (MEM_REF
, TREE_TYPE (ptype
),
4482 ptr
, build_int_cst (ptype
, offset
));
4483 SET_EXPR_LOCATION (tem
, loc
);
4487 /* Return the constant offset of a MEM_REF or TARGET_MEM_REF tree T. */
4490 mem_ref_offset (const_tree t
)
4492 return offset_int::from (TREE_OPERAND (t
, 1), SIGNED
);
4495 /* Return an invariant ADDR_EXPR of type TYPE taking the address of BASE
4496 offsetted by OFFSET units. */
4499 build_invariant_address (tree type
, tree base
, HOST_WIDE_INT offset
)
4501 tree ref
= fold_build2 (MEM_REF
, TREE_TYPE (type
),
4502 build_fold_addr_expr (base
),
4503 build_int_cst (ptr_type_node
, offset
));
4504 tree addr
= build1 (ADDR_EXPR
, type
, ref
);
4505 recompute_tree_invariant_for_addr_expr (addr
);
4509 /* Similar except don't specify the TREE_TYPE
4510 and leave the TREE_SIDE_EFFECTS as 0.
4511 It is permissible for arguments to be null,
4512 or even garbage if their values do not matter. */
4515 build_nt (enum tree_code code
, ...)
4522 gcc_assert (TREE_CODE_CLASS (code
) != tcc_vl_exp
);
4526 t
= make_node (code
);
4527 length
= TREE_CODE_LENGTH (code
);
4529 for (i
= 0; i
< length
; i
++)
4530 TREE_OPERAND (t
, i
) = va_arg (p
, tree
);
4536 /* Similar to build_nt, but for creating a CALL_EXPR object with a
4540 build_nt_call_vec (tree fn
, vec
<tree
, va_gc
> *args
)
4545 ret
= build_vl_exp (CALL_EXPR
, vec_safe_length (args
) + 3);
4546 CALL_EXPR_FN (ret
) = fn
;
4547 CALL_EXPR_STATIC_CHAIN (ret
) = NULL_TREE
;
4548 FOR_EACH_VEC_SAFE_ELT (args
, ix
, t
)
4549 CALL_EXPR_ARG (ret
, ix
) = t
;
4553 /* Create a DECL_... node of code CODE, name NAME and data type TYPE.
4554 We do NOT enter this node in any sort of symbol table.
4556 LOC is the location of the decl.
4558 layout_decl is used to set up the decl's storage layout.
4559 Other slots are initialized to 0 or null pointers. */
4562 build_decl_stat (location_t loc
, enum tree_code code
, tree name
,
4563 tree type MEM_STAT_DECL
)
4567 t
= make_node_stat (code PASS_MEM_STAT
);
4568 DECL_SOURCE_LOCATION (t
) = loc
;
4570 /* if (type == error_mark_node)
4571 type = integer_type_node; */
4572 /* That is not done, deliberately, so that having error_mark_node
4573 as the type can suppress useless errors in the use of this variable. */
4575 DECL_NAME (t
) = name
;
4576 TREE_TYPE (t
) = type
;
4578 if (code
== VAR_DECL
|| code
== PARM_DECL
|| code
== RESULT_DECL
)
4584 /* Builds and returns function declaration with NAME and TYPE. */
4587 build_fn_decl (const char *name
, tree type
)
4589 tree id
= get_identifier (name
);
4590 tree decl
= build_decl (input_location
, FUNCTION_DECL
, id
, type
);
4592 DECL_EXTERNAL (decl
) = 1;
4593 TREE_PUBLIC (decl
) = 1;
4594 DECL_ARTIFICIAL (decl
) = 1;
4595 TREE_NOTHROW (decl
) = 1;
4600 vec
<tree
, va_gc
> *all_translation_units
;
4602 /* Builds a new translation-unit decl with name NAME, queues it in the
4603 global list of translation-unit decls and returns it. */
4606 build_translation_unit_decl (tree name
)
4608 tree tu
= build_decl (UNKNOWN_LOCATION
, TRANSLATION_UNIT_DECL
,
4610 TRANSLATION_UNIT_LANGUAGE (tu
) = lang_hooks
.name
;
4611 vec_safe_push (all_translation_units
, tu
);
4616 /* BLOCK nodes are used to represent the structure of binding contours
4617 and declarations, once those contours have been exited and their contents
4618 compiled. This information is used for outputting debugging info. */
4621 build_block (tree vars
, tree subblocks
, tree supercontext
, tree chain
)
4623 tree block
= make_node (BLOCK
);
4625 BLOCK_VARS (block
) = vars
;
4626 BLOCK_SUBBLOCKS (block
) = subblocks
;
4627 BLOCK_SUPERCONTEXT (block
) = supercontext
;
4628 BLOCK_CHAIN (block
) = chain
;
4633 /* Like SET_EXPR_LOCATION, but make sure the tree can have a location.
4635 LOC is the location to use in tree T. */
4638 protected_set_expr_location (tree t
, location_t loc
)
4640 if (CAN_HAVE_LOCATION_P (t
))
4641 SET_EXPR_LOCATION (t
, loc
);
4644 /* Return a declaration like DDECL except that its DECL_ATTRIBUTES
4648 build_decl_attribute_variant (tree ddecl
, tree attribute
)
4650 DECL_ATTRIBUTES (ddecl
) = attribute
;
4654 /* Return a type like TYPE except that its TYPE_ATTRIBUTE
4655 is ATTRIBUTE and its qualifiers are QUALS.
4657 Record such modified types already made so we don't make duplicates. */
4660 build_type_attribute_qual_variant (tree type
, tree attribute
, int quals
)
4662 if (! attribute_list_equal (TYPE_ATTRIBUTES (type
), attribute
))
4664 inchash::hash hstate
;
4668 enum tree_code code
= TREE_CODE (type
);
4670 /* Building a distinct copy of a tagged type is inappropriate; it
4671 causes breakage in code that expects there to be a one-to-one
4672 relationship between a struct and its fields.
4673 build_duplicate_type is another solution (as used in
4674 handle_transparent_union_attribute), but that doesn't play well
4675 with the stronger C++ type identity model. */
4676 if (TREE_CODE (type
) == RECORD_TYPE
4677 || TREE_CODE (type
) == UNION_TYPE
4678 || TREE_CODE (type
) == QUAL_UNION_TYPE
4679 || TREE_CODE (type
) == ENUMERAL_TYPE
)
4681 warning (OPT_Wattributes
,
4682 "ignoring attributes applied to %qT after definition",
4683 TYPE_MAIN_VARIANT (type
));
4684 return build_qualified_type (type
, quals
);
4687 type
= build_qualified_type (type
, TYPE_UNQUALIFIED
);
4688 ntype
= build_distinct_type_copy (type
);
4690 TYPE_ATTRIBUTES (ntype
) = attribute
;
4692 hstate
.add_int (code
);
4693 if (TREE_TYPE (ntype
))
4694 hstate
.add_object (TYPE_HASH (TREE_TYPE (ntype
)));
4695 attribute_hash_list (attribute
, hstate
);
4697 switch (TREE_CODE (ntype
))
4700 type_hash_list (TYPE_ARG_TYPES (ntype
), hstate
);
4703 if (TYPE_DOMAIN (ntype
))
4704 hstate
.add_object (TYPE_HASH (TYPE_DOMAIN (ntype
)));
4707 t
= TYPE_MAX_VALUE (ntype
);
4708 for (i
= 0; i
< TREE_INT_CST_NUNITS (t
); i
++)
4709 hstate
.add_object (TREE_INT_CST_ELT (t
, i
));
4712 case FIXED_POINT_TYPE
:
4714 unsigned int precision
= TYPE_PRECISION (ntype
);
4715 hstate
.add_object (precision
);
4722 ntype
= type_hash_canon (hstate
.end(), ntype
);
4724 /* If the target-dependent attributes make NTYPE different from
4725 its canonical type, we will need to use structural equality
4726 checks for this type. */
4727 if (TYPE_STRUCTURAL_EQUALITY_P (type
)
4728 || !comp_type_attributes (ntype
, type
))
4729 SET_TYPE_STRUCTURAL_EQUALITY (ntype
);
4730 else if (TYPE_CANONICAL (ntype
) == ntype
)
4731 TYPE_CANONICAL (ntype
) = TYPE_CANONICAL (type
);
4733 type
= build_qualified_type (ntype
, quals
);
4735 else if (TYPE_QUALS (type
) != quals
)
4736 type
= build_qualified_type (type
, quals
);
4741 /* Check if "omp declare simd" attribute arguments, CLAUSES1 and CLAUSES2, are
4745 omp_declare_simd_clauses_equal (tree clauses1
, tree clauses2
)
4748 for (cl1
= clauses1
, cl2
= clauses2
;
4750 cl1
= OMP_CLAUSE_CHAIN (cl1
), cl2
= OMP_CLAUSE_CHAIN (cl2
))
4752 if (OMP_CLAUSE_CODE (cl1
) != OMP_CLAUSE_CODE (cl2
))
4754 if (OMP_CLAUSE_CODE (cl1
) != OMP_CLAUSE_SIMDLEN
)
4756 if (simple_cst_equal (OMP_CLAUSE_DECL (cl1
),
4757 OMP_CLAUSE_DECL (cl2
)) != 1)
4760 switch (OMP_CLAUSE_CODE (cl1
))
4762 case OMP_CLAUSE_ALIGNED
:
4763 if (simple_cst_equal (OMP_CLAUSE_ALIGNED_ALIGNMENT (cl1
),
4764 OMP_CLAUSE_ALIGNED_ALIGNMENT (cl2
)) != 1)
4767 case OMP_CLAUSE_LINEAR
:
4768 if (simple_cst_equal (OMP_CLAUSE_LINEAR_STEP (cl1
),
4769 OMP_CLAUSE_LINEAR_STEP (cl2
)) != 1)
4772 case OMP_CLAUSE_SIMDLEN
:
4773 if (simple_cst_equal (OMP_CLAUSE_SIMDLEN_EXPR (cl1
),
4774 OMP_CLAUSE_SIMDLEN_EXPR (cl2
)) != 1)
4783 /* Compare two constructor-element-type constants. Return 1 if the lists
4784 are known to be equal; otherwise return 0. */
4787 simple_cst_list_equal (const_tree l1
, const_tree l2
)
4789 while (l1
!= NULL_TREE
&& l2
!= NULL_TREE
)
4791 if (simple_cst_equal (TREE_VALUE (l1
), TREE_VALUE (l2
)) != 1)
4794 l1
= TREE_CHAIN (l1
);
4795 l2
= TREE_CHAIN (l2
);
4801 /* Compare two attributes for their value identity. Return true if the
4802 attribute values are known to be equal; otherwise return false.
4806 attribute_value_equal (const_tree attr1
, const_tree attr2
)
4808 if (TREE_VALUE (attr1
) == TREE_VALUE (attr2
))
4811 if (TREE_VALUE (attr1
) != NULL_TREE
4812 && TREE_CODE (TREE_VALUE (attr1
)) == TREE_LIST
4813 && TREE_VALUE (attr2
) != NULL
4814 && TREE_CODE (TREE_VALUE (attr2
)) == TREE_LIST
)
4815 return (simple_cst_list_equal (TREE_VALUE (attr1
),
4816 TREE_VALUE (attr2
)) == 1);
4818 if ((flag_openmp
|| flag_openmp_simd
)
4819 && TREE_VALUE (attr1
) && TREE_VALUE (attr2
)
4820 && TREE_CODE (TREE_VALUE (attr1
)) == OMP_CLAUSE
4821 && TREE_CODE (TREE_VALUE (attr2
)) == OMP_CLAUSE
)
4822 return omp_declare_simd_clauses_equal (TREE_VALUE (attr1
),
4823 TREE_VALUE (attr2
));
4825 return (simple_cst_equal (TREE_VALUE (attr1
), TREE_VALUE (attr2
)) == 1);
4828 /* Return 0 if the attributes for two types are incompatible, 1 if they
4829 are compatible, and 2 if they are nearly compatible (which causes a
4830 warning to be generated). */
4832 comp_type_attributes (const_tree type1
, const_tree type2
)
4834 const_tree a1
= TYPE_ATTRIBUTES (type1
);
4835 const_tree a2
= TYPE_ATTRIBUTES (type2
);
4840 for (a
= a1
; a
!= NULL_TREE
; a
= TREE_CHAIN (a
))
4842 const struct attribute_spec
*as
;
4845 as
= lookup_attribute_spec (get_attribute_name (a
));
4846 if (!as
|| as
->affects_type_identity
== false)
4849 attr
= lookup_attribute (as
->name
, CONST_CAST_TREE (a2
));
4850 if (!attr
|| !attribute_value_equal (a
, attr
))
4855 for (a
= a2
; a
!= NULL_TREE
; a
= TREE_CHAIN (a
))
4857 const struct attribute_spec
*as
;
4859 as
= lookup_attribute_spec (get_attribute_name (a
));
4860 if (!as
|| as
->affects_type_identity
== false)
4863 if (!lookup_attribute (as
->name
, CONST_CAST_TREE (a1
)))
4865 /* We don't need to compare trees again, as we did this
4866 already in first loop. */
4868 /* All types - affecting identity - are equal, so
4869 there is no need to call target hook for comparison. */
4873 /* As some type combinations - like default calling-convention - might
4874 be compatible, we have to call the target hook to get the final result. */
4875 return targetm
.comp_type_attributes (type1
, type2
);
4878 /* Return a type like TTYPE except that its TYPE_ATTRIBUTE
4881 Record such modified types already made so we don't make duplicates. */
4884 build_type_attribute_variant (tree type
, tree attribute
)
4886 return build_type_attribute_qual_variant (type
, attribute
,
4891 /* Reset the expression *EXPR_P, a size or position.
4893 ??? We could reset all non-constant sizes or positions. But it's cheap
4894 enough to not do so and refrain from adding workarounds to dwarf2out.c.
4896 We need to reset self-referential sizes or positions because they cannot
4897 be gimplified and thus can contain a CALL_EXPR after the gimplification
4898 is finished, which will run afoul of LTO streaming. And they need to be
4899 reset to something essentially dummy but not constant, so as to preserve
4900 the properties of the object they are attached to. */
4903 free_lang_data_in_one_sizepos (tree
*expr_p
)
4905 tree expr
= *expr_p
;
4906 if (CONTAINS_PLACEHOLDER_P (expr
))
4907 *expr_p
= build0 (PLACEHOLDER_EXPR
, TREE_TYPE (expr
));
4911 /* Reset all the fields in a binfo node BINFO. We only keep
4912 BINFO_VTABLE, which is used by gimple_fold_obj_type_ref. */
4915 free_lang_data_in_binfo (tree binfo
)
4920 gcc_assert (TREE_CODE (binfo
) == TREE_BINFO
);
4922 BINFO_VIRTUALS (binfo
) = NULL_TREE
;
4923 BINFO_BASE_ACCESSES (binfo
) = NULL
;
4924 BINFO_INHERITANCE_CHAIN (binfo
) = NULL_TREE
;
4925 BINFO_SUBVTT_INDEX (binfo
) = NULL_TREE
;
4927 FOR_EACH_VEC_ELT (*BINFO_BASE_BINFOS (binfo
), i
, t
)
4928 free_lang_data_in_binfo (t
);
4932 /* Reset all language specific information still present in TYPE. */
4935 free_lang_data_in_type (tree type
)
4937 gcc_assert (TYPE_P (type
));
4939 /* Give the FE a chance to remove its own data first. */
4940 lang_hooks
.free_lang_data (type
);
4942 TREE_LANG_FLAG_0 (type
) = 0;
4943 TREE_LANG_FLAG_1 (type
) = 0;
4944 TREE_LANG_FLAG_2 (type
) = 0;
4945 TREE_LANG_FLAG_3 (type
) = 0;
4946 TREE_LANG_FLAG_4 (type
) = 0;
4947 TREE_LANG_FLAG_5 (type
) = 0;
4948 TREE_LANG_FLAG_6 (type
) = 0;
4950 if (TREE_CODE (type
) == FUNCTION_TYPE
)
4952 /* Remove the const and volatile qualifiers from arguments. The
4953 C++ front end removes them, but the C front end does not,
4954 leading to false ODR violation errors when merging two
4955 instances of the same function signature compiled by
4956 different front ends. */
4959 for (p
= TYPE_ARG_TYPES (type
); p
; p
= TREE_CHAIN (p
))
4961 tree arg_type
= TREE_VALUE (p
);
4963 if (TYPE_READONLY (arg_type
) || TYPE_VOLATILE (arg_type
))
4965 int quals
= TYPE_QUALS (arg_type
)
4967 & ~TYPE_QUAL_VOLATILE
;
4968 TREE_VALUE (p
) = build_qualified_type (arg_type
, quals
);
4969 free_lang_data_in_type (TREE_VALUE (p
));
4974 /* Remove members that are not actually FIELD_DECLs from the field
4975 list of an aggregate. These occur in C++. */
4976 if (RECORD_OR_UNION_TYPE_P (type
))
4980 /* Note that TYPE_FIELDS can be shared across distinct
4981 TREE_TYPEs. Therefore, if the first field of TYPE_FIELDS is
4982 to be removed, we cannot set its TREE_CHAIN to NULL.
4983 Otherwise, we would not be able to find all the other fields
4984 in the other instances of this TREE_TYPE.
4986 This was causing an ICE in testsuite/g++.dg/lto/20080915.C. */
4988 member
= TYPE_FIELDS (type
);
4991 if (TREE_CODE (member
) == FIELD_DECL
4992 || TREE_CODE (member
) == TYPE_DECL
)
4995 TREE_CHAIN (prev
) = member
;
4997 TYPE_FIELDS (type
) = member
;
5001 member
= TREE_CHAIN (member
);
5005 TREE_CHAIN (prev
) = NULL_TREE
;
5007 TYPE_FIELDS (type
) = NULL_TREE
;
5009 TYPE_METHODS (type
) = NULL_TREE
;
5010 if (TYPE_BINFO (type
))
5012 free_lang_data_in_binfo (TYPE_BINFO (type
));
5013 if ((!BINFO_VTABLE (TYPE_BINFO (type
))
5014 || !flag_devirtualize
)
5015 && (!BINFO_N_BASE_BINFOS (TYPE_BINFO (type
))
5016 || debug_info_level
!= DINFO_LEVEL_NONE
))
5017 TYPE_BINFO (type
) = NULL
;
5022 /* For non-aggregate types, clear out the language slot (which
5023 overloads TYPE_BINFO). */
5024 TYPE_LANG_SLOT_1 (type
) = NULL_TREE
;
5026 if (INTEGRAL_TYPE_P (type
)
5027 || SCALAR_FLOAT_TYPE_P (type
)
5028 || FIXED_POINT_TYPE_P (type
))
5030 free_lang_data_in_one_sizepos (&TYPE_MIN_VALUE (type
));
5031 free_lang_data_in_one_sizepos (&TYPE_MAX_VALUE (type
));
5035 free_lang_data_in_one_sizepos (&TYPE_SIZE (type
));
5036 free_lang_data_in_one_sizepos (&TYPE_SIZE_UNIT (type
));
5038 if (TYPE_CONTEXT (type
)
5039 && TREE_CODE (TYPE_CONTEXT (type
)) == BLOCK
)
5041 tree ctx
= TYPE_CONTEXT (type
);
5044 ctx
= BLOCK_SUPERCONTEXT (ctx
);
5046 while (ctx
&& TREE_CODE (ctx
) == BLOCK
);
5047 TYPE_CONTEXT (type
) = ctx
;
5052 /* Return true if DECL may need an assembler name to be set. */
5055 need_assembler_name_p (tree decl
)
5057 /* We use DECL_ASSEMBLER_NAME to hold mangled type names for One Definition Rule
5059 if (flag_lto_odr_type_mering
5060 && TREE_CODE (decl
) == TYPE_DECL
5062 && decl
== TYPE_NAME (TREE_TYPE (decl
))
5063 && !is_lang_specific (TREE_TYPE (decl
))
5064 && AGGREGATE_TYPE_P (TREE_TYPE (decl
))
5065 && !variably_modified_type_p (TREE_TYPE (decl
), NULL_TREE
)
5066 && !type_in_anonymous_namespace_p (TREE_TYPE (decl
)))
5067 return !DECL_ASSEMBLER_NAME_SET_P (decl
);
5068 /* Only FUNCTION_DECLs and VAR_DECLs are considered. */
5069 if (TREE_CODE (decl
) != FUNCTION_DECL
5070 && TREE_CODE (decl
) != VAR_DECL
)
5073 /* If DECL already has its assembler name set, it does not need a
5075 if (!HAS_DECL_ASSEMBLER_NAME_P (decl
)
5076 || DECL_ASSEMBLER_NAME_SET_P (decl
))
5079 /* Abstract decls do not need an assembler name. */
5080 if (DECL_ABSTRACT_P (decl
))
5083 /* For VAR_DECLs, only static, public and external symbols need an
5085 if (TREE_CODE (decl
) == VAR_DECL
5086 && !TREE_STATIC (decl
)
5087 && !TREE_PUBLIC (decl
)
5088 && !DECL_EXTERNAL (decl
))
5091 if (TREE_CODE (decl
) == FUNCTION_DECL
)
5093 /* Do not set assembler name on builtins. Allow RTL expansion to
5094 decide whether to expand inline or via a regular call. */
5095 if (DECL_BUILT_IN (decl
)
5096 && DECL_BUILT_IN_CLASS (decl
) != BUILT_IN_FRONTEND
)
5099 /* Functions represented in the callgraph need an assembler name. */
5100 if (cgraph_node::get (decl
) != NULL
)
5103 /* Unused and not public functions don't need an assembler name. */
5104 if (!TREE_USED (decl
) && !TREE_PUBLIC (decl
))
5112 /* Reset all language specific information still present in symbol
5116 free_lang_data_in_decl (tree decl
)
5118 gcc_assert (DECL_P (decl
));
5120 /* Give the FE a chance to remove its own data first. */
5121 lang_hooks
.free_lang_data (decl
);
5123 TREE_LANG_FLAG_0 (decl
) = 0;
5124 TREE_LANG_FLAG_1 (decl
) = 0;
5125 TREE_LANG_FLAG_2 (decl
) = 0;
5126 TREE_LANG_FLAG_3 (decl
) = 0;
5127 TREE_LANG_FLAG_4 (decl
) = 0;
5128 TREE_LANG_FLAG_5 (decl
) = 0;
5129 TREE_LANG_FLAG_6 (decl
) = 0;
5131 free_lang_data_in_one_sizepos (&DECL_SIZE (decl
));
5132 free_lang_data_in_one_sizepos (&DECL_SIZE_UNIT (decl
));
5133 if (TREE_CODE (decl
) == FIELD_DECL
)
5135 free_lang_data_in_one_sizepos (&DECL_FIELD_OFFSET (decl
));
5136 if (TREE_CODE (DECL_CONTEXT (decl
)) == QUAL_UNION_TYPE
)
5137 DECL_QUALIFIER (decl
) = NULL_TREE
;
5140 if (TREE_CODE (decl
) == FUNCTION_DECL
)
5142 struct cgraph_node
*node
;
5143 if (!(node
= cgraph_node::get (decl
))
5144 || (!node
->definition
&& !node
->clones
))
5147 node
->release_body ();
5150 release_function_body (decl
);
5151 DECL_ARGUMENTS (decl
) = NULL
;
5152 DECL_RESULT (decl
) = NULL
;
5153 DECL_INITIAL (decl
) = error_mark_node
;
5156 if (gimple_has_body_p (decl
))
5160 /* If DECL has a gimple body, then the context for its
5161 arguments must be DECL. Otherwise, it doesn't really
5162 matter, as we will not be emitting any code for DECL. In
5163 general, there may be other instances of DECL created by
5164 the front end and since PARM_DECLs are generally shared,
5165 their DECL_CONTEXT changes as the replicas of DECL are
5166 created. The only time where DECL_CONTEXT is important
5167 is for the FUNCTION_DECLs that have a gimple body (since
5168 the PARM_DECL will be used in the function's body). */
5169 for (t
= DECL_ARGUMENTS (decl
); t
; t
= TREE_CHAIN (t
))
5170 DECL_CONTEXT (t
) = decl
;
5171 if (!DECL_FUNCTION_SPECIFIC_TARGET (decl
))
5172 DECL_FUNCTION_SPECIFIC_TARGET (decl
)
5173 = target_option_default_node
;
5174 if (!DECL_FUNCTION_SPECIFIC_OPTIMIZATION (decl
))
5175 DECL_FUNCTION_SPECIFIC_OPTIMIZATION (decl
)
5176 = optimization_default_node
;
5179 /* DECL_SAVED_TREE holds the GENERIC representation for DECL.
5180 At this point, it is not needed anymore. */
5181 DECL_SAVED_TREE (decl
) = NULL_TREE
;
5183 /* Clear the abstract origin if it refers to a method. Otherwise
5184 dwarf2out.c will ICE as we clear TYPE_METHODS and thus the
5185 origin will not be output correctly. */
5186 if (DECL_ABSTRACT_ORIGIN (decl
)
5187 && DECL_CONTEXT (DECL_ABSTRACT_ORIGIN (decl
))
5188 && RECORD_OR_UNION_TYPE_P
5189 (DECL_CONTEXT (DECL_ABSTRACT_ORIGIN (decl
))))
5190 DECL_ABSTRACT_ORIGIN (decl
) = NULL_TREE
;
5192 /* Sometimes the C++ frontend doesn't manage to transform a temporary
5193 DECL_VINDEX referring to itself into a vtable slot number as it
5194 should. Happens with functions that are copied and then forgotten
5195 about. Just clear it, it won't matter anymore. */
5196 if (DECL_VINDEX (decl
) && !tree_fits_shwi_p (DECL_VINDEX (decl
)))
5197 DECL_VINDEX (decl
) = NULL_TREE
;
5199 else if (TREE_CODE (decl
) == VAR_DECL
)
5201 if ((DECL_EXTERNAL (decl
)
5202 && (!TREE_STATIC (decl
) || !TREE_READONLY (decl
)))
5203 || (decl_function_context (decl
) && !TREE_STATIC (decl
)))
5204 DECL_INITIAL (decl
) = NULL_TREE
;
5206 else if (TREE_CODE (decl
) == TYPE_DECL
5207 || TREE_CODE (decl
) == FIELD_DECL
)
5208 DECL_INITIAL (decl
) = NULL_TREE
;
5209 else if (TREE_CODE (decl
) == TRANSLATION_UNIT_DECL
5210 && DECL_INITIAL (decl
)
5211 && TREE_CODE (DECL_INITIAL (decl
)) == BLOCK
)
5213 /* Strip builtins from the translation-unit BLOCK. We still have targets
5214 without builtin_decl_explicit support and also builtins are shared
5215 nodes and thus we can't use TREE_CHAIN in multiple lists. */
5216 tree
*nextp
= &BLOCK_VARS (DECL_INITIAL (decl
));
5220 if (TREE_CODE (var
) == FUNCTION_DECL
5221 && DECL_BUILT_IN (var
))
5222 *nextp
= TREE_CHAIN (var
);
5224 nextp
= &TREE_CHAIN (var
);
5230 /* Data used when collecting DECLs and TYPEs for language data removal. */
5232 struct free_lang_data_d
5234 /* Worklist to avoid excessive recursion. */
5237 /* Set of traversed objects. Used to avoid duplicate visits. */
5238 hash_set
<tree
> *pset
;
5240 /* Array of symbols to process with free_lang_data_in_decl. */
5243 /* Array of types to process with free_lang_data_in_type. */
5248 /* Save all language fields needed to generate proper debug information
5249 for DECL. This saves most fields cleared out by free_lang_data_in_decl. */
5252 save_debug_info_for_decl (tree t
)
5254 /*struct saved_debug_info_d *sdi;*/
5256 gcc_assert (debug_info_level
> DINFO_LEVEL_TERSE
&& t
&& DECL_P (t
));
5258 /* FIXME. Partial implementation for saving debug info removed. */
5262 /* Save all language fields needed to generate proper debug information
5263 for TYPE. This saves most fields cleared out by free_lang_data_in_type. */
5266 save_debug_info_for_type (tree t
)
5268 /*struct saved_debug_info_d *sdi;*/
5270 gcc_assert (debug_info_level
> DINFO_LEVEL_TERSE
&& t
&& TYPE_P (t
));
5272 /* FIXME. Partial implementation for saving debug info removed. */
5276 /* Add type or decl T to one of the list of tree nodes that need their
5277 language data removed. The lists are held inside FLD. */
5280 add_tree_to_fld_list (tree t
, struct free_lang_data_d
*fld
)
5284 fld
->decls
.safe_push (t
);
5285 if (debug_info_level
> DINFO_LEVEL_TERSE
)
5286 save_debug_info_for_decl (t
);
5288 else if (TYPE_P (t
))
5290 fld
->types
.safe_push (t
);
5291 if (debug_info_level
> DINFO_LEVEL_TERSE
)
5292 save_debug_info_for_type (t
);
5298 /* Push tree node T into FLD->WORKLIST. */
5301 fld_worklist_push (tree t
, struct free_lang_data_d
*fld
)
5303 if (t
&& !is_lang_specific (t
) && !fld
->pset
->contains (t
))
5304 fld
->worklist
.safe_push ((t
));
5308 /* Operand callback helper for free_lang_data_in_node. *TP is the
5309 subtree operand being considered. */
5312 find_decls_types_r (tree
*tp
, int *ws
, void *data
)
5315 struct free_lang_data_d
*fld
= (struct free_lang_data_d
*) data
;
5317 if (TREE_CODE (t
) == TREE_LIST
)
5320 /* Language specific nodes will be removed, so there is no need
5321 to gather anything under them. */
5322 if (is_lang_specific (t
))
5330 /* Note that walk_tree does not traverse every possible field in
5331 decls, so we have to do our own traversals here. */
5332 add_tree_to_fld_list (t
, fld
);
5334 fld_worklist_push (DECL_NAME (t
), fld
);
5335 fld_worklist_push (DECL_CONTEXT (t
), fld
);
5336 fld_worklist_push (DECL_SIZE (t
), fld
);
5337 fld_worklist_push (DECL_SIZE_UNIT (t
), fld
);
5339 /* We are going to remove everything under DECL_INITIAL for
5340 TYPE_DECLs. No point walking them. */
5341 if (TREE_CODE (t
) != TYPE_DECL
)
5342 fld_worklist_push (DECL_INITIAL (t
), fld
);
5344 fld_worklist_push (DECL_ATTRIBUTES (t
), fld
);
5345 fld_worklist_push (DECL_ABSTRACT_ORIGIN (t
), fld
);
5347 if (TREE_CODE (t
) == FUNCTION_DECL
)
5349 fld_worklist_push (DECL_ARGUMENTS (t
), fld
);
5350 fld_worklist_push (DECL_RESULT (t
), fld
);
5352 else if (TREE_CODE (t
) == TYPE_DECL
)
5354 fld_worklist_push (DECL_ORIGINAL_TYPE (t
), fld
);
5356 else if (TREE_CODE (t
) == FIELD_DECL
)
5358 fld_worklist_push (DECL_FIELD_OFFSET (t
), fld
);
5359 fld_worklist_push (DECL_BIT_FIELD_TYPE (t
), fld
);
5360 fld_worklist_push (DECL_FIELD_BIT_OFFSET (t
), fld
);
5361 fld_worklist_push (DECL_FCONTEXT (t
), fld
);
5364 if ((TREE_CODE (t
) == VAR_DECL
|| TREE_CODE (t
) == PARM_DECL
)
5365 && DECL_HAS_VALUE_EXPR_P (t
))
5366 fld_worklist_push (DECL_VALUE_EXPR (t
), fld
);
5368 if (TREE_CODE (t
) != FIELD_DECL
5369 && TREE_CODE (t
) != TYPE_DECL
)
5370 fld_worklist_push (TREE_CHAIN (t
), fld
);
5373 else if (TYPE_P (t
))
5375 /* Note that walk_tree does not traverse every possible field in
5376 types, so we have to do our own traversals here. */
5377 add_tree_to_fld_list (t
, fld
);
5379 if (!RECORD_OR_UNION_TYPE_P (t
))
5380 fld_worklist_push (TYPE_CACHED_VALUES (t
), fld
);
5381 fld_worklist_push (TYPE_SIZE (t
), fld
);
5382 fld_worklist_push (TYPE_SIZE_UNIT (t
), fld
);
5383 fld_worklist_push (TYPE_ATTRIBUTES (t
), fld
);
5384 fld_worklist_push (TYPE_POINTER_TO (t
), fld
);
5385 fld_worklist_push (TYPE_REFERENCE_TO (t
), fld
);
5386 fld_worklist_push (TYPE_NAME (t
), fld
);
5387 /* Do not walk TYPE_NEXT_PTR_TO or TYPE_NEXT_REF_TO. We do not stream
5388 them and thus do not and want not to reach unused pointer types
5390 if (!POINTER_TYPE_P (t
))
5391 fld_worklist_push (TYPE_MINVAL (t
), fld
);
5392 if (!RECORD_OR_UNION_TYPE_P (t
))
5393 fld_worklist_push (TYPE_MAXVAL (t
), fld
);
5394 fld_worklist_push (TYPE_MAIN_VARIANT (t
), fld
);
5395 /* Do not walk TYPE_NEXT_VARIANT. We do not stream it and thus
5396 do not and want not to reach unused variants this way. */
5397 if (TYPE_CONTEXT (t
))
5399 tree ctx
= TYPE_CONTEXT (t
);
5400 /* We adjust BLOCK TYPE_CONTEXTs to the innermost non-BLOCK one.
5401 So push that instead. */
5402 while (ctx
&& TREE_CODE (ctx
) == BLOCK
)
5403 ctx
= BLOCK_SUPERCONTEXT (ctx
);
5404 fld_worklist_push (ctx
, fld
);
5406 /* Do not walk TYPE_CANONICAL. We do not stream it and thus do not
5407 and want not to reach unused types this way. */
5409 if (RECORD_OR_UNION_TYPE_P (t
) && TYPE_BINFO (t
))
5413 FOR_EACH_VEC_ELT (*BINFO_BASE_BINFOS (TYPE_BINFO (t
)), i
, tem
)
5414 fld_worklist_push (TREE_TYPE (tem
), fld
);
5415 tem
= BINFO_VIRTUALS (TYPE_BINFO (t
));
5417 /* The Java FE overloads BINFO_VIRTUALS for its own purpose. */
5418 && TREE_CODE (tem
) == TREE_LIST
)
5421 fld_worklist_push (TREE_VALUE (tem
), fld
);
5422 tem
= TREE_CHAIN (tem
);
5426 if (RECORD_OR_UNION_TYPE_P (t
))
5429 /* Push all TYPE_FIELDS - there can be interleaving interesting
5430 and non-interesting things. */
5431 tem
= TYPE_FIELDS (t
);
5434 if (TREE_CODE (tem
) == FIELD_DECL
5435 || TREE_CODE (tem
) == TYPE_DECL
)
5436 fld_worklist_push (tem
, fld
);
5437 tem
= TREE_CHAIN (tem
);
5441 fld_worklist_push (TYPE_STUB_DECL (t
), fld
);
5444 else if (TREE_CODE (t
) == BLOCK
)
5447 for (tem
= BLOCK_VARS (t
); tem
; tem
= TREE_CHAIN (tem
))
5448 fld_worklist_push (tem
, fld
);
5449 for (tem
= BLOCK_SUBBLOCKS (t
); tem
; tem
= BLOCK_CHAIN (tem
))
5450 fld_worklist_push (tem
, fld
);
5451 fld_worklist_push (BLOCK_ABSTRACT_ORIGIN (t
), fld
);
5454 if (TREE_CODE (t
) != IDENTIFIER_NODE
5455 && CODE_CONTAINS_STRUCT (TREE_CODE (t
), TS_TYPED
))
5456 fld_worklist_push (TREE_TYPE (t
), fld
);
5462 /* Find decls and types in T. */
5465 find_decls_types (tree t
, struct free_lang_data_d
*fld
)
5469 if (!fld
->pset
->contains (t
))
5470 walk_tree (&t
, find_decls_types_r
, fld
, fld
->pset
);
5471 if (fld
->worklist
.is_empty ())
5473 t
= fld
->worklist
.pop ();
5477 /* Translate all the types in LIST with the corresponding runtime
5481 get_eh_types_for_runtime (tree list
)
5485 if (list
== NULL_TREE
)
5488 head
= build_tree_list (0, lookup_type_for_runtime (TREE_VALUE (list
)));
5490 list
= TREE_CHAIN (list
);
5493 tree n
= build_tree_list (0, lookup_type_for_runtime (TREE_VALUE (list
)));
5494 TREE_CHAIN (prev
) = n
;
5495 prev
= TREE_CHAIN (prev
);
5496 list
= TREE_CHAIN (list
);
5503 /* Find decls and types referenced in EH region R and store them in
5504 FLD->DECLS and FLD->TYPES. */
5507 find_decls_types_in_eh_region (eh_region r
, struct free_lang_data_d
*fld
)
5518 /* The types referenced in each catch must first be changed to the
5519 EH types used at runtime. This removes references to FE types
5521 for (c
= r
->u
.eh_try
.first_catch
; c
; c
= c
->next_catch
)
5523 c
->type_list
= get_eh_types_for_runtime (c
->type_list
);
5524 walk_tree (&c
->type_list
, find_decls_types_r
, fld
, fld
->pset
);
5529 case ERT_ALLOWED_EXCEPTIONS
:
5530 r
->u
.allowed
.type_list
5531 = get_eh_types_for_runtime (r
->u
.allowed
.type_list
);
5532 walk_tree (&r
->u
.allowed
.type_list
, find_decls_types_r
, fld
, fld
->pset
);
5535 case ERT_MUST_NOT_THROW
:
5536 walk_tree (&r
->u
.must_not_throw
.failure_decl
,
5537 find_decls_types_r
, fld
, fld
->pset
);
5543 /* Find decls and types referenced in cgraph node N and store them in
5544 FLD->DECLS and FLD->TYPES. Unlike pass_referenced_vars, this will
5545 look for *every* kind of DECL and TYPE node reachable from N,
5546 including those embedded inside types and decls (i.e,, TYPE_DECLs,
5547 NAMESPACE_DECLs, etc). */
5550 find_decls_types_in_node (struct cgraph_node
*n
, struct free_lang_data_d
*fld
)
5553 struct function
*fn
;
5557 find_decls_types (n
->decl
, fld
);
5559 if (!gimple_has_body_p (n
->decl
))
5562 gcc_assert (current_function_decl
== NULL_TREE
&& cfun
== NULL
);
5564 fn
= DECL_STRUCT_FUNCTION (n
->decl
);
5566 /* Traverse locals. */
5567 FOR_EACH_LOCAL_DECL (fn
, ix
, t
)
5568 find_decls_types (t
, fld
);
5570 /* Traverse EH regions in FN. */
5573 FOR_ALL_EH_REGION_FN (r
, fn
)
5574 find_decls_types_in_eh_region (r
, fld
);
5577 /* Traverse every statement in FN. */
5578 FOR_EACH_BB_FN (bb
, fn
)
5581 gimple_stmt_iterator si
;
5584 for (psi
= gsi_start_phis (bb
); !gsi_end_p (psi
); gsi_next (&psi
))
5586 gphi
*phi
= psi
.phi ();
5588 for (i
= 0; i
< gimple_phi_num_args (phi
); i
++)
5590 tree
*arg_p
= gimple_phi_arg_def_ptr (phi
, i
);
5591 find_decls_types (*arg_p
, fld
);
5595 for (si
= gsi_start_bb (bb
); !gsi_end_p (si
); gsi_next (&si
))
5597 gimple stmt
= gsi_stmt (si
);
5599 if (is_gimple_call (stmt
))
5600 find_decls_types (gimple_call_fntype (stmt
), fld
);
5602 for (i
= 0; i
< gimple_num_ops (stmt
); i
++)
5604 tree arg
= gimple_op (stmt
, i
);
5605 find_decls_types (arg
, fld
);
5612 /* Find decls and types referenced in varpool node N and store them in
5613 FLD->DECLS and FLD->TYPES. Unlike pass_referenced_vars, this will
5614 look for *every* kind of DECL and TYPE node reachable from N,
5615 including those embedded inside types and decls (i.e,, TYPE_DECLs,
5616 NAMESPACE_DECLs, etc). */
5619 find_decls_types_in_var (varpool_node
*v
, struct free_lang_data_d
*fld
)
5621 find_decls_types (v
->decl
, fld
);
5624 /* If T needs an assembler name, have one created for it. */
5627 assign_assembler_name_if_neeeded (tree t
)
5629 if (need_assembler_name_p (t
))
5631 /* When setting DECL_ASSEMBLER_NAME, the C++ mangler may emit
5632 diagnostics that use input_location to show locus
5633 information. The problem here is that, at this point,
5634 input_location is generally anchored to the end of the file
5635 (since the parser is long gone), so we don't have a good
5636 position to pin it to.
5638 To alleviate this problem, this uses the location of T's
5639 declaration. Examples of this are
5640 testsuite/g++.dg/template/cond2.C and
5641 testsuite/g++.dg/template/pr35240.C. */
5642 location_t saved_location
= input_location
;
5643 input_location
= DECL_SOURCE_LOCATION (t
);
5645 decl_assembler_name (t
);
5647 input_location
= saved_location
;
5652 /* Free language specific information for every operand and expression
5653 in every node of the call graph. This process operates in three stages:
5655 1- Every callgraph node and varpool node is traversed looking for
5656 decls and types embedded in them. This is a more exhaustive
5657 search than that done by find_referenced_vars, because it will
5658 also collect individual fields, decls embedded in types, etc.
5660 2- All the decls found are sent to free_lang_data_in_decl.
5662 3- All the types found are sent to free_lang_data_in_type.
5664 The ordering between decls and types is important because
5665 free_lang_data_in_decl sets assembler names, which includes
5666 mangling. So types cannot be freed up until assembler names have
5670 free_lang_data_in_cgraph (void)
5672 struct cgraph_node
*n
;
5674 struct free_lang_data_d fld
;
5679 /* Initialize sets and arrays to store referenced decls and types. */
5680 fld
.pset
= new hash_set
<tree
>;
5681 fld
.worklist
.create (0);
5682 fld
.decls
.create (100);
5683 fld
.types
.create (100);
5685 /* Find decls and types in the body of every function in the callgraph. */
5686 FOR_EACH_FUNCTION (n
)
5687 find_decls_types_in_node (n
, &fld
);
5689 FOR_EACH_VEC_SAFE_ELT (alias_pairs
, i
, p
)
5690 find_decls_types (p
->decl
, &fld
);
5692 /* Find decls and types in every varpool symbol. */
5693 FOR_EACH_VARIABLE (v
)
5694 find_decls_types_in_var (v
, &fld
);
5696 /* Set the assembler name on every decl found. We need to do this
5697 now because free_lang_data_in_decl will invalidate data needed
5698 for mangling. This breaks mangling on interdependent decls. */
5699 FOR_EACH_VEC_ELT (fld
.decls
, i
, t
)
5700 assign_assembler_name_if_neeeded (t
);
5702 /* Traverse every decl found freeing its language data. */
5703 FOR_EACH_VEC_ELT (fld
.decls
, i
, t
)
5704 free_lang_data_in_decl (t
);
5706 /* Traverse every type found freeing its language data. */
5707 FOR_EACH_VEC_ELT (fld
.types
, i
, t
)
5708 free_lang_data_in_type (t
);
5711 fld
.worklist
.release ();
5712 fld
.decls
.release ();
5713 fld
.types
.release ();
5717 /* Free resources that are used by FE but are not needed once they are done. */
5720 free_lang_data (void)
5724 /* If we are the LTO frontend we have freed lang-specific data already. */
5726 || (!flag_generate_lto
&& !flag_generate_offload
))
5729 /* Allocate and assign alias sets to the standard integer types
5730 while the slots are still in the way the frontends generated them. */
5731 for (i
= 0; i
< itk_none
; ++i
)
5732 if (integer_types
[i
])
5733 TYPE_ALIAS_SET (integer_types
[i
]) = get_alias_set (integer_types
[i
]);
5735 /* Traverse the IL resetting language specific information for
5736 operands, expressions, etc. */
5737 free_lang_data_in_cgraph ();
5739 /* Create gimple variants for common types. */
5740 ptrdiff_type_node
= integer_type_node
;
5741 fileptr_type_node
= ptr_type_node
;
5743 /* Reset some langhooks. Do not reset types_compatible_p, it may
5744 still be used indirectly via the get_alias_set langhook. */
5745 lang_hooks
.dwarf_name
= lhd_dwarf_name
;
5746 lang_hooks
.decl_printable_name
= gimple_decl_printable_name
;
5747 /* We do not want the default decl_assembler_name implementation,
5748 rather if we have fixed everything we want a wrapper around it
5749 asserting that all non-local symbols already got their assembler
5750 name and only produce assembler names for local symbols. Or rather
5751 make sure we never call decl_assembler_name on local symbols and
5752 devise a separate, middle-end private scheme for it. */
5754 /* Reset diagnostic machinery. */
5755 tree_diagnostics_defaults (global_dc
);
5763 const pass_data pass_data_ipa_free_lang_data
=
5765 SIMPLE_IPA_PASS
, /* type */
5766 "*free_lang_data", /* name */
5767 OPTGROUP_NONE
, /* optinfo_flags */
5768 TV_IPA_FREE_LANG_DATA
, /* tv_id */
5769 0, /* properties_required */
5770 0, /* properties_provided */
5771 0, /* properties_destroyed */
5772 0, /* todo_flags_start */
5773 0, /* todo_flags_finish */
5776 class pass_ipa_free_lang_data
: public simple_ipa_opt_pass
5779 pass_ipa_free_lang_data (gcc::context
*ctxt
)
5780 : simple_ipa_opt_pass (pass_data_ipa_free_lang_data
, ctxt
)
5783 /* opt_pass methods: */
5784 virtual unsigned int execute (function
*) { return free_lang_data (); }
5786 }; // class pass_ipa_free_lang_data
5790 simple_ipa_opt_pass
*
5791 make_pass_ipa_free_lang_data (gcc::context
*ctxt
)
5793 return new pass_ipa_free_lang_data (ctxt
);
5796 /* The backbone of is_attribute_p(). ATTR_LEN is the string length of
5797 ATTR_NAME. Also used internally by remove_attribute(). */
5799 private_is_attribute_p (const char *attr_name
, size_t attr_len
, const_tree ident
)
5801 size_t ident_len
= IDENTIFIER_LENGTH (ident
);
5803 if (ident_len
== attr_len
)
5805 if (strcmp (attr_name
, IDENTIFIER_POINTER (ident
)) == 0)
5808 else if (ident_len
== attr_len
+ 4)
5810 /* There is the possibility that ATTR is 'text' and IDENT is
5812 const char *p
= IDENTIFIER_POINTER (ident
);
5813 if (p
[0] == '_' && p
[1] == '_'
5814 && p
[ident_len
- 2] == '_' && p
[ident_len
- 1] == '_'
5815 && strncmp (attr_name
, p
+ 2, attr_len
) == 0)
5822 /* The backbone of lookup_attribute(). ATTR_LEN is the string length
5823 of ATTR_NAME, and LIST is not NULL_TREE. */
5825 private_lookup_attribute (const char *attr_name
, size_t attr_len
, tree list
)
5829 size_t ident_len
= IDENTIFIER_LENGTH (get_attribute_name (list
));
5831 if (ident_len
== attr_len
)
5833 if (!strcmp (attr_name
,
5834 IDENTIFIER_POINTER (get_attribute_name (list
))))
5837 /* TODO: If we made sure that attributes were stored in the
5838 canonical form without '__...__' (ie, as in 'text' as opposed
5839 to '__text__') then we could avoid the following case. */
5840 else if (ident_len
== attr_len
+ 4)
5842 const char *p
= IDENTIFIER_POINTER (get_attribute_name (list
));
5843 if (p
[0] == '_' && p
[1] == '_'
5844 && p
[ident_len
- 2] == '_' && p
[ident_len
- 1] == '_'
5845 && strncmp (attr_name
, p
+ 2, attr_len
) == 0)
5848 list
= TREE_CHAIN (list
);
5854 /* Given an attribute name ATTR_NAME and a list of attributes LIST,
5855 return a pointer to the attribute's list first element if the attribute
5856 starts with ATTR_NAME. ATTR_NAME must be in the form 'text' (not
5860 private_lookup_attribute_by_prefix (const char *attr_name
, size_t attr_len
,
5865 size_t ident_len
= IDENTIFIER_LENGTH (get_attribute_name (list
));
5867 if (attr_len
> ident_len
)
5869 list
= TREE_CHAIN (list
);
5873 const char *p
= IDENTIFIER_POINTER (get_attribute_name (list
));
5875 if (strncmp (attr_name
, p
, attr_len
) == 0)
5878 /* TODO: If we made sure that attributes were stored in the
5879 canonical form without '__...__' (ie, as in 'text' as opposed
5880 to '__text__') then we could avoid the following case. */
5881 if (p
[0] == '_' && p
[1] == '_' &&
5882 strncmp (attr_name
, p
+ 2, attr_len
) == 0)
5885 list
= TREE_CHAIN (list
);
5892 /* A variant of lookup_attribute() that can be used with an identifier
5893 as the first argument, and where the identifier can be either
5894 'text' or '__text__'.
5896 Given an attribute ATTR_IDENTIFIER, and a list of attributes LIST,
5897 return a pointer to the attribute's list element if the attribute
5898 is part of the list, or NULL_TREE if not found. If the attribute
5899 appears more than once, this only returns the first occurrence; the
5900 TREE_CHAIN of the return value should be passed back in if further
5901 occurrences are wanted. ATTR_IDENTIFIER must be an identifier but
5902 can be in the form 'text' or '__text__'. */
5904 lookup_ident_attribute (tree attr_identifier
, tree list
)
5906 gcc_checking_assert (TREE_CODE (attr_identifier
) == IDENTIFIER_NODE
);
5910 gcc_checking_assert (TREE_CODE (get_attribute_name (list
))
5911 == IDENTIFIER_NODE
);
5913 /* Identifiers can be compared directly for equality. */
5914 if (attr_identifier
== get_attribute_name (list
))
5917 /* If they are not equal, they may still be one in the form
5918 'text' while the other one is in the form '__text__'. TODO:
5919 If we were storing attributes in normalized 'text' form, then
5920 this could all go away and we could take full advantage of
5921 the fact that we're comparing identifiers. :-) */
5923 size_t attr_len
= IDENTIFIER_LENGTH (attr_identifier
);
5924 size_t ident_len
= IDENTIFIER_LENGTH (get_attribute_name (list
));
5926 if (ident_len
== attr_len
+ 4)
5928 const char *p
= IDENTIFIER_POINTER (get_attribute_name (list
));
5929 const char *q
= IDENTIFIER_POINTER (attr_identifier
);
5930 if (p
[0] == '_' && p
[1] == '_'
5931 && p
[ident_len
- 2] == '_' && p
[ident_len
- 1] == '_'
5932 && strncmp (q
, p
+ 2, attr_len
) == 0)
5935 else if (ident_len
+ 4 == attr_len
)
5937 const char *p
= IDENTIFIER_POINTER (get_attribute_name (list
));
5938 const char *q
= IDENTIFIER_POINTER (attr_identifier
);
5939 if (q
[0] == '_' && q
[1] == '_'
5940 && q
[attr_len
- 2] == '_' && q
[attr_len
- 1] == '_'
5941 && strncmp (q
+ 2, p
, ident_len
) == 0)
5945 list
= TREE_CHAIN (list
);
5951 /* Remove any instances of attribute ATTR_NAME in LIST and return the
5955 remove_attribute (const char *attr_name
, tree list
)
5958 size_t attr_len
= strlen (attr_name
);
5960 gcc_checking_assert (attr_name
[0] != '_');
5962 for (p
= &list
; *p
; )
5965 /* TODO: If we were storing attributes in normalized form, here
5966 we could use a simple strcmp(). */
5967 if (private_is_attribute_p (attr_name
, attr_len
, get_attribute_name (l
)))
5968 *p
= TREE_CHAIN (l
);
5970 p
= &TREE_CHAIN (l
);
5976 /* Return an attribute list that is the union of a1 and a2. */
5979 merge_attributes (tree a1
, tree a2
)
5983 /* Either one unset? Take the set one. */
5985 if ((attributes
= a1
) == 0)
5988 /* One that completely contains the other? Take it. */
5990 else if (a2
!= 0 && ! attribute_list_contained (a1
, a2
))
5992 if (attribute_list_contained (a2
, a1
))
5996 /* Pick the longest list, and hang on the other list. */
5998 if (list_length (a1
) < list_length (a2
))
5999 attributes
= a2
, a2
= a1
;
6001 for (; a2
!= 0; a2
= TREE_CHAIN (a2
))
6004 for (a
= lookup_ident_attribute (get_attribute_name (a2
),
6006 a
!= NULL_TREE
&& !attribute_value_equal (a
, a2
);
6007 a
= lookup_ident_attribute (get_attribute_name (a2
),
6012 a1
= copy_node (a2
);
6013 TREE_CHAIN (a1
) = attributes
;
6022 /* Given types T1 and T2, merge their attributes and return
6026 merge_type_attributes (tree t1
, tree t2
)
6028 return merge_attributes (TYPE_ATTRIBUTES (t1
),
6029 TYPE_ATTRIBUTES (t2
));
6032 /* Given decls OLDDECL and NEWDECL, merge their attributes and return
6036 merge_decl_attributes (tree olddecl
, tree newdecl
)
6038 return merge_attributes (DECL_ATTRIBUTES (olddecl
),
6039 DECL_ATTRIBUTES (newdecl
));
6042 #if TARGET_DLLIMPORT_DECL_ATTRIBUTES
6044 /* Specialization of merge_decl_attributes for various Windows targets.
6046 This handles the following situation:
6048 __declspec (dllimport) int foo;
6051 The second instance of `foo' nullifies the dllimport. */
6054 merge_dllimport_decl_attributes (tree old
, tree new_tree
)
6057 int delete_dllimport_p
= 1;
6059 /* What we need to do here is remove from `old' dllimport if it doesn't
6060 appear in `new'. dllimport behaves like extern: if a declaration is
6061 marked dllimport and a definition appears later, then the object
6062 is not dllimport'd. We also remove a `new' dllimport if the old list
6063 contains dllexport: dllexport always overrides dllimport, regardless
6064 of the order of declaration. */
6065 if (!VAR_OR_FUNCTION_DECL_P (new_tree
))
6066 delete_dllimport_p
= 0;
6067 else if (DECL_DLLIMPORT_P (new_tree
)
6068 && lookup_attribute ("dllexport", DECL_ATTRIBUTES (old
)))
6070 DECL_DLLIMPORT_P (new_tree
) = 0;
6071 warning (OPT_Wattributes
, "%q+D already declared with dllexport attribute: "
6072 "dllimport ignored", new_tree
);
6074 else if (DECL_DLLIMPORT_P (old
) && !DECL_DLLIMPORT_P (new_tree
))
6076 /* Warn about overriding a symbol that has already been used, e.g.:
6077 extern int __attribute__ ((dllimport)) foo;
6078 int* bar () {return &foo;}
6081 if (TREE_USED (old
))
6083 warning (0, "%q+D redeclared without dllimport attribute "
6084 "after being referenced with dll linkage", new_tree
);
6085 /* If we have used a variable's address with dllimport linkage,
6086 keep the old DECL_DLLIMPORT_P flag: the ADDR_EXPR using the
6087 decl may already have had TREE_CONSTANT computed.
6088 We still remove the attribute so that assembler code refers
6089 to '&foo rather than '_imp__foo'. */
6090 if (TREE_CODE (old
) == VAR_DECL
&& TREE_ADDRESSABLE (old
))
6091 DECL_DLLIMPORT_P (new_tree
) = 1;
6094 /* Let an inline definition silently override the external reference,
6095 but otherwise warn about attribute inconsistency. */
6096 else if (TREE_CODE (new_tree
) == VAR_DECL
6097 || !DECL_DECLARED_INLINE_P (new_tree
))
6098 warning (OPT_Wattributes
, "%q+D redeclared without dllimport attribute: "
6099 "previous dllimport ignored", new_tree
);
6102 delete_dllimport_p
= 0;
6104 a
= merge_attributes (DECL_ATTRIBUTES (old
), DECL_ATTRIBUTES (new_tree
));
6106 if (delete_dllimport_p
)
6107 a
= remove_attribute ("dllimport", a
);
6112 /* Handle a "dllimport" or "dllexport" attribute for decls; arguments as in
6113 struct attribute_spec.handler. */
6116 handle_dll_decl_attribute (tree
* pnode
, tree name
, tree args
, int flags
,
6122 if (TREE_CODE (node
) != FUNCTION_DECL
6123 && TREE_CODE (node
) != VAR_DECL
6124 && TREE_CODE (node
) != TYPE_DECL
)
6126 *no_add_attrs
= true;
6127 warning (OPT_Wattributes
, "%qE attribute ignored",
6132 if (TREE_CODE (node
) == TYPE_DECL
6133 && TREE_CODE (TREE_TYPE (node
)) != RECORD_TYPE
6134 && TREE_CODE (TREE_TYPE (node
)) != UNION_TYPE
)
6136 *no_add_attrs
= true;
6137 warning (OPT_Wattributes
, "%qE attribute ignored",
6142 is_dllimport
= is_attribute_p ("dllimport", name
);
6144 /* Report error on dllimport ambiguities seen now before they cause
6148 /* Honor any target-specific overrides. */
6149 if (!targetm
.valid_dllimport_attribute_p (node
))
6150 *no_add_attrs
= true;
6152 else if (TREE_CODE (node
) == FUNCTION_DECL
6153 && DECL_DECLARED_INLINE_P (node
))
6155 warning (OPT_Wattributes
, "inline function %q+D declared as "
6156 " dllimport: attribute ignored", node
);
6157 *no_add_attrs
= true;
6159 /* Like MS, treat definition of dllimported variables and
6160 non-inlined functions on declaration as syntax errors. */
6161 else if (TREE_CODE (node
) == FUNCTION_DECL
&& DECL_INITIAL (node
))
6163 error ("function %q+D definition is marked dllimport", node
);
6164 *no_add_attrs
= true;
6167 else if (TREE_CODE (node
) == VAR_DECL
)
6169 if (DECL_INITIAL (node
))
6171 error ("variable %q+D definition is marked dllimport",
6173 *no_add_attrs
= true;
6176 /* `extern' needn't be specified with dllimport.
6177 Specify `extern' now and hope for the best. Sigh. */
6178 DECL_EXTERNAL (node
) = 1;
6179 /* Also, implicitly give dllimport'd variables declared within
6180 a function global scope, unless declared static. */
6181 if (current_function_decl
!= NULL_TREE
&& !TREE_STATIC (node
))
6182 TREE_PUBLIC (node
) = 1;
6185 if (*no_add_attrs
== false)
6186 DECL_DLLIMPORT_P (node
) = 1;
6188 else if (TREE_CODE (node
) == FUNCTION_DECL
6189 && DECL_DECLARED_INLINE_P (node
)
6190 && flag_keep_inline_dllexport
)
6191 /* An exported function, even if inline, must be emitted. */
6192 DECL_EXTERNAL (node
) = 0;
6194 /* Report error if symbol is not accessible at global scope. */
6195 if (!TREE_PUBLIC (node
)
6196 && (TREE_CODE (node
) == VAR_DECL
6197 || TREE_CODE (node
) == FUNCTION_DECL
))
6199 error ("external linkage required for symbol %q+D because of "
6200 "%qE attribute", node
, name
);
6201 *no_add_attrs
= true;
6204 /* A dllexport'd entity must have default visibility so that other
6205 program units (shared libraries or the main executable) can see
6206 it. A dllimport'd entity must have default visibility so that
6207 the linker knows that undefined references within this program
6208 unit can be resolved by the dynamic linker. */
6211 if (DECL_VISIBILITY_SPECIFIED (node
)
6212 && DECL_VISIBILITY (node
) != VISIBILITY_DEFAULT
)
6213 error ("%qE implies default visibility, but %qD has already "
6214 "been declared with a different visibility",
6216 DECL_VISIBILITY (node
) = VISIBILITY_DEFAULT
;
6217 DECL_VISIBILITY_SPECIFIED (node
) = 1;
6224 /* Handle a "dllimport" or "dllexport" attribute for types; arguments as in
6225 struct attribute_spec.handler. */
6228 handle_dll_type_attribute (tree
* pnode
, tree name
, tree args
, int flags
,
6233 /* These attributes may apply to structure and union types being created,
6234 but otherwise should pass to the declaration involved. */
6235 if (flags
& ((int) ATTR_FLAG_DECL_NEXT
| (int) ATTR_FLAG_FUNCTION_NEXT
6236 | (int) ATTR_FLAG_ARRAY_NEXT
))
6238 *no_add_attrs
= true;
6239 return tree_cons (name
, args
, NULL_TREE
);
6242 if (TREE_CODE (node
) != RECORD_TYPE
&& TREE_CODE (node
) != UNION_TYPE
)
6244 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
6245 *no_add_attrs
= true;
6249 if (!TYPE_NAME (node
))
6252 return handle_dll_decl_attribute (&TYPE_NAME (node
), name
, args
, flags
,
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_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_build_call_array_loc (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 tree t
= TREE_TYPE (target
);
11868 gcc_checking_assert (TREE_CODE (t
) == POINTER_TYPE
);
11870 if (TREE_CODE (t
) == FUNCTION_TYPE
)
11872 gcc_checking_assert (TREE_CODE (t
) == METHOD_TYPE
);
11873 /* If we do not have BINFO associated, it means that type was built
11874 without devirtualization enabled. Do not consider this a virtual
11876 if (!TYPE_BINFO (obj_type_ref_class (target
)))
11881 /* REF is OBJ_TYPE_REF, return the class the ref corresponds to. */
11884 obj_type_ref_class (tree ref
)
11886 gcc_checking_assert (TREE_CODE (ref
) == OBJ_TYPE_REF
);
11887 ref
= TREE_TYPE (ref
);
11888 gcc_checking_assert (TREE_CODE (ref
) == POINTER_TYPE
);
11889 ref
= TREE_TYPE (ref
);
11890 /* We look for type THIS points to. ObjC also builds
11891 OBJ_TYPE_REF with non-method calls, Their first parameter
11892 ID however also corresponds to class type. */
11893 gcc_checking_assert (TREE_CODE (ref
) == METHOD_TYPE
11894 || TREE_CODE (ref
) == FUNCTION_TYPE
);
11895 ref
= TREE_VALUE (TYPE_ARG_TYPES (ref
));
11896 gcc_checking_assert (TREE_CODE (ref
) == POINTER_TYPE
);
11897 return TREE_TYPE (ref
);
11900 /* Return true if T is in anonymous namespace. */
11903 type_in_anonymous_namespace_p (const_tree t
)
11905 /* TREE_PUBLIC of TYPE_STUB_DECL may not be properly set for
11906 bulitin types; those have CONTEXT NULL. */
11907 if (!TYPE_CONTEXT (t
))
11909 return (TYPE_STUB_DECL (t
) && !TREE_PUBLIC (TYPE_STUB_DECL (t
)));
11912 /* Try to find a base info of BINFO that would have its field decl at offset
11913 OFFSET within the BINFO type and which is of EXPECTED_TYPE. If it can be
11914 found, return, otherwise return NULL_TREE. */
11917 get_binfo_at_offset (tree binfo
, HOST_WIDE_INT offset
, tree expected_type
)
11919 tree type
= BINFO_TYPE (binfo
);
11923 HOST_WIDE_INT pos
, size
;
11927 if (types_same_for_odr (type
, expected_type
))
11932 for (fld
= TYPE_FIELDS (type
); fld
; fld
= DECL_CHAIN (fld
))
11934 if (TREE_CODE (fld
) != FIELD_DECL
|| !DECL_ARTIFICIAL (fld
))
11937 pos
= int_bit_position (fld
);
11938 size
= tree_to_uhwi (DECL_SIZE (fld
));
11939 if (pos
<= offset
&& (pos
+ size
) > offset
)
11942 if (!fld
|| TREE_CODE (TREE_TYPE (fld
)) != RECORD_TYPE
)
11945 /* Offset 0 indicates the primary base, whose vtable contents are
11946 represented in the binfo for the derived class. */
11947 else if (offset
!= 0)
11949 tree base_binfo
, binfo2
= binfo
;
11951 /* Find BINFO corresponding to FLD. This is bit harder
11952 by a fact that in virtual inheritance we may need to walk down
11953 the non-virtual inheritance chain. */
11956 tree containing_binfo
= NULL
, found_binfo
= NULL
;
11957 for (i
= 0; BINFO_BASE_ITERATE (binfo2
, i
, base_binfo
); i
++)
11958 if (types_same_for_odr (TREE_TYPE (base_binfo
), TREE_TYPE (fld
)))
11960 found_binfo
= base_binfo
;
11964 if ((tree_to_shwi (BINFO_OFFSET (base_binfo
))
11965 - tree_to_shwi (BINFO_OFFSET (binfo
)))
11966 * BITS_PER_UNIT
< pos
11967 /* Rule out types with no virtual methods or we can get confused
11968 here by zero sized bases. */
11969 && TYPE_BINFO (BINFO_TYPE (base_binfo
))
11970 && BINFO_VTABLE (TYPE_BINFO (BINFO_TYPE (base_binfo
)))
11971 && (!containing_binfo
11972 || (tree_to_shwi (BINFO_OFFSET (containing_binfo
))
11973 < tree_to_shwi (BINFO_OFFSET (base_binfo
)))))
11974 containing_binfo
= base_binfo
;
11977 binfo
= found_binfo
;
11980 if (!containing_binfo
)
11982 binfo2
= containing_binfo
;
11986 type
= TREE_TYPE (fld
);
11991 /* Returns true if X is a typedef decl. */
11994 is_typedef_decl (tree x
)
11996 return (x
&& TREE_CODE (x
) == TYPE_DECL
11997 && DECL_ORIGINAL_TYPE (x
) != NULL_TREE
);
12000 /* Returns true iff TYPE is a type variant created for a typedef. */
12003 typedef_variant_p (tree type
)
12005 return is_typedef_decl (TYPE_NAME (type
));
12008 /* Warn about a use of an identifier which was marked deprecated. */
12010 warn_deprecated_use (tree node
, tree attr
)
12014 if (node
== 0 || !warn_deprecated_decl
)
12020 attr
= DECL_ATTRIBUTES (node
);
12021 else if (TYPE_P (node
))
12023 tree decl
= TYPE_STUB_DECL (node
);
12025 attr
= lookup_attribute ("deprecated",
12026 TYPE_ATTRIBUTES (TREE_TYPE (decl
)));
12031 attr
= lookup_attribute ("deprecated", attr
);
12034 msg
= TREE_STRING_POINTER (TREE_VALUE (TREE_VALUE (attr
)));
12042 w
= warning (OPT_Wdeprecated_declarations
,
12043 "%qD is deprecated: %s", node
, msg
);
12045 w
= warning (OPT_Wdeprecated_declarations
,
12046 "%qD is deprecated", node
);
12048 inform (DECL_SOURCE_LOCATION (node
), "declared here");
12050 else if (TYPE_P (node
))
12052 tree what
= NULL_TREE
;
12053 tree decl
= TYPE_STUB_DECL (node
);
12055 if (TYPE_NAME (node
))
12057 if (TREE_CODE (TYPE_NAME (node
)) == IDENTIFIER_NODE
)
12058 what
= TYPE_NAME (node
);
12059 else if (TREE_CODE (TYPE_NAME (node
)) == TYPE_DECL
12060 && DECL_NAME (TYPE_NAME (node
)))
12061 what
= DECL_NAME (TYPE_NAME (node
));
12069 w
= warning (OPT_Wdeprecated_declarations
,
12070 "%qE is deprecated: %s", what
, msg
);
12072 w
= warning (OPT_Wdeprecated_declarations
,
12073 "%qE is deprecated", what
);
12078 w
= warning (OPT_Wdeprecated_declarations
,
12079 "type is deprecated: %s", msg
);
12081 w
= warning (OPT_Wdeprecated_declarations
,
12082 "type is deprecated");
12085 inform (DECL_SOURCE_LOCATION (decl
), "declared here");
12092 warning (OPT_Wdeprecated_declarations
, "%qE is deprecated: %s",
12095 warning (OPT_Wdeprecated_declarations
, "%qE is deprecated", what
);
12100 warning (OPT_Wdeprecated_declarations
, "type is deprecated: %s",
12103 warning (OPT_Wdeprecated_declarations
, "type is deprecated");
12109 /* Return true if REF has a COMPONENT_REF with a bit-field field declaration
12110 somewhere in it. */
12113 contains_bitfld_component_ref_p (const_tree ref
)
12115 while (handled_component_p (ref
))
12117 if (TREE_CODE (ref
) == COMPONENT_REF
12118 && DECL_BIT_FIELD (TREE_OPERAND (ref
, 1)))
12120 ref
= TREE_OPERAND (ref
, 0);
12126 /* Try to determine whether a TRY_CATCH expression can fall through.
12127 This is a subroutine of block_may_fallthru. */
12130 try_catch_may_fallthru (const_tree stmt
)
12132 tree_stmt_iterator i
;
12134 /* If the TRY block can fall through, the whole TRY_CATCH can
12136 if (block_may_fallthru (TREE_OPERAND (stmt
, 0)))
12139 i
= tsi_start (TREE_OPERAND (stmt
, 1));
12140 switch (TREE_CODE (tsi_stmt (i
)))
12143 /* We expect to see a sequence of CATCH_EXPR trees, each with a
12144 catch expression and a body. The whole TRY_CATCH may fall
12145 through iff any of the catch bodies falls through. */
12146 for (; !tsi_end_p (i
); tsi_next (&i
))
12148 if (block_may_fallthru (CATCH_BODY (tsi_stmt (i
))))
12153 case EH_FILTER_EXPR
:
12154 /* The exception filter expression only matters if there is an
12155 exception. If the exception does not match EH_FILTER_TYPES,
12156 we will execute EH_FILTER_FAILURE, and we will fall through
12157 if that falls through. If the exception does match
12158 EH_FILTER_TYPES, the stack unwinder will continue up the
12159 stack, so we will not fall through. We don't know whether we
12160 will throw an exception which matches EH_FILTER_TYPES or not,
12161 so we just ignore EH_FILTER_TYPES and assume that we might
12162 throw an exception which doesn't match. */
12163 return block_may_fallthru (EH_FILTER_FAILURE (tsi_stmt (i
)));
12166 /* This case represents statements to be executed when an
12167 exception occurs. Those statements are implicitly followed
12168 by a RESX statement to resume execution after the exception.
12169 So in this case the TRY_CATCH never falls through. */
12174 /* Try to determine if we can fall out of the bottom of BLOCK. This guess
12175 need not be 100% accurate; simply be conservative and return true if we
12176 don't know. This is used only to avoid stupidly generating extra code.
12177 If we're wrong, we'll just delete the extra code later. */
12180 block_may_fallthru (const_tree block
)
12182 /* This CONST_CAST is okay because expr_last returns its argument
12183 unmodified and we assign it to a const_tree. */
12184 const_tree stmt
= expr_last (CONST_CAST_TREE (block
));
12186 switch (stmt
? TREE_CODE (stmt
) : ERROR_MARK
)
12190 /* Easy cases. If the last statement of the block implies
12191 control transfer, then we can't fall through. */
12195 /* If SWITCH_LABELS is set, this is lowered, and represents a
12196 branch to a selected label and hence can not fall through.
12197 Otherwise SWITCH_BODY is set, and the switch can fall
12199 return SWITCH_LABELS (stmt
) == NULL_TREE
;
12202 if (block_may_fallthru (COND_EXPR_THEN (stmt
)))
12204 return block_may_fallthru (COND_EXPR_ELSE (stmt
));
12207 return block_may_fallthru (BIND_EXPR_BODY (stmt
));
12209 case TRY_CATCH_EXPR
:
12210 return try_catch_may_fallthru (stmt
);
12212 case TRY_FINALLY_EXPR
:
12213 /* The finally clause is always executed after the try clause,
12214 so if it does not fall through, then the try-finally will not
12215 fall through. Otherwise, if the try clause does not fall
12216 through, then when the finally clause falls through it will
12217 resume execution wherever the try clause was going. So the
12218 whole try-finally will only fall through if both the try
12219 clause and the finally clause fall through. */
12220 return (block_may_fallthru (TREE_OPERAND (stmt
, 0))
12221 && block_may_fallthru (TREE_OPERAND (stmt
, 1)));
12224 if (TREE_CODE (TREE_OPERAND (stmt
, 1)) == CALL_EXPR
)
12225 stmt
= TREE_OPERAND (stmt
, 1);
12231 /* Functions that do not return do not fall through. */
12232 return (call_expr_flags (stmt
) & ECF_NORETURN
) == 0;
12234 case CLEANUP_POINT_EXPR
:
12235 return block_may_fallthru (TREE_OPERAND (stmt
, 0));
12238 return block_may_fallthru (TREE_OPERAND (stmt
, 1));
12244 return lang_hooks
.block_may_fallthru (stmt
);
12248 /* True if we are using EH to handle cleanups. */
12249 static bool using_eh_for_cleanups_flag
= false;
12251 /* This routine is called from front ends to indicate eh should be used for
12254 using_eh_for_cleanups (void)
12256 using_eh_for_cleanups_flag
= true;
12259 /* Query whether EH is used for cleanups. */
12261 using_eh_for_cleanups_p (void)
12263 return using_eh_for_cleanups_flag
;
12266 /* Wrapper for tree_code_name to ensure that tree code is valid */
12268 get_tree_code_name (enum tree_code code
)
12270 const char *invalid
= "<invalid tree code>";
12272 if (code
>= MAX_TREE_CODES
)
12275 return tree_code_name
[code
];
12278 /* Drops the TREE_OVERFLOW flag from T. */
12281 drop_tree_overflow (tree t
)
12283 gcc_checking_assert (TREE_OVERFLOW (t
));
12285 /* For tree codes with a sharing machinery re-build the result. */
12286 if (TREE_CODE (t
) == INTEGER_CST
)
12287 return wide_int_to_tree (TREE_TYPE (t
), t
);
12289 /* Otherwise, as all tcc_constants are possibly shared, copy the node
12290 and drop the flag. */
12292 TREE_OVERFLOW (t
) = 0;
12296 /* Given a memory reference expression T, return its base address.
12297 The base address of a memory reference expression is the main
12298 object being referenced. For instance, the base address for
12299 'array[i].fld[j]' is 'array'. You can think of this as stripping
12300 away the offset part from a memory address.
12302 This function calls handled_component_p to strip away all the inner
12303 parts of the memory reference until it reaches the base object. */
12306 get_base_address (tree t
)
12308 while (handled_component_p (t
))
12309 t
= TREE_OPERAND (t
, 0);
12311 if ((TREE_CODE (t
) == MEM_REF
12312 || TREE_CODE (t
) == TARGET_MEM_REF
)
12313 && TREE_CODE (TREE_OPERAND (t
, 0)) == ADDR_EXPR
)
12314 t
= TREE_OPERAND (TREE_OPERAND (t
, 0), 0);
12316 /* ??? Either the alias oracle or all callers need to properly deal
12317 with WITH_SIZE_EXPRs before we can look through those. */
12318 if (TREE_CODE (t
) == WITH_SIZE_EXPR
)
12324 /* Return the machine mode of T. For vectors, returns the mode of the
12325 inner type. The main use case is to feed the result to HONOR_NANS,
12326 avoiding the BLKmode that a direct TYPE_MODE (T) might return. */
12329 element_mode (const_tree t
)
12333 if (VECTOR_TYPE_P (t
) || TREE_CODE (t
) == COMPLEX_TYPE
)
12335 return TYPE_MODE (t
);
12338 #include "gt-tree.h"