1 /* Language-independent node constructors for parse phase of GNU compiler.
2 Copyright (C) 1987, 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010,
4 2011, 2012 Free Software Foundation, Inc.
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 3, or (at your option) any later
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
22 /* This file contains the low level primitives for operating on tree nodes,
23 including allocation, list operations, interning of identifiers,
24 construction of data type nodes and statement nodes,
25 and construction of type conversion nodes. It also contains
26 tables index by tree code that describe how to take apart
29 It is intended to be language-independent, but occasionally
30 calls language-dependent routines defined (for C) in typecheck.c. */
34 #include "coretypes.h"
44 #include "filenames.h"
47 #include "common/common-target.h"
48 #include "langhooks.h"
49 #include "tree-inline.h"
50 #include "tree-iterator.h"
51 #include "basic-block.h"
52 #include "tree-flow.h"
54 #include "pointer-set.h"
55 #include "tree-pass.h"
56 #include "langhooks-def.h"
57 #include "diagnostic.h"
58 #include "tree-diagnostic.h"
59 #include "tree-pretty-print.h"
66 /* Tree code classes. */
68 #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) TYPE,
69 #define END_OF_BASE_TREE_CODES tcc_exceptional,
71 const enum tree_code_class tree_code_type
[] = {
72 #include "all-tree.def"
76 #undef END_OF_BASE_TREE_CODES
78 /* Table indexed by tree code giving number of expression
79 operands beyond the fixed part of the node structure.
80 Not used for types or decls. */
82 #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) LENGTH,
83 #define END_OF_BASE_TREE_CODES 0,
85 const unsigned char tree_code_length
[] = {
86 #include "all-tree.def"
90 #undef END_OF_BASE_TREE_CODES
92 /* Names of tree components.
93 Used for printing out the tree and error messages. */
94 #define DEFTREECODE(SYM, NAME, TYPE, LEN) NAME,
95 #define END_OF_BASE_TREE_CODES "@dummy",
97 const char *const tree_code_name
[] = {
98 #include "all-tree.def"
102 #undef END_OF_BASE_TREE_CODES
104 /* Each tree code class has an associated string representation.
105 These must correspond to the tree_code_class entries. */
107 const char *const tree_code_class_strings
[] =
122 /* obstack.[ch] explicitly declined to prototype this. */
123 extern int _obstack_allocated_p (struct obstack
*h
, void *obj
);
125 #ifdef GATHER_STATISTICS
126 /* Statistics-gathering stuff. */
128 static int tree_code_counts
[MAX_TREE_CODES
];
129 int tree_node_counts
[(int) all_kinds
];
130 int tree_node_sizes
[(int) all_kinds
];
132 /* Keep in sync with tree.h:enum tree_node_kind. */
133 static const char * const tree_node_kind_names
[] = {
151 #endif /* GATHER_STATISTICS */
153 /* Unique id for next decl created. */
154 static GTY(()) int next_decl_uid
;
155 /* Unique id for next type created. */
156 static GTY(()) int next_type_uid
= 1;
157 /* Unique id for next debug decl created. Use negative numbers,
158 to catch erroneous uses. */
159 static GTY(()) int next_debug_decl_uid
;
161 /* Since we cannot rehash a type after it is in the table, we have to
162 keep the hash code. */
164 struct GTY(()) type_hash
{
169 /* Initial size of the hash table (rounded to next prime). */
170 #define TYPE_HASH_INITIAL_SIZE 1000
172 /* Now here is the hash table. When recording a type, it is added to
173 the slot whose index is the hash code. Note that the hash table is
174 used for several kinds of types (function types, array types and
175 array index range types, for now). While all these live in the
176 same table, they are completely independent, and the hash code is
177 computed differently for each of these. */
179 static GTY ((if_marked ("type_hash_marked_p"), param_is (struct type_hash
)))
180 htab_t type_hash_table
;
182 /* Hash table and temporary node for larger integer const values. */
183 static GTY (()) tree int_cst_node
;
184 static GTY ((if_marked ("ggc_marked_p"), param_is (union tree_node
)))
185 htab_t int_cst_hash_table
;
187 /* Hash table for optimization flags and target option flags. Use the same
188 hash table for both sets of options. Nodes for building the current
189 optimization and target option nodes. The assumption is most of the time
190 the options created will already be in the hash table, so we avoid
191 allocating and freeing up a node repeatably. */
192 static GTY (()) tree cl_optimization_node
;
193 static GTY (()) tree cl_target_option_node
;
194 static GTY ((if_marked ("ggc_marked_p"), param_is (union tree_node
)))
195 htab_t cl_option_hash_table
;
197 /* General tree->tree mapping structure for use in hash tables. */
200 static GTY ((if_marked ("tree_decl_map_marked_p"), param_is (struct tree_decl_map
)))
201 htab_t debug_expr_for_decl
;
203 static GTY ((if_marked ("tree_decl_map_marked_p"), param_is (struct tree_decl_map
)))
204 htab_t value_expr_for_decl
;
206 static GTY ((if_marked ("tree_vec_map_marked_p"), param_is (struct tree_vec_map
)))
207 htab_t debug_args_for_decl
;
209 static GTY ((if_marked ("tree_priority_map_marked_p"),
210 param_is (struct tree_priority_map
)))
211 htab_t init_priority_for_decl
;
213 static void set_type_quals (tree
, int);
214 static int type_hash_eq (const void *, const void *);
215 static hashval_t
type_hash_hash (const void *);
216 static hashval_t
int_cst_hash_hash (const void *);
217 static int int_cst_hash_eq (const void *, const void *);
218 static hashval_t
cl_option_hash_hash (const void *);
219 static int cl_option_hash_eq (const void *, const void *);
220 static void print_type_hash_statistics (void);
221 static void print_debug_expr_statistics (void);
222 static void print_value_expr_statistics (void);
223 static int type_hash_marked_p (const void *);
224 static unsigned int type_hash_list (const_tree
, hashval_t
);
225 static unsigned int attribute_hash_list (const_tree
, hashval_t
);
227 tree global_trees
[TI_MAX
];
228 tree integer_types
[itk_none
];
230 unsigned char tree_contains_struct
[MAX_TREE_CODES
][64];
232 /* Number of operands for each OpenMP clause. */
233 unsigned const char omp_clause_num_ops
[] =
235 0, /* OMP_CLAUSE_ERROR */
236 1, /* OMP_CLAUSE_PRIVATE */
237 1, /* OMP_CLAUSE_SHARED */
238 1, /* OMP_CLAUSE_FIRSTPRIVATE */
239 2, /* OMP_CLAUSE_LASTPRIVATE */
240 4, /* OMP_CLAUSE_REDUCTION */
241 1, /* OMP_CLAUSE_COPYIN */
242 1, /* OMP_CLAUSE_COPYPRIVATE */
243 1, /* OMP_CLAUSE_IF */
244 1, /* OMP_CLAUSE_NUM_THREADS */
245 1, /* OMP_CLAUSE_SCHEDULE */
246 0, /* OMP_CLAUSE_NOWAIT */
247 0, /* OMP_CLAUSE_ORDERED */
248 0, /* OMP_CLAUSE_DEFAULT */
249 3, /* OMP_CLAUSE_COLLAPSE */
250 0, /* OMP_CLAUSE_UNTIED */
251 1, /* OMP_CLAUSE_FINAL */
252 0 /* OMP_CLAUSE_MERGEABLE */
255 const char * const omp_clause_code_name
[] =
278 /* Return the tree node structure used by tree code CODE. */
280 static inline enum tree_node_structure_enum
281 tree_node_structure_for_code (enum tree_code code
)
283 switch (TREE_CODE_CLASS (code
))
285 case tcc_declaration
:
290 return TS_FIELD_DECL
;
296 return TS_LABEL_DECL
;
298 return TS_RESULT_DECL
;
299 case DEBUG_EXPR_DECL
:
302 return TS_CONST_DECL
;
306 return TS_FUNCTION_DECL
;
307 case TRANSLATION_UNIT_DECL
:
308 return TS_TRANSLATION_UNIT_DECL
;
310 return TS_DECL_NON_COMMON
;
314 return TS_TYPE_NON_COMMON
;
323 default: /* tcc_constant and tcc_exceptional */
328 /* tcc_constant cases. */
329 case INTEGER_CST
: return TS_INT_CST
;
330 case REAL_CST
: return TS_REAL_CST
;
331 case FIXED_CST
: return TS_FIXED_CST
;
332 case COMPLEX_CST
: return TS_COMPLEX
;
333 case VECTOR_CST
: return TS_VECTOR
;
334 case STRING_CST
: return TS_STRING
;
335 /* tcc_exceptional cases. */
336 case ERROR_MARK
: return TS_COMMON
;
337 case IDENTIFIER_NODE
: return TS_IDENTIFIER
;
338 case TREE_LIST
: return TS_LIST
;
339 case TREE_VEC
: return TS_VEC
;
340 case SSA_NAME
: return TS_SSA_NAME
;
341 case PLACEHOLDER_EXPR
: return TS_COMMON
;
342 case STATEMENT_LIST
: return TS_STATEMENT_LIST
;
343 case BLOCK
: return TS_BLOCK
;
344 case CONSTRUCTOR
: return TS_CONSTRUCTOR
;
345 case TREE_BINFO
: return TS_BINFO
;
346 case OMP_CLAUSE
: return TS_OMP_CLAUSE
;
347 case OPTIMIZATION_NODE
: return TS_OPTIMIZATION
;
348 case TARGET_OPTION_NODE
: return TS_TARGET_OPTION
;
356 /* Initialize tree_contains_struct to describe the hierarchy of tree
360 initialize_tree_contains_struct (void)
364 for (i
= ERROR_MARK
; i
< LAST_AND_UNUSED_TREE_CODE
; i
++)
367 enum tree_node_structure_enum ts_code
;
369 code
= (enum tree_code
) i
;
370 ts_code
= tree_node_structure_for_code (code
);
372 /* Mark the TS structure itself. */
373 tree_contains_struct
[code
][ts_code
] = 1;
375 /* Mark all the structures that TS is derived from. */
393 case TS_STATEMENT_LIST
:
394 MARK_TS_TYPED (code
);
398 case TS_DECL_MINIMAL
:
404 case TS_OPTIMIZATION
:
405 case TS_TARGET_OPTION
:
406 MARK_TS_COMMON (code
);
409 case TS_TYPE_WITH_LANG_SPECIFIC
:
410 MARK_TS_TYPE_COMMON (code
);
413 case TS_TYPE_NON_COMMON
:
414 MARK_TS_TYPE_WITH_LANG_SPECIFIC (code
);
418 MARK_TS_DECL_MINIMAL (code
);
423 MARK_TS_DECL_COMMON (code
);
426 case TS_DECL_NON_COMMON
:
427 MARK_TS_DECL_WITH_VIS (code
);
430 case TS_DECL_WITH_VIS
:
434 MARK_TS_DECL_WRTL (code
);
438 MARK_TS_DECL_COMMON (code
);
442 MARK_TS_DECL_WITH_VIS (code
);
446 case TS_FUNCTION_DECL
:
447 MARK_TS_DECL_NON_COMMON (code
);
450 case TS_TRANSLATION_UNIT_DECL
:
451 MARK_TS_DECL_COMMON (code
);
459 /* Basic consistency checks for attributes used in fold. */
460 gcc_assert (tree_contains_struct
[FUNCTION_DECL
][TS_DECL_NON_COMMON
]);
461 gcc_assert (tree_contains_struct
[TYPE_DECL
][TS_DECL_NON_COMMON
]);
462 gcc_assert (tree_contains_struct
[CONST_DECL
][TS_DECL_COMMON
]);
463 gcc_assert (tree_contains_struct
[VAR_DECL
][TS_DECL_COMMON
]);
464 gcc_assert (tree_contains_struct
[PARM_DECL
][TS_DECL_COMMON
]);
465 gcc_assert (tree_contains_struct
[RESULT_DECL
][TS_DECL_COMMON
]);
466 gcc_assert (tree_contains_struct
[FUNCTION_DECL
][TS_DECL_COMMON
]);
467 gcc_assert (tree_contains_struct
[TYPE_DECL
][TS_DECL_COMMON
]);
468 gcc_assert (tree_contains_struct
[TRANSLATION_UNIT_DECL
][TS_DECL_COMMON
]);
469 gcc_assert (tree_contains_struct
[LABEL_DECL
][TS_DECL_COMMON
]);
470 gcc_assert (tree_contains_struct
[FIELD_DECL
][TS_DECL_COMMON
]);
471 gcc_assert (tree_contains_struct
[VAR_DECL
][TS_DECL_WRTL
]);
472 gcc_assert (tree_contains_struct
[PARM_DECL
][TS_DECL_WRTL
]);
473 gcc_assert (tree_contains_struct
[RESULT_DECL
][TS_DECL_WRTL
]);
474 gcc_assert (tree_contains_struct
[FUNCTION_DECL
][TS_DECL_WRTL
]);
475 gcc_assert (tree_contains_struct
[LABEL_DECL
][TS_DECL_WRTL
]);
476 gcc_assert (tree_contains_struct
[CONST_DECL
][TS_DECL_MINIMAL
]);
477 gcc_assert (tree_contains_struct
[VAR_DECL
][TS_DECL_MINIMAL
]);
478 gcc_assert (tree_contains_struct
[PARM_DECL
][TS_DECL_MINIMAL
]);
479 gcc_assert (tree_contains_struct
[RESULT_DECL
][TS_DECL_MINIMAL
]);
480 gcc_assert (tree_contains_struct
[FUNCTION_DECL
][TS_DECL_MINIMAL
]);
481 gcc_assert (tree_contains_struct
[TYPE_DECL
][TS_DECL_MINIMAL
]);
482 gcc_assert (tree_contains_struct
[TRANSLATION_UNIT_DECL
][TS_DECL_MINIMAL
]);
483 gcc_assert (tree_contains_struct
[LABEL_DECL
][TS_DECL_MINIMAL
]);
484 gcc_assert (tree_contains_struct
[FIELD_DECL
][TS_DECL_MINIMAL
]);
485 gcc_assert (tree_contains_struct
[VAR_DECL
][TS_DECL_WITH_VIS
]);
486 gcc_assert (tree_contains_struct
[FUNCTION_DECL
][TS_DECL_WITH_VIS
]);
487 gcc_assert (tree_contains_struct
[TYPE_DECL
][TS_DECL_WITH_VIS
]);
488 gcc_assert (tree_contains_struct
[VAR_DECL
][TS_VAR_DECL
]);
489 gcc_assert (tree_contains_struct
[FIELD_DECL
][TS_FIELD_DECL
]);
490 gcc_assert (tree_contains_struct
[PARM_DECL
][TS_PARM_DECL
]);
491 gcc_assert (tree_contains_struct
[LABEL_DECL
][TS_LABEL_DECL
]);
492 gcc_assert (tree_contains_struct
[RESULT_DECL
][TS_RESULT_DECL
]);
493 gcc_assert (tree_contains_struct
[CONST_DECL
][TS_CONST_DECL
]);
494 gcc_assert (tree_contains_struct
[TYPE_DECL
][TS_TYPE_DECL
]);
495 gcc_assert (tree_contains_struct
[FUNCTION_DECL
][TS_FUNCTION_DECL
]);
496 gcc_assert (tree_contains_struct
[IMPORTED_DECL
][TS_DECL_MINIMAL
]);
497 gcc_assert (tree_contains_struct
[IMPORTED_DECL
][TS_DECL_COMMON
]);
506 /* Initialize the hash table of types. */
507 type_hash_table
= htab_create_ggc (TYPE_HASH_INITIAL_SIZE
, type_hash_hash
,
510 debug_expr_for_decl
= htab_create_ggc (512, tree_decl_map_hash
,
511 tree_decl_map_eq
, 0);
513 value_expr_for_decl
= htab_create_ggc (512, tree_decl_map_hash
,
514 tree_decl_map_eq
, 0);
515 init_priority_for_decl
= htab_create_ggc (512, tree_priority_map_hash
,
516 tree_priority_map_eq
, 0);
518 int_cst_hash_table
= htab_create_ggc (1024, int_cst_hash_hash
,
519 int_cst_hash_eq
, NULL
);
521 int_cst_node
= make_node (INTEGER_CST
);
523 cl_option_hash_table
= htab_create_ggc (64, cl_option_hash_hash
,
524 cl_option_hash_eq
, NULL
);
526 cl_optimization_node
= make_node (OPTIMIZATION_NODE
);
527 cl_target_option_node
= make_node (TARGET_OPTION_NODE
);
529 /* Initialize the tree_contains_struct array. */
530 initialize_tree_contains_struct ();
531 lang_hooks
.init_ts ();
535 /* The name of the object as the assembler will see it (but before any
536 translations made by ASM_OUTPUT_LABELREF). Often this is the same
537 as DECL_NAME. It is an IDENTIFIER_NODE. */
539 decl_assembler_name (tree decl
)
541 if (!DECL_ASSEMBLER_NAME_SET_P (decl
))
542 lang_hooks
.set_decl_assembler_name (decl
);
543 return DECL_WITH_VIS_CHECK (decl
)->decl_with_vis
.assembler_name
;
546 /* Compare ASMNAME with the DECL_ASSEMBLER_NAME of DECL. */
549 decl_assembler_name_equal (tree decl
, const_tree asmname
)
551 tree decl_asmname
= DECL_ASSEMBLER_NAME (decl
);
552 const char *decl_str
;
553 const char *asmname_str
;
556 if (decl_asmname
== asmname
)
559 decl_str
= IDENTIFIER_POINTER (decl_asmname
);
560 asmname_str
= IDENTIFIER_POINTER (asmname
);
563 /* If the target assembler name was set by the user, things are trickier.
564 We have a leading '*' to begin with. After that, it's arguable what
565 is the correct thing to do with -fleading-underscore. Arguably, we've
566 historically been doing the wrong thing in assemble_alias by always
567 printing the leading underscore. Since we're not changing that, make
568 sure user_label_prefix follows the '*' before matching. */
569 if (decl_str
[0] == '*')
571 size_t ulp_len
= strlen (user_label_prefix
);
577 else if (strncmp (decl_str
, user_label_prefix
, ulp_len
) == 0)
578 decl_str
+= ulp_len
, test
=true;
582 if (asmname_str
[0] == '*')
584 size_t ulp_len
= strlen (user_label_prefix
);
590 else if (strncmp (asmname_str
, user_label_prefix
, ulp_len
) == 0)
591 asmname_str
+= ulp_len
, test
=true;
598 return strcmp (decl_str
, asmname_str
) == 0;
601 /* Hash asmnames ignoring the user specified marks. */
604 decl_assembler_name_hash (const_tree asmname
)
606 if (IDENTIFIER_POINTER (asmname
)[0] == '*')
608 const char *decl_str
= IDENTIFIER_POINTER (asmname
) + 1;
609 size_t ulp_len
= strlen (user_label_prefix
);
613 else if (strncmp (decl_str
, user_label_prefix
, ulp_len
) == 0)
616 return htab_hash_string (decl_str
);
619 return htab_hash_string (IDENTIFIER_POINTER (asmname
));
622 /* Compute the number of bytes occupied by a tree with code CODE.
623 This function cannot be used for nodes that have variable sizes,
624 including TREE_VEC, STRING_CST, and CALL_EXPR. */
626 tree_code_size (enum tree_code code
)
628 switch (TREE_CODE_CLASS (code
))
630 case tcc_declaration
: /* A decl node */
635 return sizeof (struct tree_field_decl
);
637 return sizeof (struct tree_parm_decl
);
639 return sizeof (struct tree_var_decl
);
641 return sizeof (struct tree_label_decl
);
643 return sizeof (struct tree_result_decl
);
645 return sizeof (struct tree_const_decl
);
647 return sizeof (struct tree_type_decl
);
649 return sizeof (struct tree_function_decl
);
650 case DEBUG_EXPR_DECL
:
651 return sizeof (struct tree_decl_with_rtl
);
653 return sizeof (struct tree_decl_non_common
);
657 case tcc_type
: /* a type node */
658 return sizeof (struct tree_type_non_common
);
660 case tcc_reference
: /* a reference */
661 case tcc_expression
: /* an expression */
662 case tcc_statement
: /* an expression with side effects */
663 case tcc_comparison
: /* a comparison expression */
664 case tcc_unary
: /* a unary arithmetic expression */
665 case tcc_binary
: /* a binary arithmetic expression */
666 return (sizeof (struct tree_exp
)
667 + (TREE_CODE_LENGTH (code
) - 1) * sizeof (tree
));
669 case tcc_constant
: /* a constant */
672 case INTEGER_CST
: return sizeof (struct tree_int_cst
);
673 case REAL_CST
: return sizeof (struct tree_real_cst
);
674 case FIXED_CST
: return sizeof (struct tree_fixed_cst
);
675 case COMPLEX_CST
: return sizeof (struct tree_complex
);
676 case VECTOR_CST
: return sizeof (struct tree_vector
);
677 case STRING_CST
: gcc_unreachable ();
679 return lang_hooks
.tree_size (code
);
682 case tcc_exceptional
: /* something random, like an identifier. */
685 case IDENTIFIER_NODE
: return lang_hooks
.identifier_size
;
686 case TREE_LIST
: return sizeof (struct tree_list
);
689 case PLACEHOLDER_EXPR
: return sizeof (struct tree_common
);
692 case OMP_CLAUSE
: gcc_unreachable ();
694 case SSA_NAME
: return sizeof (struct tree_ssa_name
);
696 case STATEMENT_LIST
: return sizeof (struct tree_statement_list
);
697 case BLOCK
: return sizeof (struct tree_block
);
698 case CONSTRUCTOR
: return sizeof (struct tree_constructor
);
699 case OPTIMIZATION_NODE
: return sizeof (struct tree_optimization_option
);
700 case TARGET_OPTION_NODE
: return sizeof (struct tree_target_option
);
703 return lang_hooks
.tree_size (code
);
711 /* Compute the number of bytes occupied by NODE. This routine only
712 looks at TREE_CODE, except for those nodes that have variable sizes. */
714 tree_size (const_tree node
)
716 const enum tree_code code
= TREE_CODE (node
);
720 return (offsetof (struct tree_binfo
, base_binfos
)
721 + VEC_embedded_size (tree
, BINFO_N_BASE_BINFOS (node
)));
724 return (sizeof (struct tree_vec
)
725 + (TREE_VEC_LENGTH (node
) - 1) * sizeof (tree
));
728 return (sizeof (struct tree_vector
)
729 + (TYPE_VECTOR_SUBPARTS (TREE_TYPE (node
)) - 1) * sizeof (tree
));
732 return TREE_STRING_LENGTH (node
) + offsetof (struct tree_string
, str
) + 1;
735 return (sizeof (struct tree_omp_clause
)
736 + (omp_clause_num_ops
[OMP_CLAUSE_CODE (node
)] - 1)
740 if (TREE_CODE_CLASS (code
) == tcc_vl_exp
)
741 return (sizeof (struct tree_exp
)
742 + (VL_EXP_OPERAND_LENGTH (node
) - 1) * sizeof (tree
));
744 return tree_code_size (code
);
748 /* Record interesting allocation statistics for a tree node with CODE
752 record_node_allocation_statistics (enum tree_code code ATTRIBUTE_UNUSED
,
753 size_t length ATTRIBUTE_UNUSED
)
755 #ifdef GATHER_STATISTICS
756 enum tree_code_class type
= TREE_CODE_CLASS (code
);
761 case tcc_declaration
: /* A decl node */
765 case tcc_type
: /* a type node */
769 case tcc_statement
: /* an expression with side effects */
773 case tcc_reference
: /* a reference */
777 case tcc_expression
: /* an expression */
778 case tcc_comparison
: /* a comparison expression */
779 case tcc_unary
: /* a unary arithmetic expression */
780 case tcc_binary
: /* a binary arithmetic expression */
784 case tcc_constant
: /* a constant */
788 case tcc_exceptional
: /* something random, like an identifier. */
791 case IDENTIFIER_NODE
:
804 kind
= ssa_name_kind
;
816 kind
= omp_clause_kind
;
833 tree_code_counts
[(int) code
]++;
834 tree_node_counts
[(int) kind
]++;
835 tree_node_sizes
[(int) kind
] += length
;
839 /* Allocate and return a new UID from the DECL_UID namespace. */
842 allocate_decl_uid (void)
844 return next_decl_uid
++;
847 /* Return a newly allocated node of code CODE. For decl and type
848 nodes, some other fields are initialized. The rest of the node is
849 initialized to zero. This function cannot be used for TREE_VEC or
850 OMP_CLAUSE nodes, which is enforced by asserts in tree_code_size.
852 Achoo! I got a code in the node. */
855 make_node_stat (enum tree_code code MEM_STAT_DECL
)
858 enum tree_code_class type
= TREE_CODE_CLASS (code
);
859 size_t length
= tree_code_size (code
);
861 record_node_allocation_statistics (code
, length
);
863 t
= ggc_alloc_zone_cleared_tree_node_stat (
864 (code
== IDENTIFIER_NODE
) ? &tree_id_zone
: &tree_zone
,
865 length PASS_MEM_STAT
);
866 TREE_SET_CODE (t
, code
);
871 TREE_SIDE_EFFECTS (t
) = 1;
874 case tcc_declaration
:
875 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_COMMON
))
877 if (code
== FUNCTION_DECL
)
879 DECL_ALIGN (t
) = FUNCTION_BOUNDARY
;
880 DECL_MODE (t
) = FUNCTION_MODE
;
885 DECL_SOURCE_LOCATION (t
) = input_location
;
886 if (TREE_CODE (t
) == DEBUG_EXPR_DECL
)
887 DECL_UID (t
) = --next_debug_decl_uid
;
890 DECL_UID (t
) = allocate_decl_uid ();
891 SET_DECL_PT_UID (t
, -1);
893 if (TREE_CODE (t
) == LABEL_DECL
)
894 LABEL_DECL_UID (t
) = -1;
899 TYPE_UID (t
) = next_type_uid
++;
900 TYPE_ALIGN (t
) = BITS_PER_UNIT
;
901 TYPE_USER_ALIGN (t
) = 0;
902 TYPE_MAIN_VARIANT (t
) = t
;
903 TYPE_CANONICAL (t
) = t
;
905 /* Default to no attributes for type, but let target change that. */
906 TYPE_ATTRIBUTES (t
) = NULL_TREE
;
907 targetm
.set_default_type_attributes (t
);
909 /* We have not yet computed the alias set for this type. */
910 TYPE_ALIAS_SET (t
) = -1;
914 TREE_CONSTANT (t
) = 1;
923 case PREDECREMENT_EXPR
:
924 case PREINCREMENT_EXPR
:
925 case POSTDECREMENT_EXPR
:
926 case POSTINCREMENT_EXPR
:
927 /* All of these have side-effects, no matter what their
929 TREE_SIDE_EFFECTS (t
) = 1;
938 /* Other classes need no special treatment. */
945 /* Return a new node with the same contents as NODE except that its
946 TREE_CHAIN, if it has one, is zero and it has a fresh uid. */
949 copy_node_stat (tree node MEM_STAT_DECL
)
952 enum tree_code code
= TREE_CODE (node
);
955 gcc_assert (code
!= STATEMENT_LIST
);
957 length
= tree_size (node
);
958 record_node_allocation_statistics (code
, length
);
959 t
= ggc_alloc_zone_tree_node_stat (&tree_zone
, length PASS_MEM_STAT
);
960 memcpy (t
, node
, length
);
962 if (CODE_CONTAINS_STRUCT (code
, TS_COMMON
))
964 TREE_ASM_WRITTEN (t
) = 0;
965 TREE_VISITED (t
) = 0;
966 if (code
== VAR_DECL
|| code
== PARM_DECL
|| code
== RESULT_DECL
)
967 *DECL_VAR_ANN_PTR (t
) = 0;
969 if (TREE_CODE_CLASS (code
) == tcc_declaration
)
971 if (code
== DEBUG_EXPR_DECL
)
972 DECL_UID (t
) = --next_debug_decl_uid
;
975 DECL_UID (t
) = allocate_decl_uid ();
976 if (DECL_PT_UID_SET_P (node
))
977 SET_DECL_PT_UID (t
, DECL_PT_UID (node
));
979 if ((TREE_CODE (node
) == PARM_DECL
|| TREE_CODE (node
) == VAR_DECL
)
980 && DECL_HAS_VALUE_EXPR_P (node
))
982 SET_DECL_VALUE_EXPR (t
, DECL_VALUE_EXPR (node
));
983 DECL_HAS_VALUE_EXPR_P (t
) = 1;
985 if (TREE_CODE (node
) == VAR_DECL
&& DECL_HAS_INIT_PRIORITY_P (node
))
987 SET_DECL_INIT_PRIORITY (t
, DECL_INIT_PRIORITY (node
));
988 DECL_HAS_INIT_PRIORITY_P (t
) = 1;
991 else if (TREE_CODE_CLASS (code
) == tcc_type
)
993 TYPE_UID (t
) = next_type_uid
++;
994 /* The following is so that the debug code for
995 the copy is different from the original type.
996 The two statements usually duplicate each other
997 (because they clear fields of the same union),
998 but the optimizer should catch that. */
999 TYPE_SYMTAB_POINTER (t
) = 0;
1000 TYPE_SYMTAB_ADDRESS (t
) = 0;
1002 /* Do not copy the values cache. */
1003 if (TYPE_CACHED_VALUES_P(t
))
1005 TYPE_CACHED_VALUES_P (t
) = 0;
1006 TYPE_CACHED_VALUES (t
) = NULL_TREE
;
1013 /* Return a copy of a chain of nodes, chained through the TREE_CHAIN field.
1014 For example, this can copy a list made of TREE_LIST nodes. */
1017 copy_list (tree list
)
1025 head
= prev
= copy_node (list
);
1026 next
= TREE_CHAIN (list
);
1029 TREE_CHAIN (prev
) = copy_node (next
);
1030 prev
= TREE_CHAIN (prev
);
1031 next
= TREE_CHAIN (next
);
1037 /* Create an INT_CST node with a LOW value sign extended to TYPE. */
1040 build_int_cst (tree type
, HOST_WIDE_INT low
)
1042 /* Support legacy code. */
1044 type
= integer_type_node
;
1046 return double_int_to_tree (type
, shwi_to_double_int (low
));
1049 /* Create an INT_CST node with a LOW value sign extended to TYPE. */
1052 build_int_cst_type (tree type
, HOST_WIDE_INT low
)
1056 return double_int_to_tree (type
, shwi_to_double_int (low
));
1059 /* Constructs tree in type TYPE from with value given by CST. Signedness
1060 of CST is assumed to be the same as the signedness of TYPE. */
1063 double_int_to_tree (tree type
, double_int cst
)
1065 /* Size types *are* sign extended. */
1066 bool sign_extended_type
= (!TYPE_UNSIGNED (type
)
1067 || (TREE_CODE (type
) == INTEGER_TYPE
1068 && TYPE_IS_SIZETYPE (type
)));
1070 cst
= double_int_ext (cst
, TYPE_PRECISION (type
), !sign_extended_type
);
1072 return build_int_cst_wide (type
, cst
.low
, cst
.high
);
1075 /* Returns true if CST fits into range of TYPE. Signedness of CST is assumed
1076 to be the same as the signedness of TYPE. */
1079 double_int_fits_to_tree_p (const_tree type
, double_int cst
)
1081 /* Size types *are* sign extended. */
1082 bool sign_extended_type
= (!TYPE_UNSIGNED (type
)
1083 || (TREE_CODE (type
) == INTEGER_TYPE
1084 && TYPE_IS_SIZETYPE (type
)));
1087 = double_int_ext (cst
, TYPE_PRECISION (type
), !sign_extended_type
);
1089 return double_int_equal_p (cst
, ext
);
1092 /* We force the double_int CST to the range of the type TYPE by sign or
1093 zero extending it. OVERFLOWABLE indicates if we are interested in
1094 overflow of the value, when >0 we are only interested in signed
1095 overflow, for <0 we are interested in any overflow. OVERFLOWED
1096 indicates whether overflow has already occurred. CONST_OVERFLOWED
1097 indicates whether constant overflow has already occurred. We force
1098 T's value to be within range of T's type (by setting to 0 or 1 all
1099 the bits outside the type's range). We set TREE_OVERFLOWED if,
1100 OVERFLOWED is nonzero,
1101 or OVERFLOWABLE is >0 and signed overflow occurs
1102 or OVERFLOWABLE is <0 and any overflow occurs
1103 We return a new tree node for the extended double_int. The node
1104 is shared if no overflow flags are set. */
1108 force_fit_type_double (tree type
, double_int cst
, int overflowable
,
1111 bool sign_extended_type
;
1113 /* Size types *are* sign extended. */
1114 sign_extended_type
= (!TYPE_UNSIGNED (type
)
1115 || (TREE_CODE (type
) == INTEGER_TYPE
1116 && TYPE_IS_SIZETYPE (type
)));
1118 /* If we need to set overflow flags, return a new unshared node. */
1119 if (overflowed
|| !double_int_fits_to_tree_p(type
, cst
))
1123 || (overflowable
> 0 && sign_extended_type
))
1125 tree t
= make_node (INTEGER_CST
);
1126 TREE_INT_CST (t
) = double_int_ext (cst
, TYPE_PRECISION (type
),
1127 !sign_extended_type
);
1128 TREE_TYPE (t
) = type
;
1129 TREE_OVERFLOW (t
) = 1;
1134 /* Else build a shared node. */
1135 return double_int_to_tree (type
, cst
);
1138 /* These are the hash table functions for the hash table of INTEGER_CST
1139 nodes of a sizetype. */
1141 /* Return the hash code code X, an INTEGER_CST. */
1144 int_cst_hash_hash (const void *x
)
1146 const_tree
const t
= (const_tree
) x
;
1148 return (TREE_INT_CST_HIGH (t
) ^ TREE_INT_CST_LOW (t
)
1149 ^ htab_hash_pointer (TREE_TYPE (t
)));
1152 /* Return nonzero if the value represented by *X (an INTEGER_CST tree node)
1153 is the same as that given by *Y, which is the same. */
1156 int_cst_hash_eq (const void *x
, const void *y
)
1158 const_tree
const xt
= (const_tree
) x
;
1159 const_tree
const yt
= (const_tree
) y
;
1161 return (TREE_TYPE (xt
) == TREE_TYPE (yt
)
1162 && TREE_INT_CST_HIGH (xt
) == TREE_INT_CST_HIGH (yt
)
1163 && TREE_INT_CST_LOW (xt
) == TREE_INT_CST_LOW (yt
));
1166 /* Create an INT_CST node of TYPE and value HI:LOW.
1167 The returned node is always shared. For small integers we use a
1168 per-type vector cache, for larger ones we use a single hash table. */
1171 build_int_cst_wide (tree type
, unsigned HOST_WIDE_INT low
, HOST_WIDE_INT hi
)
1179 switch (TREE_CODE (type
))
1182 gcc_assert (hi
== 0 && low
== 0);
1186 case REFERENCE_TYPE
:
1187 /* Cache NULL pointer. */
1196 /* Cache false or true. */
1204 if (TYPE_UNSIGNED (type
))
1207 limit
= INTEGER_SHARE_LIMIT
;
1208 if (!hi
&& low
< (unsigned HOST_WIDE_INT
)INTEGER_SHARE_LIMIT
)
1214 limit
= INTEGER_SHARE_LIMIT
+ 1;
1215 if (!hi
&& low
< (unsigned HOST_WIDE_INT
)INTEGER_SHARE_LIMIT
)
1217 else if (hi
== -1 && low
== -(unsigned HOST_WIDE_INT
)1)
1231 /* Look for it in the type's vector of small shared ints. */
1232 if (!TYPE_CACHED_VALUES_P (type
))
1234 TYPE_CACHED_VALUES_P (type
) = 1;
1235 TYPE_CACHED_VALUES (type
) = make_tree_vec (limit
);
1238 t
= TREE_VEC_ELT (TYPE_CACHED_VALUES (type
), ix
);
1241 /* Make sure no one is clobbering the shared constant. */
1242 gcc_assert (TREE_TYPE (t
) == type
);
1243 gcc_assert (TREE_INT_CST_LOW (t
) == low
);
1244 gcc_assert (TREE_INT_CST_HIGH (t
) == hi
);
1248 /* Create a new shared int. */
1249 t
= make_node (INTEGER_CST
);
1251 TREE_INT_CST_LOW (t
) = low
;
1252 TREE_INT_CST_HIGH (t
) = hi
;
1253 TREE_TYPE (t
) = type
;
1255 TREE_VEC_ELT (TYPE_CACHED_VALUES (type
), ix
) = t
;
1260 /* Use the cache of larger shared ints. */
1263 TREE_INT_CST_LOW (int_cst_node
) = low
;
1264 TREE_INT_CST_HIGH (int_cst_node
) = hi
;
1265 TREE_TYPE (int_cst_node
) = type
;
1267 slot
= htab_find_slot (int_cst_hash_table
, int_cst_node
, INSERT
);
1271 /* Insert this one into the hash table. */
1274 /* Make a new node for next time round. */
1275 int_cst_node
= make_node (INTEGER_CST
);
1282 /* Builds an integer constant in TYPE such that lowest BITS bits are ones
1283 and the rest are zeros. */
1286 build_low_bits_mask (tree type
, unsigned bits
)
1290 gcc_assert (bits
<= TYPE_PRECISION (type
));
1292 if (bits
== TYPE_PRECISION (type
)
1293 && !TYPE_UNSIGNED (type
))
1294 /* Sign extended all-ones mask. */
1295 mask
= double_int_minus_one
;
1297 mask
= double_int_mask (bits
);
1299 return build_int_cst_wide (type
, mask
.low
, mask
.high
);
1302 /* Checks that X is integer constant that can be expressed in (unsigned)
1303 HOST_WIDE_INT without loss of precision. */
1306 cst_and_fits_in_hwi (const_tree x
)
1308 if (TREE_CODE (x
) != INTEGER_CST
)
1311 if (TYPE_PRECISION (TREE_TYPE (x
)) > HOST_BITS_PER_WIDE_INT
)
1314 return (TREE_INT_CST_HIGH (x
) == 0
1315 || TREE_INT_CST_HIGH (x
) == -1);
1318 /* Return a new VECTOR_CST node whose type is TYPE and whose values
1319 are in a list pointed to by VALS. */
1322 build_vector_stat (tree type
, tree
*vals MEM_STAT_DECL
)
1327 int length
= ((TYPE_VECTOR_SUBPARTS (type
) - 1) * sizeof (tree
)
1328 + sizeof (struct tree_vector
));
1330 record_node_allocation_statistics (VECTOR_CST
, length
);
1332 v
= ggc_alloc_zone_cleared_tree_node_stat (&tree_zone
, length PASS_MEM_STAT
);
1334 TREE_SET_CODE (v
, VECTOR_CST
);
1335 TREE_CONSTANT (v
) = 1;
1336 TREE_TYPE (v
) = type
;
1338 /* Iterate through elements and check for overflow. */
1339 for (cnt
= 0; cnt
< TYPE_VECTOR_SUBPARTS (type
); ++cnt
)
1341 tree value
= vals
[cnt
];
1343 VECTOR_CST_ELT (v
, cnt
) = value
;
1345 /* Don't crash if we get an address constant. */
1346 if (!CONSTANT_CLASS_P (value
))
1349 over
|= TREE_OVERFLOW (value
);
1352 TREE_OVERFLOW (v
) = over
;
1356 /* Return a new VECTOR_CST node whose type is TYPE and whose values
1357 are extracted from V, a vector of CONSTRUCTOR_ELT. */
1360 build_vector_from_ctor (tree type
, VEC(constructor_elt
,gc
) *v
)
1362 tree
*vec
= XALLOCAVEC (tree
, TYPE_VECTOR_SUBPARTS (type
));
1363 unsigned HOST_WIDE_INT idx
;
1366 FOR_EACH_CONSTRUCTOR_VALUE (v
, idx
, value
)
1368 for (; idx
< TYPE_VECTOR_SUBPARTS (type
); ++idx
)
1369 vec
[idx
] = build_zero_cst (TREE_TYPE (type
));
1371 return build_vector (type
, vec
);
1374 /* Build a vector of type VECTYPE where all the elements are SCs. */
1376 build_vector_from_val (tree vectype
, tree sc
)
1378 int i
, nunits
= TYPE_VECTOR_SUBPARTS (vectype
);
1380 if (sc
== error_mark_node
)
1383 /* Verify that the vector type is suitable for SC. Note that there
1384 is some inconsistency in the type-system with respect to restrict
1385 qualifications of pointers. Vector types always have a main-variant
1386 element type and the qualification is applied to the vector-type.
1387 So TREE_TYPE (vector-type) does not return a properly qualified
1388 vector element-type. */
1389 gcc_checking_assert (types_compatible_p (TYPE_MAIN_VARIANT (TREE_TYPE (sc
)),
1390 TREE_TYPE (vectype
)));
1392 if (CONSTANT_CLASS_P (sc
))
1394 tree
*v
= XALLOCAVEC (tree
, nunits
);
1395 for (i
= 0; i
< nunits
; ++i
)
1397 return build_vector (vectype
, v
);
1401 VEC(constructor_elt
, gc
) *v
= VEC_alloc (constructor_elt
, gc
, nunits
);
1402 for (i
= 0; i
< nunits
; ++i
)
1403 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, sc
);
1404 return build_constructor (vectype
, v
);
1408 /* Return a new CONSTRUCTOR node whose type is TYPE and whose values
1409 are in the VEC pointed to by VALS. */
1411 build_constructor (tree type
, VEC(constructor_elt
,gc
) *vals
)
1413 tree c
= make_node (CONSTRUCTOR
);
1415 constructor_elt
*elt
;
1416 bool constant_p
= true;
1418 TREE_TYPE (c
) = type
;
1419 CONSTRUCTOR_ELTS (c
) = vals
;
1421 FOR_EACH_VEC_ELT (constructor_elt
, vals
, i
, elt
)
1422 if (!TREE_CONSTANT (elt
->value
))
1428 TREE_CONSTANT (c
) = constant_p
;
1433 /* Build a CONSTRUCTOR node made of a single initializer, with the specified
1436 build_constructor_single (tree type
, tree index
, tree value
)
1438 VEC(constructor_elt
,gc
) *v
;
1439 constructor_elt
*elt
;
1441 v
= VEC_alloc (constructor_elt
, gc
, 1);
1442 elt
= VEC_quick_push (constructor_elt
, v
, NULL
);
1446 return build_constructor (type
, v
);
1450 /* Return a new CONSTRUCTOR node whose type is TYPE and whose values
1451 are in a list pointed to by VALS. */
1453 build_constructor_from_list (tree type
, tree vals
)
1456 VEC(constructor_elt
,gc
) *v
= NULL
;
1460 v
= VEC_alloc (constructor_elt
, gc
, list_length (vals
));
1461 for (t
= vals
; t
; t
= TREE_CHAIN (t
))
1462 CONSTRUCTOR_APPEND_ELT (v
, TREE_PURPOSE (t
), TREE_VALUE (t
));
1465 return build_constructor (type
, v
);
1468 /* Return a new FIXED_CST node whose type is TYPE and value is F. */
1471 build_fixed (tree type
, FIXED_VALUE_TYPE f
)
1474 FIXED_VALUE_TYPE
*fp
;
1476 v
= make_node (FIXED_CST
);
1477 fp
= ggc_alloc_fixed_value ();
1478 memcpy (fp
, &f
, sizeof (FIXED_VALUE_TYPE
));
1480 TREE_TYPE (v
) = type
;
1481 TREE_FIXED_CST_PTR (v
) = fp
;
1485 /* Return a new REAL_CST node whose type is TYPE and value is D. */
1488 build_real (tree type
, REAL_VALUE_TYPE d
)
1491 REAL_VALUE_TYPE
*dp
;
1494 /* ??? Used to check for overflow here via CHECK_FLOAT_TYPE.
1495 Consider doing it via real_convert now. */
1497 v
= make_node (REAL_CST
);
1498 dp
= ggc_alloc_real_value ();
1499 memcpy (dp
, &d
, sizeof (REAL_VALUE_TYPE
));
1501 TREE_TYPE (v
) = type
;
1502 TREE_REAL_CST_PTR (v
) = dp
;
1503 TREE_OVERFLOW (v
) = overflow
;
1507 /* Return a new REAL_CST node whose type is TYPE
1508 and whose value is the integer value of the INTEGER_CST node I. */
1511 real_value_from_int_cst (const_tree type
, const_tree i
)
1515 /* Clear all bits of the real value type so that we can later do
1516 bitwise comparisons to see if two values are the same. */
1517 memset (&d
, 0, sizeof d
);
1519 real_from_integer (&d
, type
? TYPE_MODE (type
) : VOIDmode
,
1520 TREE_INT_CST_LOW (i
), TREE_INT_CST_HIGH (i
),
1521 TYPE_UNSIGNED (TREE_TYPE (i
)));
1525 /* Given a tree representing an integer constant I, return a tree
1526 representing the same value as a floating-point constant of type TYPE. */
1529 build_real_from_int_cst (tree type
, const_tree i
)
1532 int overflow
= TREE_OVERFLOW (i
);
1534 v
= build_real (type
, real_value_from_int_cst (type
, i
));
1536 TREE_OVERFLOW (v
) |= overflow
;
1540 /* Return a newly constructed STRING_CST node whose value is
1541 the LEN characters at STR.
1542 Note that for a C string literal, LEN should include the trailing NUL.
1543 The TREE_TYPE is not initialized. */
1546 build_string (int len
, const char *str
)
1551 /* Do not waste bytes provided by padding of struct tree_string. */
1552 length
= len
+ offsetof (struct tree_string
, str
) + 1;
1554 record_node_allocation_statistics (STRING_CST
, length
);
1556 s
= ggc_alloc_tree_node (length
);
1558 memset (s
, 0, sizeof (struct tree_typed
));
1559 TREE_SET_CODE (s
, STRING_CST
);
1560 TREE_CONSTANT (s
) = 1;
1561 TREE_STRING_LENGTH (s
) = len
;
1562 memcpy (s
->string
.str
, str
, len
);
1563 s
->string
.str
[len
] = '\0';
1568 /* Return a newly constructed COMPLEX_CST node whose value is
1569 specified by the real and imaginary parts REAL and IMAG.
1570 Both REAL and IMAG should be constant nodes. TYPE, if specified,
1571 will be the type of the COMPLEX_CST; otherwise a new type will be made. */
1574 build_complex (tree type
, tree real
, tree imag
)
1576 tree t
= make_node (COMPLEX_CST
);
1578 TREE_REALPART (t
) = real
;
1579 TREE_IMAGPART (t
) = imag
;
1580 TREE_TYPE (t
) = type
? type
: build_complex_type (TREE_TYPE (real
));
1581 TREE_OVERFLOW (t
) = TREE_OVERFLOW (real
) | TREE_OVERFLOW (imag
);
1585 /* Return a constant of arithmetic type TYPE which is the
1586 multiplicative identity of the set TYPE. */
1589 build_one_cst (tree type
)
1591 switch (TREE_CODE (type
))
1593 case INTEGER_TYPE
: case ENUMERAL_TYPE
: case BOOLEAN_TYPE
:
1594 case POINTER_TYPE
: case REFERENCE_TYPE
:
1596 return build_int_cst (type
, 1);
1599 return build_real (type
, dconst1
);
1601 case FIXED_POINT_TYPE
:
1602 /* We can only generate 1 for accum types. */
1603 gcc_assert (ALL_SCALAR_ACCUM_MODE_P (TYPE_MODE (type
)));
1604 return build_fixed (type
, FCONST1(TYPE_MODE (type
)));
1608 tree scalar
= build_one_cst (TREE_TYPE (type
));
1610 return build_vector_from_val (type
, scalar
);
1614 return build_complex (type
,
1615 build_one_cst (TREE_TYPE (type
)),
1616 build_zero_cst (TREE_TYPE (type
)));
1623 /* Build 0 constant of type TYPE. This is used by constructor folding
1624 and thus the constant should be represented in memory by
1628 build_zero_cst (tree type
)
1630 switch (TREE_CODE (type
))
1632 case INTEGER_TYPE
: case ENUMERAL_TYPE
: case BOOLEAN_TYPE
:
1633 case POINTER_TYPE
: case REFERENCE_TYPE
:
1635 return build_int_cst (type
, 0);
1638 return build_real (type
, dconst0
);
1640 case FIXED_POINT_TYPE
:
1641 return build_fixed (type
, FCONST0 (TYPE_MODE (type
)));
1645 tree scalar
= build_zero_cst (TREE_TYPE (type
));
1647 return build_vector_from_val (type
, scalar
);
1652 tree zero
= build_zero_cst (TREE_TYPE (type
));
1654 return build_complex (type
, zero
, zero
);
1658 if (!AGGREGATE_TYPE_P (type
))
1659 return fold_convert (type
, integer_zero_node
);
1660 return build_constructor (type
, NULL
);
1665 /* Build a BINFO with LEN language slots. */
1668 make_tree_binfo_stat (unsigned base_binfos MEM_STAT_DECL
)
1671 size_t length
= (offsetof (struct tree_binfo
, base_binfos
)
1672 + VEC_embedded_size (tree
, base_binfos
));
1674 record_node_allocation_statistics (TREE_BINFO
, length
);
1676 t
= ggc_alloc_zone_tree_node_stat (&tree_zone
, length PASS_MEM_STAT
);
1678 memset (t
, 0, offsetof (struct tree_binfo
, base_binfos
));
1680 TREE_SET_CODE (t
, TREE_BINFO
);
1682 VEC_embedded_init (tree
, BINFO_BASE_BINFOS (t
), base_binfos
);
1687 /* Create a CASE_LABEL_EXPR tree node and return it. */
1690 build_case_label (tree low_value
, tree high_value
, tree label_decl
)
1692 tree t
= make_node (CASE_LABEL_EXPR
);
1694 TREE_TYPE (t
) = void_type_node
;
1695 SET_EXPR_LOCATION (t
, DECL_SOURCE_LOCATION (label_decl
));
1697 CASE_LOW (t
) = low_value
;
1698 CASE_HIGH (t
) = high_value
;
1699 CASE_LABEL (t
) = label_decl
;
1700 CASE_CHAIN (t
) = NULL_TREE
;
1705 /* Build a newly constructed TREE_VEC node of length LEN. */
1708 make_tree_vec_stat (int len MEM_STAT_DECL
)
1711 int length
= (len
- 1) * sizeof (tree
) + sizeof (struct tree_vec
);
1713 record_node_allocation_statistics (TREE_VEC
, length
);
1715 t
= ggc_alloc_zone_cleared_tree_node_stat (&tree_zone
, length PASS_MEM_STAT
);
1717 TREE_SET_CODE (t
, TREE_VEC
);
1718 TREE_VEC_LENGTH (t
) = len
;
1723 /* Return 1 if EXPR is the integer constant zero or a complex constant
1727 integer_zerop (const_tree expr
)
1731 switch (TREE_CODE (expr
))
1734 return (TREE_INT_CST_LOW (expr
) == 0
1735 && TREE_INT_CST_HIGH (expr
) == 0);
1737 return (integer_zerop (TREE_REALPART (expr
))
1738 && integer_zerop (TREE_IMAGPART (expr
)));
1742 for (i
= 0; i
< VECTOR_CST_NELTS (expr
); ++i
)
1743 if (!integer_zerop (VECTOR_CST_ELT (expr
, i
)))
1752 /* Return 1 if EXPR is the integer constant one or the corresponding
1753 complex constant. */
1756 integer_onep (const_tree expr
)
1760 switch (TREE_CODE (expr
))
1763 return (TREE_INT_CST_LOW (expr
) == 1
1764 && TREE_INT_CST_HIGH (expr
) == 0);
1766 return (integer_onep (TREE_REALPART (expr
))
1767 && integer_zerop (TREE_IMAGPART (expr
)));
1771 for (i
= 0; i
< VECTOR_CST_NELTS (expr
); ++i
)
1772 if (!integer_onep (VECTOR_CST_ELT (expr
, i
)))
1781 /* Return 1 if EXPR is an integer containing all 1's in as much precision as
1782 it contains. Likewise for the corresponding complex constant. */
1785 integer_all_onesp (const_tree expr
)
1792 if (TREE_CODE (expr
) == COMPLEX_CST
1793 && integer_all_onesp (TREE_REALPART (expr
))
1794 && integer_zerop (TREE_IMAGPART (expr
)))
1797 else if (TREE_CODE (expr
) == VECTOR_CST
)
1800 for (i
= 0; i
< VECTOR_CST_NELTS (expr
); ++i
)
1801 if (!integer_all_onesp (VECTOR_CST_ELT (expr
, i
)))
1806 else if (TREE_CODE (expr
) != INTEGER_CST
)
1809 uns
= TYPE_UNSIGNED (TREE_TYPE (expr
));
1810 if (TREE_INT_CST_LOW (expr
) == ~(unsigned HOST_WIDE_INT
) 0
1811 && TREE_INT_CST_HIGH (expr
) == -1)
1816 prec
= TYPE_PRECISION (TREE_TYPE (expr
));
1817 if (prec
>= HOST_BITS_PER_WIDE_INT
)
1819 HOST_WIDE_INT high_value
;
1822 shift_amount
= prec
- HOST_BITS_PER_WIDE_INT
;
1824 /* Can not handle precisions greater than twice the host int size. */
1825 gcc_assert (shift_amount
<= HOST_BITS_PER_WIDE_INT
);
1826 if (shift_amount
== HOST_BITS_PER_WIDE_INT
)
1827 /* Shifting by the host word size is undefined according to the ANSI
1828 standard, so we must handle this as a special case. */
1831 high_value
= ((HOST_WIDE_INT
) 1 << shift_amount
) - 1;
1833 return (TREE_INT_CST_LOW (expr
) == ~(unsigned HOST_WIDE_INT
) 0
1834 && TREE_INT_CST_HIGH (expr
) == high_value
);
1837 return TREE_INT_CST_LOW (expr
) == ((unsigned HOST_WIDE_INT
) 1 << prec
) - 1;
1840 /* Return 1 if EXPR is an integer constant that is a power of 2 (i.e., has only
1844 integer_pow2p (const_tree expr
)
1847 HOST_WIDE_INT high
, low
;
1851 if (TREE_CODE (expr
) == COMPLEX_CST
1852 && integer_pow2p (TREE_REALPART (expr
))
1853 && integer_zerop (TREE_IMAGPART (expr
)))
1856 if (TREE_CODE (expr
) != INTEGER_CST
)
1859 prec
= TYPE_PRECISION (TREE_TYPE (expr
));
1860 high
= TREE_INT_CST_HIGH (expr
);
1861 low
= TREE_INT_CST_LOW (expr
);
1863 /* First clear all bits that are beyond the type's precision in case
1864 we've been sign extended. */
1866 if (prec
== 2 * HOST_BITS_PER_WIDE_INT
)
1868 else if (prec
> HOST_BITS_PER_WIDE_INT
)
1869 high
&= ~((HOST_WIDE_INT
) (-1) << (prec
- HOST_BITS_PER_WIDE_INT
));
1873 if (prec
< HOST_BITS_PER_WIDE_INT
)
1874 low
&= ~((HOST_WIDE_INT
) (-1) << prec
);
1877 if (high
== 0 && low
== 0)
1880 return ((high
== 0 && (low
& (low
- 1)) == 0)
1881 || (low
== 0 && (high
& (high
- 1)) == 0));
1884 /* Return 1 if EXPR is an integer constant other than zero or a
1885 complex constant other than zero. */
1888 integer_nonzerop (const_tree expr
)
1892 return ((TREE_CODE (expr
) == INTEGER_CST
1893 && (TREE_INT_CST_LOW (expr
) != 0
1894 || TREE_INT_CST_HIGH (expr
) != 0))
1895 || (TREE_CODE (expr
) == COMPLEX_CST
1896 && (integer_nonzerop (TREE_REALPART (expr
))
1897 || integer_nonzerop (TREE_IMAGPART (expr
)))));
1900 /* Return 1 if EXPR is the fixed-point constant zero. */
1903 fixed_zerop (const_tree expr
)
1905 return (TREE_CODE (expr
) == FIXED_CST
1906 && double_int_zero_p (TREE_FIXED_CST (expr
).data
));
1909 /* Return the power of two represented by a tree node known to be a
1913 tree_log2 (const_tree expr
)
1916 HOST_WIDE_INT high
, low
;
1920 if (TREE_CODE (expr
) == COMPLEX_CST
)
1921 return tree_log2 (TREE_REALPART (expr
));
1923 prec
= TYPE_PRECISION (TREE_TYPE (expr
));
1924 high
= TREE_INT_CST_HIGH (expr
);
1925 low
= TREE_INT_CST_LOW (expr
);
1927 /* First clear all bits that are beyond the type's precision in case
1928 we've been sign extended. */
1930 if (prec
== 2 * HOST_BITS_PER_WIDE_INT
)
1932 else if (prec
> HOST_BITS_PER_WIDE_INT
)
1933 high
&= ~((HOST_WIDE_INT
) (-1) << (prec
- HOST_BITS_PER_WIDE_INT
));
1937 if (prec
< HOST_BITS_PER_WIDE_INT
)
1938 low
&= ~((HOST_WIDE_INT
) (-1) << prec
);
1941 return (high
!= 0 ? HOST_BITS_PER_WIDE_INT
+ exact_log2 (high
)
1942 : exact_log2 (low
));
1945 /* Similar, but return the largest integer Y such that 2 ** Y is less
1946 than or equal to EXPR. */
1949 tree_floor_log2 (const_tree expr
)
1952 HOST_WIDE_INT high
, low
;
1956 if (TREE_CODE (expr
) == COMPLEX_CST
)
1957 return tree_log2 (TREE_REALPART (expr
));
1959 prec
= TYPE_PRECISION (TREE_TYPE (expr
));
1960 high
= TREE_INT_CST_HIGH (expr
);
1961 low
= TREE_INT_CST_LOW (expr
);
1963 /* First clear all bits that are beyond the type's precision in case
1964 we've been sign extended. Ignore if type's precision hasn't been set
1965 since what we are doing is setting it. */
1967 if (prec
== 2 * HOST_BITS_PER_WIDE_INT
|| prec
== 0)
1969 else if (prec
> HOST_BITS_PER_WIDE_INT
)
1970 high
&= ~((HOST_WIDE_INT
) (-1) << (prec
- HOST_BITS_PER_WIDE_INT
));
1974 if (prec
< HOST_BITS_PER_WIDE_INT
)
1975 low
&= ~((HOST_WIDE_INT
) (-1) << prec
);
1978 return (high
!= 0 ? HOST_BITS_PER_WIDE_INT
+ floor_log2 (high
)
1979 : floor_log2 (low
));
1982 /* Return 1 if EXPR is the real constant zero. Trailing zeroes matter for
1983 decimal float constants, so don't return 1 for them. */
1986 real_zerop (const_tree expr
)
1990 return ((TREE_CODE (expr
) == REAL_CST
1991 && REAL_VALUES_EQUAL (TREE_REAL_CST (expr
), dconst0
)
1992 && !(DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (expr
)))))
1993 || (TREE_CODE (expr
) == COMPLEX_CST
1994 && real_zerop (TREE_REALPART (expr
))
1995 && real_zerop (TREE_IMAGPART (expr
))));
1998 /* Return 1 if EXPR is the real constant one in real or complex form.
1999 Trailing zeroes matter for decimal float constants, so don't return
2003 real_onep (const_tree expr
)
2007 return ((TREE_CODE (expr
) == REAL_CST
2008 && REAL_VALUES_EQUAL (TREE_REAL_CST (expr
), dconst1
)
2009 && !(DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (expr
)))))
2010 || (TREE_CODE (expr
) == COMPLEX_CST
2011 && real_onep (TREE_REALPART (expr
))
2012 && real_zerop (TREE_IMAGPART (expr
))));
2015 /* Return 1 if EXPR is the real constant two. Trailing zeroes matter
2016 for decimal float constants, so don't return 1 for them. */
2019 real_twop (const_tree expr
)
2023 return ((TREE_CODE (expr
) == REAL_CST
2024 && REAL_VALUES_EQUAL (TREE_REAL_CST (expr
), dconst2
)
2025 && !(DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (expr
)))))
2026 || (TREE_CODE (expr
) == COMPLEX_CST
2027 && real_twop (TREE_REALPART (expr
))
2028 && real_zerop (TREE_IMAGPART (expr
))));
2031 /* Return 1 if EXPR is the real constant minus one. Trailing zeroes
2032 matter for decimal float constants, so don't return 1 for them. */
2035 real_minus_onep (const_tree expr
)
2039 return ((TREE_CODE (expr
) == REAL_CST
2040 && REAL_VALUES_EQUAL (TREE_REAL_CST (expr
), dconstm1
)
2041 && !(DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (expr
)))))
2042 || (TREE_CODE (expr
) == COMPLEX_CST
2043 && real_minus_onep (TREE_REALPART (expr
))
2044 && real_zerop (TREE_IMAGPART (expr
))));
2047 /* Nonzero if EXP is a constant or a cast of a constant. */
2050 really_constant_p (const_tree exp
)
2052 /* This is not quite the same as STRIP_NOPS. It does more. */
2053 while (CONVERT_EXPR_P (exp
)
2054 || TREE_CODE (exp
) == NON_LVALUE_EXPR
)
2055 exp
= TREE_OPERAND (exp
, 0);
2056 return TREE_CONSTANT (exp
);
2059 /* Return first list element whose TREE_VALUE is ELEM.
2060 Return 0 if ELEM is not in LIST. */
2063 value_member (tree elem
, tree list
)
2067 if (elem
== TREE_VALUE (list
))
2069 list
= TREE_CHAIN (list
);
2074 /* Return first list element whose TREE_PURPOSE is ELEM.
2075 Return 0 if ELEM is not in LIST. */
2078 purpose_member (const_tree elem
, tree list
)
2082 if (elem
== TREE_PURPOSE (list
))
2084 list
= TREE_CHAIN (list
);
2089 /* Return true if ELEM is in V. */
2092 vec_member (const_tree elem
, VEC(tree
,gc
) *v
)
2096 FOR_EACH_VEC_ELT (tree
, v
, ix
, t
)
2102 /* Returns element number IDX (zero-origin) of chain CHAIN, or
2106 chain_index (int idx
, tree chain
)
2108 for (; chain
&& idx
> 0; --idx
)
2109 chain
= TREE_CHAIN (chain
);
2113 /* Return nonzero if ELEM is part of the chain CHAIN. */
2116 chain_member (const_tree elem
, const_tree chain
)
2122 chain
= DECL_CHAIN (chain
);
2128 /* Return the length of a chain of nodes chained through TREE_CHAIN.
2129 We expect a null pointer to mark the end of the chain.
2130 This is the Lisp primitive `length'. */
2133 list_length (const_tree t
)
2136 #ifdef ENABLE_TREE_CHECKING
2144 #ifdef ENABLE_TREE_CHECKING
2147 gcc_assert (p
!= q
);
2155 /* Returns the number of FIELD_DECLs in TYPE. */
2158 fields_length (const_tree type
)
2160 tree t
= TYPE_FIELDS (type
);
2163 for (; t
; t
= DECL_CHAIN (t
))
2164 if (TREE_CODE (t
) == FIELD_DECL
)
2170 /* Returns the first FIELD_DECL in the TYPE_FIELDS of the RECORD_TYPE or
2171 UNION_TYPE TYPE, or NULL_TREE if none. */
2174 first_field (const_tree type
)
2176 tree t
= TYPE_FIELDS (type
);
2177 while (t
&& TREE_CODE (t
) != FIELD_DECL
)
2182 /* Concatenate two chains of nodes (chained through TREE_CHAIN)
2183 by modifying the last node in chain 1 to point to chain 2.
2184 This is the Lisp primitive `nconc'. */
2187 chainon (tree op1
, tree op2
)
2196 for (t1
= op1
; TREE_CHAIN (t1
); t1
= TREE_CHAIN (t1
))
2198 TREE_CHAIN (t1
) = op2
;
2200 #ifdef ENABLE_TREE_CHECKING
2203 for (t2
= op2
; t2
; t2
= TREE_CHAIN (t2
))
2204 gcc_assert (t2
!= t1
);
2211 /* Return the last node in a chain of nodes (chained through TREE_CHAIN). */
2214 tree_last (tree chain
)
2218 while ((next
= TREE_CHAIN (chain
)))
2223 /* Reverse the order of elements in the chain T,
2224 and return the new head of the chain (old last element). */
2229 tree prev
= 0, decl
, next
;
2230 for (decl
= t
; decl
; decl
= next
)
2232 /* We shouldn't be using this function to reverse BLOCK chains; we
2233 have blocks_nreverse for that. */
2234 gcc_checking_assert (TREE_CODE (decl
) != BLOCK
);
2235 next
= TREE_CHAIN (decl
);
2236 TREE_CHAIN (decl
) = prev
;
2242 /* Return a newly created TREE_LIST node whose
2243 purpose and value fields are PARM and VALUE. */
2246 build_tree_list_stat (tree parm
, tree value MEM_STAT_DECL
)
2248 tree t
= make_node_stat (TREE_LIST PASS_MEM_STAT
);
2249 TREE_PURPOSE (t
) = parm
;
2250 TREE_VALUE (t
) = value
;
2254 /* Build a chain of TREE_LIST nodes from a vector. */
2257 build_tree_list_vec_stat (const VEC(tree
,gc
) *vec MEM_STAT_DECL
)
2259 tree ret
= NULL_TREE
;
2263 FOR_EACH_VEC_ELT (tree
, vec
, i
, t
)
2265 *pp
= build_tree_list_stat (NULL
, t PASS_MEM_STAT
);
2266 pp
= &TREE_CHAIN (*pp
);
2271 /* Return a newly created TREE_LIST node whose
2272 purpose and value fields are PURPOSE and VALUE
2273 and whose TREE_CHAIN is CHAIN. */
2276 tree_cons_stat (tree purpose
, tree value
, tree chain MEM_STAT_DECL
)
2280 node
= ggc_alloc_zone_tree_node_stat (&tree_zone
, sizeof (struct tree_list
)
2282 memset (node
, 0, sizeof (struct tree_common
));
2284 record_node_allocation_statistics (TREE_LIST
, sizeof (struct tree_list
));
2286 TREE_SET_CODE (node
, TREE_LIST
);
2287 TREE_CHAIN (node
) = chain
;
2288 TREE_PURPOSE (node
) = purpose
;
2289 TREE_VALUE (node
) = value
;
2293 /* Return the values of the elements of a CONSTRUCTOR as a vector of
2297 ctor_to_vec (tree ctor
)
2299 VEC(tree
, gc
) *vec
= VEC_alloc (tree
, gc
, CONSTRUCTOR_NELTS (ctor
));
2303 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (ctor
), ix
, val
)
2304 VEC_quick_push (tree
, vec
, val
);
2309 /* Return the size nominally occupied by an object of type TYPE
2310 when it resides in memory. The value is measured in units of bytes,
2311 and its data type is that normally used for type sizes
2312 (which is the first type created by make_signed_type or
2313 make_unsigned_type). */
2316 size_in_bytes (const_tree type
)
2320 if (type
== error_mark_node
)
2321 return integer_zero_node
;
2323 type
= TYPE_MAIN_VARIANT (type
);
2324 t
= TYPE_SIZE_UNIT (type
);
2328 lang_hooks
.types
.incomplete_type_error (NULL_TREE
, type
);
2329 return size_zero_node
;
2335 /* Return the size of TYPE (in bytes) as a wide integer
2336 or return -1 if the size can vary or is larger than an integer. */
2339 int_size_in_bytes (const_tree type
)
2343 if (type
== error_mark_node
)
2346 type
= TYPE_MAIN_VARIANT (type
);
2347 t
= TYPE_SIZE_UNIT (type
);
2349 || TREE_CODE (t
) != INTEGER_CST
2350 || TREE_INT_CST_HIGH (t
) != 0
2351 /* If the result would appear negative, it's too big to represent. */
2352 || (HOST_WIDE_INT
) TREE_INT_CST_LOW (t
) < 0)
2355 return TREE_INT_CST_LOW (t
);
2358 /* Return the maximum size of TYPE (in bytes) as a wide integer
2359 or return -1 if the size can vary or is larger than an integer. */
2362 max_int_size_in_bytes (const_tree type
)
2364 HOST_WIDE_INT size
= -1;
2367 /* If this is an array type, check for a possible MAX_SIZE attached. */
2369 if (TREE_CODE (type
) == ARRAY_TYPE
)
2371 size_tree
= TYPE_ARRAY_MAX_SIZE (type
);
2373 if (size_tree
&& host_integerp (size_tree
, 1))
2374 size
= tree_low_cst (size_tree
, 1);
2377 /* If we still haven't been able to get a size, see if the language
2378 can compute a maximum size. */
2382 size_tree
= lang_hooks
.types
.max_size (type
);
2384 if (size_tree
&& host_integerp (size_tree
, 1))
2385 size
= tree_low_cst (size_tree
, 1);
2391 /* Returns a tree for the size of EXP in bytes. */
2394 tree_expr_size (const_tree exp
)
2397 && DECL_SIZE_UNIT (exp
) != 0)
2398 return DECL_SIZE_UNIT (exp
);
2400 return size_in_bytes (TREE_TYPE (exp
));
2403 /* Return the bit position of FIELD, in bits from the start of the record.
2404 This is a tree of type bitsizetype. */
2407 bit_position (const_tree field
)
2409 return bit_from_pos (DECL_FIELD_OFFSET (field
),
2410 DECL_FIELD_BIT_OFFSET (field
));
2413 /* Likewise, but return as an integer. It must be representable in
2414 that way (since it could be a signed value, we don't have the
2415 option of returning -1 like int_size_in_byte can. */
2418 int_bit_position (const_tree field
)
2420 return tree_low_cst (bit_position (field
), 0);
2423 /* Return the byte position of FIELD, in bytes from the start of the record.
2424 This is a tree of type sizetype. */
2427 byte_position (const_tree field
)
2429 return byte_from_pos (DECL_FIELD_OFFSET (field
),
2430 DECL_FIELD_BIT_OFFSET (field
));
2433 /* Likewise, but return as an integer. It must be representable in
2434 that way (since it could be a signed value, we don't have the
2435 option of returning -1 like int_size_in_byte can. */
2438 int_byte_position (const_tree field
)
2440 return tree_low_cst (byte_position (field
), 0);
2443 /* Return the strictest alignment, in bits, that T is known to have. */
2446 expr_align (const_tree t
)
2448 unsigned int align0
, align1
;
2450 switch (TREE_CODE (t
))
2452 CASE_CONVERT
: case NON_LVALUE_EXPR
:
2453 /* If we have conversions, we know that the alignment of the
2454 object must meet each of the alignments of the types. */
2455 align0
= expr_align (TREE_OPERAND (t
, 0));
2456 align1
= TYPE_ALIGN (TREE_TYPE (t
));
2457 return MAX (align0
, align1
);
2459 case SAVE_EXPR
: case COMPOUND_EXPR
: case MODIFY_EXPR
:
2460 case INIT_EXPR
: case TARGET_EXPR
: case WITH_CLEANUP_EXPR
:
2461 case CLEANUP_POINT_EXPR
:
2462 /* These don't change the alignment of an object. */
2463 return expr_align (TREE_OPERAND (t
, 0));
2466 /* The best we can do is say that the alignment is the least aligned
2468 align0
= expr_align (TREE_OPERAND (t
, 1));
2469 align1
= expr_align (TREE_OPERAND (t
, 2));
2470 return MIN (align0
, align1
);
2472 /* FIXME: LABEL_DECL and CONST_DECL never have DECL_ALIGN set
2473 meaningfully, it's always 1. */
2474 case LABEL_DECL
: case CONST_DECL
:
2475 case VAR_DECL
: case PARM_DECL
: case RESULT_DECL
:
2477 gcc_assert (DECL_ALIGN (t
) != 0);
2478 return DECL_ALIGN (t
);
2484 /* Otherwise take the alignment from that of the type. */
2485 return TYPE_ALIGN (TREE_TYPE (t
));
2488 /* Return, as a tree node, the number of elements for TYPE (which is an
2489 ARRAY_TYPE) minus one. This counts only elements of the top array. */
2492 array_type_nelts (const_tree type
)
2494 tree index_type
, min
, max
;
2496 /* If they did it with unspecified bounds, then we should have already
2497 given an error about it before we got here. */
2498 if (! TYPE_DOMAIN (type
))
2499 return error_mark_node
;
2501 index_type
= TYPE_DOMAIN (type
);
2502 min
= TYPE_MIN_VALUE (index_type
);
2503 max
= TYPE_MAX_VALUE (index_type
);
2505 /* TYPE_MAX_VALUE may not be set if the array has unknown length. */
2507 return error_mark_node
;
2509 return (integer_zerop (min
)
2511 : fold_build2 (MINUS_EXPR
, TREE_TYPE (max
), max
, min
));
2514 /* If arg is static -- a reference to an object in static storage -- then
2515 return the object. This is not the same as the C meaning of `static'.
2516 If arg isn't static, return NULL. */
2521 switch (TREE_CODE (arg
))
2524 /* Nested functions are static, even though taking their address will
2525 involve a trampoline as we unnest the nested function and create
2526 the trampoline on the tree level. */
2530 return ((TREE_STATIC (arg
) || DECL_EXTERNAL (arg
))
2531 && ! DECL_THREAD_LOCAL_P (arg
)
2532 && ! DECL_DLLIMPORT_P (arg
)
2536 return ((TREE_STATIC (arg
) || DECL_EXTERNAL (arg
))
2540 return TREE_STATIC (arg
) ? arg
: NULL
;
2547 /* If the thing being referenced is not a field, then it is
2548 something language specific. */
2549 gcc_assert (TREE_CODE (TREE_OPERAND (arg
, 1)) == FIELD_DECL
);
2551 /* If we are referencing a bitfield, we can't evaluate an
2552 ADDR_EXPR at compile time and so it isn't a constant. */
2553 if (DECL_BIT_FIELD (TREE_OPERAND (arg
, 1)))
2556 return staticp (TREE_OPERAND (arg
, 0));
2562 return TREE_CONSTANT (TREE_OPERAND (arg
, 0)) ? arg
: NULL
;
2565 case ARRAY_RANGE_REF
:
2566 if (TREE_CODE (TYPE_SIZE (TREE_TYPE (arg
))) == INTEGER_CST
2567 && TREE_CODE (TREE_OPERAND (arg
, 1)) == INTEGER_CST
)
2568 return staticp (TREE_OPERAND (arg
, 0));
2572 case COMPOUND_LITERAL_EXPR
:
2573 return TREE_STATIC (COMPOUND_LITERAL_EXPR_DECL (arg
)) ? arg
: NULL
;
2583 /* Return whether OP is a DECL whose address is function-invariant. */
2586 decl_address_invariant_p (const_tree op
)
2588 /* The conditions below are slightly less strict than the one in
2591 switch (TREE_CODE (op
))
2600 if ((TREE_STATIC (op
) || DECL_EXTERNAL (op
))
2601 || DECL_THREAD_LOCAL_P (op
)
2602 || DECL_CONTEXT (op
) == current_function_decl
2603 || decl_function_context (op
) == current_function_decl
)
2608 if ((TREE_STATIC (op
) || DECL_EXTERNAL (op
))
2609 || decl_function_context (op
) == current_function_decl
)
2620 /* Return whether OP is a DECL whose address is interprocedural-invariant. */
2623 decl_address_ip_invariant_p (const_tree op
)
2625 /* The conditions below are slightly less strict than the one in
2628 switch (TREE_CODE (op
))
2636 if (((TREE_STATIC (op
) || DECL_EXTERNAL (op
))
2637 && !DECL_DLLIMPORT_P (op
))
2638 || DECL_THREAD_LOCAL_P (op
))
2643 if ((TREE_STATIC (op
) || DECL_EXTERNAL (op
)))
2655 /* Return true if T is function-invariant (internal function, does
2656 not handle arithmetic; that's handled in skip_simple_arithmetic and
2657 tree_invariant_p). */
2659 static bool tree_invariant_p (tree t
);
2662 tree_invariant_p_1 (tree t
)
2666 if (TREE_CONSTANT (t
)
2667 || (TREE_READONLY (t
) && !TREE_SIDE_EFFECTS (t
)))
2670 switch (TREE_CODE (t
))
2676 op
= TREE_OPERAND (t
, 0);
2677 while (handled_component_p (op
))
2679 switch (TREE_CODE (op
))
2682 case ARRAY_RANGE_REF
:
2683 if (!tree_invariant_p (TREE_OPERAND (op
, 1))
2684 || TREE_OPERAND (op
, 2) != NULL_TREE
2685 || TREE_OPERAND (op
, 3) != NULL_TREE
)
2690 if (TREE_OPERAND (op
, 2) != NULL_TREE
)
2696 op
= TREE_OPERAND (op
, 0);
2699 return CONSTANT_CLASS_P (op
) || decl_address_invariant_p (op
);
2708 /* Return true if T is function-invariant. */
2711 tree_invariant_p (tree t
)
2713 tree inner
= skip_simple_arithmetic (t
);
2714 return tree_invariant_p_1 (inner
);
2717 /* Wrap a SAVE_EXPR around EXPR, if appropriate.
2718 Do this to any expression which may be used in more than one place,
2719 but must be evaluated only once.
2721 Normally, expand_expr would reevaluate the expression each time.
2722 Calling save_expr produces something that is evaluated and recorded
2723 the first time expand_expr is called on it. Subsequent calls to
2724 expand_expr just reuse the recorded value.
2726 The call to expand_expr that generates code that actually computes
2727 the value is the first call *at compile time*. Subsequent calls
2728 *at compile time* generate code to use the saved value.
2729 This produces correct result provided that *at run time* control
2730 always flows through the insns made by the first expand_expr
2731 before reaching the other places where the save_expr was evaluated.
2732 You, the caller of save_expr, must make sure this is so.
2734 Constants, and certain read-only nodes, are returned with no
2735 SAVE_EXPR because that is safe. Expressions containing placeholders
2736 are not touched; see tree.def for an explanation of what these
2740 save_expr (tree expr
)
2742 tree t
= fold (expr
);
2745 /* If the tree evaluates to a constant, then we don't want to hide that
2746 fact (i.e. this allows further folding, and direct checks for constants).
2747 However, a read-only object that has side effects cannot be bypassed.
2748 Since it is no problem to reevaluate literals, we just return the
2750 inner
= skip_simple_arithmetic (t
);
2751 if (TREE_CODE (inner
) == ERROR_MARK
)
2754 if (tree_invariant_p_1 (inner
))
2757 /* If INNER contains a PLACEHOLDER_EXPR, we must evaluate it each time, since
2758 it means that the size or offset of some field of an object depends on
2759 the value within another field.
2761 Note that it must not be the case that T contains both a PLACEHOLDER_EXPR
2762 and some variable since it would then need to be both evaluated once and
2763 evaluated more than once. Front-ends must assure this case cannot
2764 happen by surrounding any such subexpressions in their own SAVE_EXPR
2765 and forcing evaluation at the proper time. */
2766 if (contains_placeholder_p (inner
))
2769 t
= build1 (SAVE_EXPR
, TREE_TYPE (expr
), t
);
2770 SET_EXPR_LOCATION (t
, EXPR_LOCATION (expr
));
2772 /* This expression might be placed ahead of a jump to ensure that the
2773 value was computed on both sides of the jump. So make sure it isn't
2774 eliminated as dead. */
2775 TREE_SIDE_EFFECTS (t
) = 1;
2779 /* Look inside EXPR and into any simple arithmetic operations. Return
2780 the innermost non-arithmetic node. */
2783 skip_simple_arithmetic (tree expr
)
2787 /* We don't care about whether this can be used as an lvalue in this
2789 while (TREE_CODE (expr
) == NON_LVALUE_EXPR
)
2790 expr
= TREE_OPERAND (expr
, 0);
2792 /* If we have simple operations applied to a SAVE_EXPR or to a SAVE_EXPR and
2793 a constant, it will be more efficient to not make another SAVE_EXPR since
2794 it will allow better simplification and GCSE will be able to merge the
2795 computations if they actually occur. */
2799 if (UNARY_CLASS_P (inner
))
2800 inner
= TREE_OPERAND (inner
, 0);
2801 else if (BINARY_CLASS_P (inner
))
2803 if (tree_invariant_p (TREE_OPERAND (inner
, 1)))
2804 inner
= TREE_OPERAND (inner
, 0);
2805 else if (tree_invariant_p (TREE_OPERAND (inner
, 0)))
2806 inner
= TREE_OPERAND (inner
, 1);
2818 /* Return which tree structure is used by T. */
2820 enum tree_node_structure_enum
2821 tree_node_structure (const_tree t
)
2823 const enum tree_code code
= TREE_CODE (t
);
2824 return tree_node_structure_for_code (code
);
2827 /* Set various status flags when building a CALL_EXPR object T. */
2830 process_call_operands (tree t
)
2832 bool side_effects
= TREE_SIDE_EFFECTS (t
);
2833 bool read_only
= false;
2834 int i
= call_expr_flags (t
);
2836 /* Calls have side-effects, except those to const or pure functions. */
2837 if ((i
& ECF_LOOPING_CONST_OR_PURE
) || !(i
& (ECF_CONST
| ECF_PURE
)))
2838 side_effects
= true;
2839 /* Propagate TREE_READONLY of arguments for const functions. */
2843 if (!side_effects
|| read_only
)
2844 for (i
= 1; i
< TREE_OPERAND_LENGTH (t
); i
++)
2846 tree op
= TREE_OPERAND (t
, i
);
2847 if (op
&& TREE_SIDE_EFFECTS (op
))
2848 side_effects
= true;
2849 if (op
&& !TREE_READONLY (op
) && !CONSTANT_CLASS_P (op
))
2853 TREE_SIDE_EFFECTS (t
) = side_effects
;
2854 TREE_READONLY (t
) = read_only
;
2857 /* Return true if EXP contains a PLACEHOLDER_EXPR, i.e. if it represents a
2858 size or offset that depends on a field within a record. */
2861 contains_placeholder_p (const_tree exp
)
2863 enum tree_code code
;
2868 code
= TREE_CODE (exp
);
2869 if (code
== PLACEHOLDER_EXPR
)
2872 switch (TREE_CODE_CLASS (code
))
2875 /* Don't look at any PLACEHOLDER_EXPRs that might be in index or bit
2876 position computations since they will be converted into a
2877 WITH_RECORD_EXPR involving the reference, which will assume
2878 here will be valid. */
2879 return CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp
, 0));
2881 case tcc_exceptional
:
2882 if (code
== TREE_LIST
)
2883 return (CONTAINS_PLACEHOLDER_P (TREE_VALUE (exp
))
2884 || CONTAINS_PLACEHOLDER_P (TREE_CHAIN (exp
)));
2889 case tcc_comparison
:
2890 case tcc_expression
:
2894 /* Ignoring the first operand isn't quite right, but works best. */
2895 return CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp
, 1));
2898 return (CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp
, 0))
2899 || CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp
, 1))
2900 || CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp
, 2)));
2903 /* The save_expr function never wraps anything containing
2904 a PLACEHOLDER_EXPR. */
2911 switch (TREE_CODE_LENGTH (code
))
2914 return CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp
, 0));
2916 return (CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp
, 0))
2917 || CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp
, 1)));
2928 const_call_expr_arg_iterator iter
;
2929 FOR_EACH_CONST_CALL_EXPR_ARG (arg
, iter
, exp
)
2930 if (CONTAINS_PLACEHOLDER_P (arg
))
2944 /* Return true if any part of the structure of TYPE involves a PLACEHOLDER_EXPR
2945 directly. This includes size, bounds, qualifiers (for QUAL_UNION_TYPE) and
2949 type_contains_placeholder_1 (const_tree type
)
2951 /* If the size contains a placeholder or the parent type (component type in
2952 the case of arrays) type involves a placeholder, this type does. */
2953 if (CONTAINS_PLACEHOLDER_P (TYPE_SIZE (type
))
2954 || CONTAINS_PLACEHOLDER_P (TYPE_SIZE_UNIT (type
))
2955 || (!POINTER_TYPE_P (type
)
2957 && type_contains_placeholder_p (TREE_TYPE (type
))))
2960 /* Now do type-specific checks. Note that the last part of the check above
2961 greatly limits what we have to do below. */
2962 switch (TREE_CODE (type
))
2970 case REFERENCE_TYPE
:
2978 case FIXED_POINT_TYPE
:
2979 /* Here we just check the bounds. */
2980 return (CONTAINS_PLACEHOLDER_P (TYPE_MIN_VALUE (type
))
2981 || CONTAINS_PLACEHOLDER_P (TYPE_MAX_VALUE (type
)));
2984 /* We have already checked the component type above, so just check the
2986 return type_contains_placeholder_p (TYPE_DOMAIN (type
));
2990 case QUAL_UNION_TYPE
:
2994 for (field
= TYPE_FIELDS (type
); field
; field
= DECL_CHAIN (field
))
2995 if (TREE_CODE (field
) == FIELD_DECL
2996 && (CONTAINS_PLACEHOLDER_P (DECL_FIELD_OFFSET (field
))
2997 || (TREE_CODE (type
) == QUAL_UNION_TYPE
2998 && CONTAINS_PLACEHOLDER_P (DECL_QUALIFIER (field
)))
2999 || type_contains_placeholder_p (TREE_TYPE (field
))))
3010 /* Wrapper around above function used to cache its result. */
3013 type_contains_placeholder_p (tree type
)
3017 /* If the contains_placeholder_bits field has been initialized,
3018 then we know the answer. */
3019 if (TYPE_CONTAINS_PLACEHOLDER_INTERNAL (type
) > 0)
3020 return TYPE_CONTAINS_PLACEHOLDER_INTERNAL (type
) - 1;
3022 /* Indicate that we've seen this type node, and the answer is false.
3023 This is what we want to return if we run into recursion via fields. */
3024 TYPE_CONTAINS_PLACEHOLDER_INTERNAL (type
) = 1;
3026 /* Compute the real value. */
3027 result
= type_contains_placeholder_1 (type
);
3029 /* Store the real value. */
3030 TYPE_CONTAINS_PLACEHOLDER_INTERNAL (type
) = result
+ 1;
3035 /* Push tree EXP onto vector QUEUE if it is not already present. */
3038 push_without_duplicates (tree exp
, VEC (tree
, heap
) **queue
)
3043 FOR_EACH_VEC_ELT (tree
, *queue
, i
, iter
)
3044 if (simple_cst_equal (iter
, exp
) == 1)
3048 VEC_safe_push (tree
, heap
, *queue
, exp
);
3051 /* Given a tree EXP, find all occurences of references to fields
3052 in a PLACEHOLDER_EXPR and place them in vector REFS without
3053 duplicates. Also record VAR_DECLs and CONST_DECLs. Note that
3054 we assume here that EXP contains only arithmetic expressions
3055 or CALL_EXPRs with PLACEHOLDER_EXPRs occurring only in their
3059 find_placeholder_in_expr (tree exp
, VEC (tree
, heap
) **refs
)
3061 enum tree_code code
= TREE_CODE (exp
);
3065 /* We handle TREE_LIST and COMPONENT_REF separately. */
3066 if (code
== TREE_LIST
)
3068 FIND_PLACEHOLDER_IN_EXPR (TREE_CHAIN (exp
), refs
);
3069 FIND_PLACEHOLDER_IN_EXPR (TREE_VALUE (exp
), refs
);
3071 else if (code
== COMPONENT_REF
)
3073 for (inner
= TREE_OPERAND (exp
, 0);
3074 REFERENCE_CLASS_P (inner
);
3075 inner
= TREE_OPERAND (inner
, 0))
3078 if (TREE_CODE (inner
) == PLACEHOLDER_EXPR
)
3079 push_without_duplicates (exp
, refs
);
3081 FIND_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp
, 0), refs
);
3084 switch (TREE_CODE_CLASS (code
))
3089 case tcc_declaration
:
3090 /* Variables allocated to static storage can stay. */
3091 if (!TREE_STATIC (exp
))
3092 push_without_duplicates (exp
, refs
);
3095 case tcc_expression
:
3096 /* This is the pattern built in ada/make_aligning_type. */
3097 if (code
== ADDR_EXPR
3098 && TREE_CODE (TREE_OPERAND (exp
, 0)) == PLACEHOLDER_EXPR
)
3100 push_without_duplicates (exp
, refs
);
3104 /* Fall through... */
3106 case tcc_exceptional
:
3109 case tcc_comparison
:
3111 for (i
= 0; i
< TREE_CODE_LENGTH (code
); i
++)
3112 FIND_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp
, i
), refs
);
3116 for (i
= 1; i
< TREE_OPERAND_LENGTH (exp
); i
++)
3117 FIND_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp
, i
), refs
);
3125 /* Given a tree EXP, a FIELD_DECL F, and a replacement value R,
3126 return a tree with all occurrences of references to F in a
3127 PLACEHOLDER_EXPR replaced by R. Also handle VAR_DECLs and
3128 CONST_DECLs. Note that we assume here that EXP contains only
3129 arithmetic expressions or CALL_EXPRs with PLACEHOLDER_EXPRs
3130 occurring only in their argument list. */
3133 substitute_in_expr (tree exp
, tree f
, tree r
)
3135 enum tree_code code
= TREE_CODE (exp
);
3136 tree op0
, op1
, op2
, op3
;
3139 /* We handle TREE_LIST and COMPONENT_REF separately. */
3140 if (code
== TREE_LIST
)
3142 op0
= SUBSTITUTE_IN_EXPR (TREE_CHAIN (exp
), f
, r
);
3143 op1
= SUBSTITUTE_IN_EXPR (TREE_VALUE (exp
), f
, r
);
3144 if (op0
== TREE_CHAIN (exp
) && op1
== TREE_VALUE (exp
))
3147 return tree_cons (TREE_PURPOSE (exp
), op1
, op0
);
3149 else if (code
== COMPONENT_REF
)
3153 /* If this expression is getting a value from a PLACEHOLDER_EXPR
3154 and it is the right field, replace it with R. */
3155 for (inner
= TREE_OPERAND (exp
, 0);
3156 REFERENCE_CLASS_P (inner
);
3157 inner
= TREE_OPERAND (inner
, 0))
3161 op1
= TREE_OPERAND (exp
, 1);
3163 if (TREE_CODE (inner
) == PLACEHOLDER_EXPR
&& op1
== f
)
3166 /* If this expression hasn't been completed let, leave it alone. */
3167 if (TREE_CODE (inner
) == PLACEHOLDER_EXPR
&& !TREE_TYPE (inner
))
3170 op0
= SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp
, 0), f
, r
);
3171 if (op0
== TREE_OPERAND (exp
, 0))
3175 = fold_build3 (COMPONENT_REF
, TREE_TYPE (exp
), op0
, op1
, NULL_TREE
);
3178 switch (TREE_CODE_CLASS (code
))
3183 case tcc_declaration
:
3189 case tcc_expression
:
3193 /* Fall through... */
3195 case tcc_exceptional
:
3198 case tcc_comparison
:
3200 switch (TREE_CODE_LENGTH (code
))
3206 op0
= SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp
, 0), f
, r
);
3207 if (op0
== TREE_OPERAND (exp
, 0))
3210 new_tree
= fold_build1 (code
, TREE_TYPE (exp
), op0
);
3214 op0
= SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp
, 0), f
, r
);
3215 op1
= SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp
, 1), f
, r
);
3217 if (op0
== TREE_OPERAND (exp
, 0) && op1
== TREE_OPERAND (exp
, 1))
3220 new_tree
= fold_build2 (code
, TREE_TYPE (exp
), op0
, op1
);
3224 op0
= SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp
, 0), f
, r
);
3225 op1
= SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp
, 1), f
, r
);
3226 op2
= SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp
, 2), f
, r
);
3228 if (op0
== TREE_OPERAND (exp
, 0) && op1
== TREE_OPERAND (exp
, 1)
3229 && op2
== TREE_OPERAND (exp
, 2))
3232 new_tree
= fold_build3 (code
, TREE_TYPE (exp
), op0
, op1
, op2
);
3236 op0
= SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp
, 0), f
, r
);
3237 op1
= SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp
, 1), f
, r
);
3238 op2
= SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp
, 2), f
, r
);
3239 op3
= SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp
, 3), f
, r
);
3241 if (op0
== TREE_OPERAND (exp
, 0) && op1
== TREE_OPERAND (exp
, 1)
3242 && op2
== TREE_OPERAND (exp
, 2)
3243 && op3
== TREE_OPERAND (exp
, 3))
3247 = fold (build4 (code
, TREE_TYPE (exp
), op0
, op1
, op2
, op3
));
3259 new_tree
= NULL_TREE
;
3261 /* If we are trying to replace F with a constant, inline back
3262 functions which do nothing else than computing a value from
3263 the arguments they are passed. This makes it possible to
3264 fold partially or entirely the replacement expression. */
3265 if (CONSTANT_CLASS_P (r
) && code
== CALL_EXPR
)
3267 tree t
= maybe_inline_call_in_expr (exp
);
3269 return SUBSTITUTE_IN_EXPR (t
, f
, r
);
3272 for (i
= 1; i
< TREE_OPERAND_LENGTH (exp
); i
++)
3274 tree op
= TREE_OPERAND (exp
, i
);
3275 tree new_op
= SUBSTITUTE_IN_EXPR (op
, f
, r
);
3279 new_tree
= copy_node (exp
);
3280 TREE_OPERAND (new_tree
, i
) = new_op
;
3286 new_tree
= fold (new_tree
);
3287 if (TREE_CODE (new_tree
) == CALL_EXPR
)
3288 process_call_operands (new_tree
);
3299 TREE_READONLY (new_tree
) |= TREE_READONLY (exp
);
3301 if (code
== INDIRECT_REF
|| code
== ARRAY_REF
|| code
== ARRAY_RANGE_REF
)
3302 TREE_THIS_NOTRAP (new_tree
) |= TREE_THIS_NOTRAP (exp
);
3307 /* Similar, but look for a PLACEHOLDER_EXPR in EXP and find a replacement
3308 for it within OBJ, a tree that is an object or a chain of references. */
3311 substitute_placeholder_in_expr (tree exp
, tree obj
)
3313 enum tree_code code
= TREE_CODE (exp
);
3314 tree op0
, op1
, op2
, op3
;
3317 /* If this is a PLACEHOLDER_EXPR, see if we find a corresponding type
3318 in the chain of OBJ. */
3319 if (code
== PLACEHOLDER_EXPR
)
3321 tree need_type
= TYPE_MAIN_VARIANT (TREE_TYPE (exp
));
3324 for (elt
= obj
; elt
!= 0;
3325 elt
= ((TREE_CODE (elt
) == COMPOUND_EXPR
3326 || TREE_CODE (elt
) == COND_EXPR
)
3327 ? TREE_OPERAND (elt
, 1)
3328 : (REFERENCE_CLASS_P (elt
)
3329 || UNARY_CLASS_P (elt
)
3330 || BINARY_CLASS_P (elt
)
3331 || VL_EXP_CLASS_P (elt
)
3332 || EXPRESSION_CLASS_P (elt
))
3333 ? TREE_OPERAND (elt
, 0) : 0))
3334 if (TYPE_MAIN_VARIANT (TREE_TYPE (elt
)) == need_type
)
3337 for (elt
= obj
; elt
!= 0;
3338 elt
= ((TREE_CODE (elt
) == COMPOUND_EXPR
3339 || TREE_CODE (elt
) == COND_EXPR
)
3340 ? TREE_OPERAND (elt
, 1)
3341 : (REFERENCE_CLASS_P (elt
)
3342 || UNARY_CLASS_P (elt
)
3343 || BINARY_CLASS_P (elt
)
3344 || VL_EXP_CLASS_P (elt
)
3345 || EXPRESSION_CLASS_P (elt
))
3346 ? TREE_OPERAND (elt
, 0) : 0))
3347 if (POINTER_TYPE_P (TREE_TYPE (elt
))
3348 && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (elt
)))
3350 return fold_build1 (INDIRECT_REF
, need_type
, elt
);
3352 /* If we didn't find it, return the original PLACEHOLDER_EXPR. If it
3353 survives until RTL generation, there will be an error. */
3357 /* TREE_LIST is special because we need to look at TREE_VALUE
3358 and TREE_CHAIN, not TREE_OPERANDS. */
3359 else if (code
== TREE_LIST
)
3361 op0
= SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_CHAIN (exp
), obj
);
3362 op1
= SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_VALUE (exp
), obj
);
3363 if (op0
== TREE_CHAIN (exp
) && op1
== TREE_VALUE (exp
))
3366 return tree_cons (TREE_PURPOSE (exp
), op1
, op0
);
3369 switch (TREE_CODE_CLASS (code
))
3372 case tcc_declaration
:
3375 case tcc_exceptional
:
3378 case tcc_comparison
:
3379 case tcc_expression
:
3382 switch (TREE_CODE_LENGTH (code
))
3388 op0
= SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp
, 0), obj
);
3389 if (op0
== TREE_OPERAND (exp
, 0))
3392 new_tree
= fold_build1 (code
, TREE_TYPE (exp
), op0
);
3396 op0
= SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp
, 0), obj
);
3397 op1
= SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp
, 1), obj
);
3399 if (op0
== TREE_OPERAND (exp
, 0) && op1
== TREE_OPERAND (exp
, 1))
3402 new_tree
= fold_build2 (code
, TREE_TYPE (exp
), op0
, op1
);
3406 op0
= SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp
, 0), obj
);
3407 op1
= SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp
, 1), obj
);
3408 op2
= SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp
, 2), obj
);
3410 if (op0
== TREE_OPERAND (exp
, 0) && op1
== TREE_OPERAND (exp
, 1)
3411 && op2
== TREE_OPERAND (exp
, 2))
3414 new_tree
= fold_build3 (code
, TREE_TYPE (exp
), op0
, op1
, op2
);
3418 op0
= SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp
, 0), obj
);
3419 op1
= SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp
, 1), obj
);
3420 op2
= SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp
, 2), obj
);
3421 op3
= SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp
, 3), obj
);
3423 if (op0
== TREE_OPERAND (exp
, 0) && op1
== TREE_OPERAND (exp
, 1)
3424 && op2
== TREE_OPERAND (exp
, 2)
3425 && op3
== TREE_OPERAND (exp
, 3))
3429 = fold (build4 (code
, TREE_TYPE (exp
), op0
, op1
, op2
, op3
));
3441 new_tree
= NULL_TREE
;
3443 for (i
= 1; i
< TREE_OPERAND_LENGTH (exp
); i
++)
3445 tree op
= TREE_OPERAND (exp
, i
);
3446 tree new_op
= SUBSTITUTE_PLACEHOLDER_IN_EXPR (op
, obj
);
3450 new_tree
= copy_node (exp
);
3451 TREE_OPERAND (new_tree
, i
) = new_op
;
3457 new_tree
= fold (new_tree
);
3458 if (TREE_CODE (new_tree
) == CALL_EXPR
)
3459 process_call_operands (new_tree
);
3470 TREE_READONLY (new_tree
) |= TREE_READONLY (exp
);
3472 if (code
== INDIRECT_REF
|| code
== ARRAY_REF
|| code
== ARRAY_RANGE_REF
)
3473 TREE_THIS_NOTRAP (new_tree
) |= TREE_THIS_NOTRAP (exp
);
3478 /* Stabilize a reference so that we can use it any number of times
3479 without causing its operands to be evaluated more than once.
3480 Returns the stabilized reference. This works by means of save_expr,
3481 so see the caveats in the comments about save_expr.
3483 Also allows conversion expressions whose operands are references.
3484 Any other kind of expression is returned unchanged. */
3487 stabilize_reference (tree ref
)
3490 enum tree_code code
= TREE_CODE (ref
);
3497 /* No action is needed in this case. */
3502 case FIX_TRUNC_EXPR
:
3503 result
= build_nt (code
, stabilize_reference (TREE_OPERAND (ref
, 0)));
3507 result
= build_nt (INDIRECT_REF
,
3508 stabilize_reference_1 (TREE_OPERAND (ref
, 0)));
3512 result
= build_nt (COMPONENT_REF
,
3513 stabilize_reference (TREE_OPERAND (ref
, 0)),
3514 TREE_OPERAND (ref
, 1), NULL_TREE
);
3518 result
= build_nt (BIT_FIELD_REF
,
3519 stabilize_reference (TREE_OPERAND (ref
, 0)),
3520 stabilize_reference_1 (TREE_OPERAND (ref
, 1)),
3521 stabilize_reference_1 (TREE_OPERAND (ref
, 2)));
3525 result
= build_nt (ARRAY_REF
,
3526 stabilize_reference (TREE_OPERAND (ref
, 0)),
3527 stabilize_reference_1 (TREE_OPERAND (ref
, 1)),
3528 TREE_OPERAND (ref
, 2), TREE_OPERAND (ref
, 3));
3531 case ARRAY_RANGE_REF
:
3532 result
= build_nt (ARRAY_RANGE_REF
,
3533 stabilize_reference (TREE_OPERAND (ref
, 0)),
3534 stabilize_reference_1 (TREE_OPERAND (ref
, 1)),
3535 TREE_OPERAND (ref
, 2), TREE_OPERAND (ref
, 3));
3539 /* We cannot wrap the first expression in a SAVE_EXPR, as then
3540 it wouldn't be ignored. This matters when dealing with
3542 return stabilize_reference_1 (ref
);
3544 /* If arg isn't a kind of lvalue we recognize, make no change.
3545 Caller should recognize the error for an invalid lvalue. */
3550 return error_mark_node
;
3553 TREE_TYPE (result
) = TREE_TYPE (ref
);
3554 TREE_READONLY (result
) = TREE_READONLY (ref
);
3555 TREE_SIDE_EFFECTS (result
) = TREE_SIDE_EFFECTS (ref
);
3556 TREE_THIS_VOLATILE (result
) = TREE_THIS_VOLATILE (ref
);
3561 /* Subroutine of stabilize_reference; this is called for subtrees of
3562 references. Any expression with side-effects must be put in a SAVE_EXPR
3563 to ensure that it is only evaluated once.
3565 We don't put SAVE_EXPR nodes around everything, because assigning very
3566 simple expressions to temporaries causes us to miss good opportunities
3567 for optimizations. Among other things, the opportunity to fold in the
3568 addition of a constant into an addressing mode often gets lost, e.g.
3569 "y[i+1] += x;". In general, we take the approach that we should not make
3570 an assignment unless we are forced into it - i.e., that any non-side effect
3571 operator should be allowed, and that cse should take care of coalescing
3572 multiple utterances of the same expression should that prove fruitful. */
3575 stabilize_reference_1 (tree e
)
3578 enum tree_code code
= TREE_CODE (e
);
3580 /* We cannot ignore const expressions because it might be a reference
3581 to a const array but whose index contains side-effects. But we can
3582 ignore things that are actual constant or that already have been
3583 handled by this function. */
3585 if (tree_invariant_p (e
))
3588 switch (TREE_CODE_CLASS (code
))
3590 case tcc_exceptional
:
3592 case tcc_declaration
:
3593 case tcc_comparison
:
3595 case tcc_expression
:
3598 /* If the expression has side-effects, then encase it in a SAVE_EXPR
3599 so that it will only be evaluated once. */
3600 /* The reference (r) and comparison (<) classes could be handled as
3601 below, but it is generally faster to only evaluate them once. */
3602 if (TREE_SIDE_EFFECTS (e
))
3603 return save_expr (e
);
3607 /* Constants need no processing. In fact, we should never reach
3612 /* Division is slow and tends to be compiled with jumps,
3613 especially the division by powers of 2 that is often
3614 found inside of an array reference. So do it just once. */
3615 if (code
== TRUNC_DIV_EXPR
|| code
== TRUNC_MOD_EXPR
3616 || code
== FLOOR_DIV_EXPR
|| code
== FLOOR_MOD_EXPR
3617 || code
== CEIL_DIV_EXPR
|| code
== CEIL_MOD_EXPR
3618 || code
== ROUND_DIV_EXPR
|| code
== ROUND_MOD_EXPR
)
3619 return save_expr (e
);
3620 /* Recursively stabilize each operand. */
3621 result
= build_nt (code
, stabilize_reference_1 (TREE_OPERAND (e
, 0)),
3622 stabilize_reference_1 (TREE_OPERAND (e
, 1)));
3626 /* Recursively stabilize each operand. */
3627 result
= build_nt (code
, stabilize_reference_1 (TREE_OPERAND (e
, 0)));
3634 TREE_TYPE (result
) = TREE_TYPE (e
);
3635 TREE_READONLY (result
) = TREE_READONLY (e
);
3636 TREE_SIDE_EFFECTS (result
) = TREE_SIDE_EFFECTS (e
);
3637 TREE_THIS_VOLATILE (result
) = TREE_THIS_VOLATILE (e
);
3642 /* Low-level constructors for expressions. */
3644 /* A helper function for build1 and constant folders. Set TREE_CONSTANT,
3645 and TREE_SIDE_EFFECTS for an ADDR_EXPR. */
3648 recompute_tree_invariant_for_addr_expr (tree t
)
3651 bool tc
= true, se
= false;
3653 /* We started out assuming this address is both invariant and constant, but
3654 does not have side effects. Now go down any handled components and see if
3655 any of them involve offsets that are either non-constant or non-invariant.
3656 Also check for side-effects.
3658 ??? Note that this code makes no attempt to deal with the case where
3659 taking the address of something causes a copy due to misalignment. */
3661 #define UPDATE_FLAGS(NODE) \
3662 do { tree _node = (NODE); \
3663 if (_node && !TREE_CONSTANT (_node)) tc = false; \
3664 if (_node && TREE_SIDE_EFFECTS (_node)) se = true; } while (0)
3666 for (node
= TREE_OPERAND (t
, 0); handled_component_p (node
);
3667 node
= TREE_OPERAND (node
, 0))
3669 /* If the first operand doesn't have an ARRAY_TYPE, this is a bogus
3670 array reference (probably made temporarily by the G++ front end),
3671 so ignore all the operands. */
3672 if ((TREE_CODE (node
) == ARRAY_REF
3673 || TREE_CODE (node
) == ARRAY_RANGE_REF
)
3674 && TREE_CODE (TREE_TYPE (TREE_OPERAND (node
, 0))) == ARRAY_TYPE
)
3676 UPDATE_FLAGS (TREE_OPERAND (node
, 1));
3677 if (TREE_OPERAND (node
, 2))
3678 UPDATE_FLAGS (TREE_OPERAND (node
, 2));
3679 if (TREE_OPERAND (node
, 3))
3680 UPDATE_FLAGS (TREE_OPERAND (node
, 3));
3682 /* Likewise, just because this is a COMPONENT_REF doesn't mean we have a
3683 FIELD_DECL, apparently. The G++ front end can put something else
3684 there, at least temporarily. */
3685 else if (TREE_CODE (node
) == COMPONENT_REF
3686 && TREE_CODE (TREE_OPERAND (node
, 1)) == FIELD_DECL
)
3688 if (TREE_OPERAND (node
, 2))
3689 UPDATE_FLAGS (TREE_OPERAND (node
, 2));
3691 else if (TREE_CODE (node
) == BIT_FIELD_REF
)
3692 UPDATE_FLAGS (TREE_OPERAND (node
, 2));
3695 node
= lang_hooks
.expr_to_decl (node
, &tc
, &se
);
3697 /* Now see what's inside. If it's an INDIRECT_REF, copy our properties from
3698 the address, since &(*a)->b is a form of addition. If it's a constant, the
3699 address is constant too. If it's a decl, its address is constant if the
3700 decl is static. Everything else is not constant and, furthermore,
3701 taking the address of a volatile variable is not volatile. */
3702 if (TREE_CODE (node
) == INDIRECT_REF
3703 || TREE_CODE (node
) == MEM_REF
)
3704 UPDATE_FLAGS (TREE_OPERAND (node
, 0));
3705 else if (CONSTANT_CLASS_P (node
))
3707 else if (DECL_P (node
))
3708 tc
&= (staticp (node
) != NULL_TREE
);
3712 se
|= TREE_SIDE_EFFECTS (node
);
3716 TREE_CONSTANT (t
) = tc
;
3717 TREE_SIDE_EFFECTS (t
) = se
;
3721 /* Build an expression of code CODE, data type TYPE, and operands as
3722 specified. Expressions and reference nodes can be created this way.
3723 Constants, decls, types and misc nodes cannot be.
3725 We define 5 non-variadic functions, from 0 to 4 arguments. This is
3726 enough for all extant tree codes. */
3729 build0_stat (enum tree_code code
, tree tt MEM_STAT_DECL
)
3733 gcc_assert (TREE_CODE_LENGTH (code
) == 0);
3735 t
= make_node_stat (code PASS_MEM_STAT
);
3742 build1_stat (enum tree_code code
, tree type
, tree node MEM_STAT_DECL
)
3744 int length
= sizeof (struct tree_exp
);
3747 record_node_allocation_statistics (code
, length
);
3749 gcc_assert (TREE_CODE_LENGTH (code
) == 1);
3751 t
= ggc_alloc_zone_tree_node_stat (&tree_zone
, length PASS_MEM_STAT
);
3753 memset (t
, 0, sizeof (struct tree_common
));
3755 TREE_SET_CODE (t
, code
);
3757 TREE_TYPE (t
) = type
;
3758 SET_EXPR_LOCATION (t
, UNKNOWN_LOCATION
);
3759 TREE_OPERAND (t
, 0) = node
;
3760 TREE_BLOCK (t
) = NULL_TREE
;
3761 if (node
&& !TYPE_P (node
))
3763 TREE_SIDE_EFFECTS (t
) = TREE_SIDE_EFFECTS (node
);
3764 TREE_READONLY (t
) = TREE_READONLY (node
);
3767 if (TREE_CODE_CLASS (code
) == tcc_statement
)
3768 TREE_SIDE_EFFECTS (t
) = 1;
3772 /* All of these have side-effects, no matter what their
3774 TREE_SIDE_EFFECTS (t
) = 1;
3775 TREE_READONLY (t
) = 0;
3779 /* Whether a dereference is readonly has nothing to do with whether
3780 its operand is readonly. */
3781 TREE_READONLY (t
) = 0;
3786 recompute_tree_invariant_for_addr_expr (t
);
3790 if ((TREE_CODE_CLASS (code
) == tcc_unary
|| code
== VIEW_CONVERT_EXPR
)
3791 && node
&& !TYPE_P (node
)
3792 && TREE_CONSTANT (node
))
3793 TREE_CONSTANT (t
) = 1;
3794 if (TREE_CODE_CLASS (code
) == tcc_reference
3795 && node
&& TREE_THIS_VOLATILE (node
))
3796 TREE_THIS_VOLATILE (t
) = 1;
3803 #define PROCESS_ARG(N) \
3805 TREE_OPERAND (t, N) = arg##N; \
3806 if (arg##N &&!TYPE_P (arg##N)) \
3808 if (TREE_SIDE_EFFECTS (arg##N)) \
3810 if (!TREE_READONLY (arg##N) \
3811 && !CONSTANT_CLASS_P (arg##N)) \
3812 (void) (read_only = 0); \
3813 if (!TREE_CONSTANT (arg##N)) \
3814 (void) (constant = 0); \
3819 build2_stat (enum tree_code code
, tree tt
, tree arg0
, tree arg1 MEM_STAT_DECL
)
3821 bool constant
, read_only
, side_effects
;
3824 gcc_assert (TREE_CODE_LENGTH (code
) == 2);
3826 if ((code
== MINUS_EXPR
|| code
== PLUS_EXPR
|| code
== MULT_EXPR
)
3827 && arg0
&& arg1
&& tt
&& POINTER_TYPE_P (tt
)
3828 /* When sizetype precision doesn't match that of pointers
3829 we need to be able to build explicit extensions or truncations
3830 of the offset argument. */
3831 && TYPE_PRECISION (sizetype
) == TYPE_PRECISION (tt
))
3832 gcc_assert (TREE_CODE (arg0
) == INTEGER_CST
3833 && TREE_CODE (arg1
) == INTEGER_CST
);
3835 if (code
== POINTER_PLUS_EXPR
&& arg0
&& arg1
&& tt
)
3836 gcc_assert (POINTER_TYPE_P (tt
) && POINTER_TYPE_P (TREE_TYPE (arg0
))
3837 && ptrofftype_p (TREE_TYPE (arg1
)));
3839 t
= make_node_stat (code PASS_MEM_STAT
);
3842 /* Below, we automatically set TREE_SIDE_EFFECTS and TREE_READONLY for the
3843 result based on those same flags for the arguments. But if the
3844 arguments aren't really even `tree' expressions, we shouldn't be trying
3847 /* Expressions without side effects may be constant if their
3848 arguments are as well. */
3849 constant
= (TREE_CODE_CLASS (code
) == tcc_comparison
3850 || TREE_CODE_CLASS (code
) == tcc_binary
);
3852 side_effects
= TREE_SIDE_EFFECTS (t
);
3857 TREE_READONLY (t
) = read_only
;
3858 TREE_CONSTANT (t
) = constant
;
3859 TREE_SIDE_EFFECTS (t
) = side_effects
;
3860 TREE_THIS_VOLATILE (t
)
3861 = (TREE_CODE_CLASS (code
) == tcc_reference
3862 && arg0
&& TREE_THIS_VOLATILE (arg0
));
3869 build3_stat (enum tree_code code
, tree tt
, tree arg0
, tree arg1
,
3870 tree arg2 MEM_STAT_DECL
)
3872 bool constant
, read_only
, side_effects
;
3875 gcc_assert (TREE_CODE_LENGTH (code
) == 3);
3876 gcc_assert (TREE_CODE_CLASS (code
) != tcc_vl_exp
);
3878 t
= make_node_stat (code PASS_MEM_STAT
);
3883 /* As a special exception, if COND_EXPR has NULL branches, we
3884 assume that it is a gimple statement and always consider
3885 it to have side effects. */
3886 if (code
== COND_EXPR
3887 && tt
== void_type_node
3888 && arg1
== NULL_TREE
3889 && arg2
== NULL_TREE
)
3890 side_effects
= true;
3892 side_effects
= TREE_SIDE_EFFECTS (t
);
3898 if (code
== COND_EXPR
)
3899 TREE_READONLY (t
) = read_only
;
3901 TREE_SIDE_EFFECTS (t
) = side_effects
;
3902 TREE_THIS_VOLATILE (t
)
3903 = (TREE_CODE_CLASS (code
) == tcc_reference
3904 && arg0
&& TREE_THIS_VOLATILE (arg0
));
3910 build4_stat (enum tree_code code
, tree tt
, tree arg0
, tree arg1
,
3911 tree arg2
, tree arg3 MEM_STAT_DECL
)
3913 bool constant
, read_only
, side_effects
;
3916 gcc_assert (TREE_CODE_LENGTH (code
) == 4);
3918 t
= make_node_stat (code PASS_MEM_STAT
);
3921 side_effects
= TREE_SIDE_EFFECTS (t
);
3928 TREE_SIDE_EFFECTS (t
) = side_effects
;
3929 TREE_THIS_VOLATILE (t
)
3930 = (TREE_CODE_CLASS (code
) == tcc_reference
3931 && arg0
&& TREE_THIS_VOLATILE (arg0
));
3937 build5_stat (enum tree_code code
, tree tt
, tree arg0
, tree arg1
,
3938 tree arg2
, tree arg3
, tree arg4 MEM_STAT_DECL
)
3940 bool constant
, read_only
, side_effects
;
3943 gcc_assert (TREE_CODE_LENGTH (code
) == 5);
3945 t
= make_node_stat (code PASS_MEM_STAT
);
3948 side_effects
= TREE_SIDE_EFFECTS (t
);
3956 TREE_SIDE_EFFECTS (t
) = side_effects
;
3957 TREE_THIS_VOLATILE (t
)
3958 = (TREE_CODE_CLASS (code
) == tcc_reference
3959 && arg0
&& TREE_THIS_VOLATILE (arg0
));
3965 build6_stat (enum tree_code code
, tree tt
, tree arg0
, tree arg1
,
3966 tree arg2
, tree arg3
, tree arg4
, tree arg5 MEM_STAT_DECL
)
3968 bool constant
, read_only
, side_effects
;
3971 gcc_assert (code
== TARGET_MEM_REF
);
3973 t
= make_node_stat (code PASS_MEM_STAT
);
3976 side_effects
= TREE_SIDE_EFFECTS (t
);
3983 if (code
== TARGET_MEM_REF
)
3987 TREE_SIDE_EFFECTS (t
) = side_effects
;
3988 TREE_THIS_VOLATILE (t
)
3989 = (code
== TARGET_MEM_REF
3990 && arg5
&& TREE_THIS_VOLATILE (arg5
));
3995 /* Build a simple MEM_REF tree with the sematics of a plain INDIRECT_REF
3996 on the pointer PTR. */
3999 build_simple_mem_ref_loc (location_t loc
, tree ptr
)
4001 HOST_WIDE_INT offset
= 0;
4002 tree ptype
= TREE_TYPE (ptr
);
4004 /* For convenience allow addresses that collapse to a simple base
4006 if (TREE_CODE (ptr
) == ADDR_EXPR
4007 && (handled_component_p (TREE_OPERAND (ptr
, 0))
4008 || TREE_CODE (TREE_OPERAND (ptr
, 0)) == MEM_REF
))
4010 ptr
= get_addr_base_and_unit_offset (TREE_OPERAND (ptr
, 0), &offset
);
4012 ptr
= build_fold_addr_expr (ptr
);
4013 gcc_assert (is_gimple_reg (ptr
) || is_gimple_min_invariant (ptr
));
4015 tem
= build2 (MEM_REF
, TREE_TYPE (ptype
),
4016 ptr
, build_int_cst (ptype
, offset
));
4017 SET_EXPR_LOCATION (tem
, loc
);
4021 /* Return the constant offset of a MEM_REF or TARGET_MEM_REF tree T. */
4024 mem_ref_offset (const_tree t
)
4026 tree toff
= TREE_OPERAND (t
, 1);
4027 return double_int_sext (tree_to_double_int (toff
),
4028 TYPE_PRECISION (TREE_TYPE (toff
)));
4031 /* Return the pointer-type relevant for TBAA purposes from the
4032 gimple memory reference tree T. This is the type to be used for
4033 the offset operand of MEM_REF or TARGET_MEM_REF replacements of T. */
4036 reference_alias_ptr_type (const_tree t
)
4038 const_tree base
= t
;
4039 while (handled_component_p (base
))
4040 base
= TREE_OPERAND (base
, 0);
4041 if (TREE_CODE (base
) == MEM_REF
)
4042 return TREE_TYPE (TREE_OPERAND (base
, 1));
4043 else if (TREE_CODE (base
) == TARGET_MEM_REF
)
4044 return TREE_TYPE (TMR_OFFSET (base
));
4046 return build_pointer_type (TYPE_MAIN_VARIANT (TREE_TYPE (base
)));
4049 /* Return an invariant ADDR_EXPR of type TYPE taking the address of BASE
4050 offsetted by OFFSET units. */
4053 build_invariant_address (tree type
, tree base
, HOST_WIDE_INT offset
)
4055 tree ref
= fold_build2 (MEM_REF
, TREE_TYPE (type
),
4056 build_fold_addr_expr (base
),
4057 build_int_cst (ptr_type_node
, offset
));
4058 tree addr
= build1 (ADDR_EXPR
, type
, ref
);
4059 recompute_tree_invariant_for_addr_expr (addr
);
4063 /* Similar except don't specify the TREE_TYPE
4064 and leave the TREE_SIDE_EFFECTS as 0.
4065 It is permissible for arguments to be null,
4066 or even garbage if their values do not matter. */
4069 build_nt (enum tree_code code
, ...)
4076 gcc_assert (TREE_CODE_CLASS (code
) != tcc_vl_exp
);
4080 t
= make_node (code
);
4081 length
= TREE_CODE_LENGTH (code
);
4083 for (i
= 0; i
< length
; i
++)
4084 TREE_OPERAND (t
, i
) = va_arg (p
, tree
);
4090 /* Similar to build_nt, but for creating a CALL_EXPR object with a
4094 build_nt_call_vec (tree fn
, VEC(tree
,gc
) *args
)
4099 ret
= build_vl_exp (CALL_EXPR
, VEC_length (tree
, args
) + 3);
4100 CALL_EXPR_FN (ret
) = fn
;
4101 CALL_EXPR_STATIC_CHAIN (ret
) = NULL_TREE
;
4102 FOR_EACH_VEC_ELT (tree
, args
, ix
, t
)
4103 CALL_EXPR_ARG (ret
, ix
) = t
;
4107 /* Create a DECL_... node of code CODE, name NAME and data type TYPE.
4108 We do NOT enter this node in any sort of symbol table.
4110 LOC is the location of the decl.
4112 layout_decl is used to set up the decl's storage layout.
4113 Other slots are initialized to 0 or null pointers. */
4116 build_decl_stat (location_t loc
, enum tree_code code
, tree name
,
4117 tree type MEM_STAT_DECL
)
4121 t
= make_node_stat (code PASS_MEM_STAT
);
4122 DECL_SOURCE_LOCATION (t
) = loc
;
4124 /* if (type == error_mark_node)
4125 type = integer_type_node; */
4126 /* That is not done, deliberately, so that having error_mark_node
4127 as the type can suppress useless errors in the use of this variable. */
4129 DECL_NAME (t
) = name
;
4130 TREE_TYPE (t
) = type
;
4132 if (code
== VAR_DECL
|| code
== PARM_DECL
|| code
== RESULT_DECL
)
4138 /* Builds and returns function declaration with NAME and TYPE. */
4141 build_fn_decl (const char *name
, tree type
)
4143 tree id
= get_identifier (name
);
4144 tree decl
= build_decl (input_location
, FUNCTION_DECL
, id
, type
);
4146 DECL_EXTERNAL (decl
) = 1;
4147 TREE_PUBLIC (decl
) = 1;
4148 DECL_ARTIFICIAL (decl
) = 1;
4149 TREE_NOTHROW (decl
) = 1;
4154 VEC(tree
,gc
) *all_translation_units
;
4156 /* Builds a new translation-unit decl with name NAME, queues it in the
4157 global list of translation-unit decls and returns it. */
4160 build_translation_unit_decl (tree name
)
4162 tree tu
= build_decl (UNKNOWN_LOCATION
, TRANSLATION_UNIT_DECL
,
4164 TRANSLATION_UNIT_LANGUAGE (tu
) = lang_hooks
.name
;
4165 VEC_safe_push (tree
, gc
, all_translation_units
, tu
);
4170 /* BLOCK nodes are used to represent the structure of binding contours
4171 and declarations, once those contours have been exited and their contents
4172 compiled. This information is used for outputting debugging info. */
4175 build_block (tree vars
, tree subblocks
, tree supercontext
, tree chain
)
4177 tree block
= make_node (BLOCK
);
4179 BLOCK_VARS (block
) = vars
;
4180 BLOCK_SUBBLOCKS (block
) = subblocks
;
4181 BLOCK_SUPERCONTEXT (block
) = supercontext
;
4182 BLOCK_CHAIN (block
) = chain
;
4187 /* Like SET_EXPR_LOCATION, but make sure the tree can have a location.
4189 LOC is the location to use in tree T. */
4192 protected_set_expr_location (tree t
, location_t loc
)
4194 if (t
&& CAN_HAVE_LOCATION_P (t
))
4195 SET_EXPR_LOCATION (t
, loc
);
4198 /* Return a declaration like DDECL except that its DECL_ATTRIBUTES
4202 build_decl_attribute_variant (tree ddecl
, tree attribute
)
4204 DECL_ATTRIBUTES (ddecl
) = attribute
;
4208 /* Borrowed from hashtab.c iterative_hash implementation. */
4209 #define mix(a,b,c) \
4211 a -= b; a -= c; a ^= (c>>13); \
4212 b -= c; b -= a; b ^= (a<< 8); \
4213 c -= a; c -= b; c ^= ((b&0xffffffff)>>13); \
4214 a -= b; a -= c; a ^= ((c&0xffffffff)>>12); \
4215 b -= c; b -= a; b = (b ^ (a<<16)) & 0xffffffff; \
4216 c -= a; c -= b; c = (c ^ (b>> 5)) & 0xffffffff; \
4217 a -= b; a -= c; a = (a ^ (c>> 3)) & 0xffffffff; \
4218 b -= c; b -= a; b = (b ^ (a<<10)) & 0xffffffff; \
4219 c -= a; c -= b; c = (c ^ (b>>15)) & 0xffffffff; \
4223 /* Produce good hash value combining VAL and VAL2. */
4225 iterative_hash_hashval_t (hashval_t val
, hashval_t val2
)
4227 /* the golden ratio; an arbitrary value. */
4228 hashval_t a
= 0x9e3779b9;
4234 /* Produce good hash value combining VAL and VAL2. */
4236 iterative_hash_host_wide_int (HOST_WIDE_INT val
, hashval_t val2
)
4238 if (sizeof (HOST_WIDE_INT
) == sizeof (hashval_t
))
4239 return iterative_hash_hashval_t (val
, val2
);
4242 hashval_t a
= (hashval_t
) val
;
4243 /* Avoid warnings about shifting of more than the width of the type on
4244 hosts that won't execute this path. */
4246 hashval_t b
= (hashval_t
) (val
>> (sizeof (hashval_t
) * 8 + zero
));
4248 if (sizeof (HOST_WIDE_INT
) > 2 * sizeof (hashval_t
))
4250 hashval_t a
= (hashval_t
) (val
>> (sizeof (hashval_t
) * 16 + zero
));
4251 hashval_t b
= (hashval_t
) (val
>> (sizeof (hashval_t
) * 24 + zero
));
4258 /* Return a type like TTYPE except that its TYPE_ATTRIBUTE
4259 is ATTRIBUTE and its qualifiers are QUALS.
4261 Record such modified types already made so we don't make duplicates. */
4264 build_type_attribute_qual_variant (tree ttype
, tree attribute
, int quals
)
4266 if (! attribute_list_equal (TYPE_ATTRIBUTES (ttype
), attribute
))
4268 hashval_t hashcode
= 0;
4270 enum tree_code code
= TREE_CODE (ttype
);
4272 /* Building a distinct copy of a tagged type is inappropriate; it
4273 causes breakage in code that expects there to be a one-to-one
4274 relationship between a struct and its fields.
4275 build_duplicate_type is another solution (as used in
4276 handle_transparent_union_attribute), but that doesn't play well
4277 with the stronger C++ type identity model. */
4278 if (TREE_CODE (ttype
) == RECORD_TYPE
4279 || TREE_CODE (ttype
) == UNION_TYPE
4280 || TREE_CODE (ttype
) == QUAL_UNION_TYPE
4281 || TREE_CODE (ttype
) == ENUMERAL_TYPE
)
4283 warning (OPT_Wattributes
,
4284 "ignoring attributes applied to %qT after definition",
4285 TYPE_MAIN_VARIANT (ttype
));
4286 return build_qualified_type (ttype
, quals
);
4289 ttype
= build_qualified_type (ttype
, TYPE_UNQUALIFIED
);
4290 ntype
= build_distinct_type_copy (ttype
);
4292 TYPE_ATTRIBUTES (ntype
) = attribute
;
4294 hashcode
= iterative_hash_object (code
, hashcode
);
4295 if (TREE_TYPE (ntype
))
4296 hashcode
= iterative_hash_object (TYPE_HASH (TREE_TYPE (ntype
)),
4298 hashcode
= attribute_hash_list (attribute
, hashcode
);
4300 switch (TREE_CODE (ntype
))
4303 hashcode
= type_hash_list (TYPE_ARG_TYPES (ntype
), hashcode
);
4306 if (TYPE_DOMAIN (ntype
))
4307 hashcode
= iterative_hash_object (TYPE_HASH (TYPE_DOMAIN (ntype
)),
4311 hashcode
= iterative_hash_object
4312 (TREE_INT_CST_LOW (TYPE_MAX_VALUE (ntype
)), hashcode
);
4313 hashcode
= iterative_hash_object
4314 (TREE_INT_CST_HIGH (TYPE_MAX_VALUE (ntype
)), hashcode
);
4317 case FIXED_POINT_TYPE
:
4319 unsigned int precision
= TYPE_PRECISION (ntype
);
4320 hashcode
= iterative_hash_object (precision
, hashcode
);
4327 ntype
= type_hash_canon (hashcode
, ntype
);
4329 /* If the target-dependent attributes make NTYPE different from
4330 its canonical type, we will need to use structural equality
4331 checks for this type. */
4332 if (TYPE_STRUCTURAL_EQUALITY_P (ttype
)
4333 || !comp_type_attributes (ntype
, ttype
))
4334 SET_TYPE_STRUCTURAL_EQUALITY (ntype
);
4335 else if (TYPE_CANONICAL (ntype
) == ntype
)
4336 TYPE_CANONICAL (ntype
) = TYPE_CANONICAL (ttype
);
4338 ttype
= build_qualified_type (ntype
, quals
);
4340 else if (TYPE_QUALS (ttype
) != quals
)
4341 ttype
= build_qualified_type (ttype
, quals
);
4346 /* Compare two attributes for their value identity. Return true if the
4347 attribute values are known to be equal; otherwise return false.
4351 attribute_value_equal (const_tree attr1
, const_tree attr2
)
4353 if (TREE_VALUE (attr1
) == TREE_VALUE (attr2
))
4356 if (TREE_VALUE (attr1
) != NULL_TREE
4357 && TREE_CODE (TREE_VALUE (attr1
)) == TREE_LIST
4358 && TREE_VALUE (attr2
) != NULL
4359 && TREE_CODE (TREE_VALUE (attr2
)) == TREE_LIST
)
4360 return (simple_cst_list_equal (TREE_VALUE (attr1
),
4361 TREE_VALUE (attr2
)) == 1);
4363 return (simple_cst_equal (TREE_VALUE (attr1
), TREE_VALUE (attr2
)) == 1);
4366 /* Return 0 if the attributes for two types are incompatible, 1 if they
4367 are compatible, and 2 if they are nearly compatible (which causes a
4368 warning to be generated). */
4370 comp_type_attributes (const_tree type1
, const_tree type2
)
4372 const_tree a1
= TYPE_ATTRIBUTES (type1
);
4373 const_tree a2
= TYPE_ATTRIBUTES (type2
);
4378 for (a
= a1
; a
!= NULL_TREE
; a
= TREE_CHAIN (a
))
4380 const struct attribute_spec
*as
;
4383 as
= lookup_attribute_spec (TREE_PURPOSE (a
));
4384 if (!as
|| as
->affects_type_identity
== false)
4387 attr
= lookup_attribute (as
->name
, CONST_CAST_TREE (a2
));
4388 if (!attr
|| !attribute_value_equal (a
, attr
))
4393 for (a
= a2
; a
!= NULL_TREE
; a
= TREE_CHAIN (a
))
4395 const struct attribute_spec
*as
;
4397 as
= lookup_attribute_spec (TREE_PURPOSE (a
));
4398 if (!as
|| as
->affects_type_identity
== false)
4401 if (!lookup_attribute (as
->name
, CONST_CAST_TREE (a1
)))
4403 /* We don't need to compare trees again, as we did this
4404 already in first loop. */
4406 /* All types - affecting identity - are equal, so
4407 there is no need to call target hook for comparison. */
4411 /* As some type combinations - like default calling-convention - might
4412 be compatible, we have to call the target hook to get the final result. */
4413 return targetm
.comp_type_attributes (type1
, type2
);
4416 /* Return a type like TTYPE except that its TYPE_ATTRIBUTE
4419 Record such modified types already made so we don't make duplicates. */
4422 build_type_attribute_variant (tree ttype
, tree attribute
)
4424 return build_type_attribute_qual_variant (ttype
, attribute
,
4425 TYPE_QUALS (ttype
));
4429 /* Reset the expression *EXPR_P, a size or position.
4431 ??? We could reset all non-constant sizes or positions. But it's cheap
4432 enough to not do so and refrain from adding workarounds to dwarf2out.c.
4434 We need to reset self-referential sizes or positions because they cannot
4435 be gimplified and thus can contain a CALL_EXPR after the gimplification
4436 is finished, which will run afoul of LTO streaming. And they need to be
4437 reset to something essentially dummy but not constant, so as to preserve
4438 the properties of the object they are attached to. */
4441 free_lang_data_in_one_sizepos (tree
*expr_p
)
4443 tree expr
= *expr_p
;
4444 if (CONTAINS_PLACEHOLDER_P (expr
))
4445 *expr_p
= build0 (PLACEHOLDER_EXPR
, TREE_TYPE (expr
));
4449 /* Reset all the fields in a binfo node BINFO. We only keep
4450 BINFO_VTABLE, which is used by gimple_fold_obj_type_ref. */
4453 free_lang_data_in_binfo (tree binfo
)
4458 gcc_assert (TREE_CODE (binfo
) == TREE_BINFO
);
4460 BINFO_VIRTUALS (binfo
) = NULL_TREE
;
4461 BINFO_BASE_ACCESSES (binfo
) = NULL
;
4462 BINFO_INHERITANCE_CHAIN (binfo
) = NULL_TREE
;
4463 BINFO_SUBVTT_INDEX (binfo
) = NULL_TREE
;
4465 FOR_EACH_VEC_ELT (tree
, BINFO_BASE_BINFOS (binfo
), i
, t
)
4466 free_lang_data_in_binfo (t
);
4470 /* Reset all language specific information still present in TYPE. */
4473 free_lang_data_in_type (tree type
)
4475 gcc_assert (TYPE_P (type
));
4477 /* Give the FE a chance to remove its own data first. */
4478 lang_hooks
.free_lang_data (type
);
4480 TREE_LANG_FLAG_0 (type
) = 0;
4481 TREE_LANG_FLAG_1 (type
) = 0;
4482 TREE_LANG_FLAG_2 (type
) = 0;
4483 TREE_LANG_FLAG_3 (type
) = 0;
4484 TREE_LANG_FLAG_4 (type
) = 0;
4485 TREE_LANG_FLAG_5 (type
) = 0;
4486 TREE_LANG_FLAG_6 (type
) = 0;
4488 if (TREE_CODE (type
) == FUNCTION_TYPE
)
4490 /* Remove the const and volatile qualifiers from arguments. The
4491 C++ front end removes them, but the C front end does not,
4492 leading to false ODR violation errors when merging two
4493 instances of the same function signature compiled by
4494 different front ends. */
4497 for (p
= TYPE_ARG_TYPES (type
); p
; p
= TREE_CHAIN (p
))
4499 tree arg_type
= TREE_VALUE (p
);
4501 if (TYPE_READONLY (arg_type
) || TYPE_VOLATILE (arg_type
))
4503 int quals
= TYPE_QUALS (arg_type
)
4505 & ~TYPE_QUAL_VOLATILE
;
4506 TREE_VALUE (p
) = build_qualified_type (arg_type
, quals
);
4507 free_lang_data_in_type (TREE_VALUE (p
));
4512 /* Remove members that are not actually FIELD_DECLs from the field
4513 list of an aggregate. These occur in C++. */
4514 if (RECORD_OR_UNION_TYPE_P (type
))
4518 /* Note that TYPE_FIELDS can be shared across distinct
4519 TREE_TYPEs. Therefore, if the first field of TYPE_FIELDS is
4520 to be removed, we cannot set its TREE_CHAIN to NULL.
4521 Otherwise, we would not be able to find all the other fields
4522 in the other instances of this TREE_TYPE.
4524 This was causing an ICE in testsuite/g++.dg/lto/20080915.C. */
4526 member
= TYPE_FIELDS (type
);
4529 if (TREE_CODE (member
) == FIELD_DECL
4530 || TREE_CODE (member
) == TYPE_DECL
)
4533 TREE_CHAIN (prev
) = member
;
4535 TYPE_FIELDS (type
) = member
;
4539 member
= TREE_CHAIN (member
);
4543 TREE_CHAIN (prev
) = NULL_TREE
;
4545 TYPE_FIELDS (type
) = NULL_TREE
;
4547 TYPE_METHODS (type
) = NULL_TREE
;
4548 if (TYPE_BINFO (type
))
4549 free_lang_data_in_binfo (TYPE_BINFO (type
));
4553 /* For non-aggregate types, clear out the language slot (which
4554 overloads TYPE_BINFO). */
4555 TYPE_LANG_SLOT_1 (type
) = NULL_TREE
;
4557 if (INTEGRAL_TYPE_P (type
)
4558 || SCALAR_FLOAT_TYPE_P (type
)
4559 || FIXED_POINT_TYPE_P (type
))
4561 free_lang_data_in_one_sizepos (&TYPE_MIN_VALUE (type
));
4562 free_lang_data_in_one_sizepos (&TYPE_MAX_VALUE (type
));
4566 free_lang_data_in_one_sizepos (&TYPE_SIZE (type
));
4567 free_lang_data_in_one_sizepos (&TYPE_SIZE_UNIT (type
));
4569 if (debug_info_level
< DINFO_LEVEL_TERSE
4570 || (TYPE_CONTEXT (type
)
4571 && TREE_CODE (TYPE_CONTEXT (type
)) != FUNCTION_DECL
4572 && TREE_CODE (TYPE_CONTEXT (type
)) != NAMESPACE_DECL
))
4573 TYPE_CONTEXT (type
) = NULL_TREE
;
4577 /* Return true if DECL may need an assembler name to be set. */
4580 need_assembler_name_p (tree decl
)
4582 /* Only FUNCTION_DECLs and VAR_DECLs are considered. */
4583 if (TREE_CODE (decl
) != FUNCTION_DECL
4584 && TREE_CODE (decl
) != VAR_DECL
)
4587 /* If DECL already has its assembler name set, it does not need a
4589 if (!HAS_DECL_ASSEMBLER_NAME_P (decl
)
4590 || DECL_ASSEMBLER_NAME_SET_P (decl
))
4593 /* Abstract decls do not need an assembler name. */
4594 if (DECL_ABSTRACT (decl
))
4597 /* For VAR_DECLs, only static, public and external symbols need an
4599 if (TREE_CODE (decl
) == VAR_DECL
4600 && !TREE_STATIC (decl
)
4601 && !TREE_PUBLIC (decl
)
4602 && !DECL_EXTERNAL (decl
))
4605 if (TREE_CODE (decl
) == FUNCTION_DECL
)
4607 /* Do not set assembler name on builtins. Allow RTL expansion to
4608 decide whether to expand inline or via a regular call. */
4609 if (DECL_BUILT_IN (decl
)
4610 && DECL_BUILT_IN_CLASS (decl
) != BUILT_IN_FRONTEND
)
4613 /* Functions represented in the callgraph need an assembler name. */
4614 if (cgraph_get_node (decl
) != NULL
)
4617 /* Unused and not public functions don't need an assembler name. */
4618 if (!TREE_USED (decl
) && !TREE_PUBLIC (decl
))
4626 /* Reset all language specific information still present in symbol
4630 free_lang_data_in_decl (tree decl
)
4632 gcc_assert (DECL_P (decl
));
4634 /* Give the FE a chance to remove its own data first. */
4635 lang_hooks
.free_lang_data (decl
);
4637 TREE_LANG_FLAG_0 (decl
) = 0;
4638 TREE_LANG_FLAG_1 (decl
) = 0;
4639 TREE_LANG_FLAG_2 (decl
) = 0;
4640 TREE_LANG_FLAG_3 (decl
) = 0;
4641 TREE_LANG_FLAG_4 (decl
) = 0;
4642 TREE_LANG_FLAG_5 (decl
) = 0;
4643 TREE_LANG_FLAG_6 (decl
) = 0;
4645 free_lang_data_in_one_sizepos (&DECL_SIZE (decl
));
4646 free_lang_data_in_one_sizepos (&DECL_SIZE_UNIT (decl
));
4647 if (TREE_CODE (decl
) == FIELD_DECL
)
4649 free_lang_data_in_one_sizepos (&DECL_FIELD_OFFSET (decl
));
4650 if (TREE_CODE (DECL_CONTEXT (decl
)) == QUAL_UNION_TYPE
)
4651 DECL_QUALIFIER (decl
) = NULL_TREE
;
4654 if (TREE_CODE (decl
) == FUNCTION_DECL
)
4656 if (gimple_has_body_p (decl
))
4660 /* If DECL has a gimple body, then the context for its
4661 arguments must be DECL. Otherwise, it doesn't really
4662 matter, as we will not be emitting any code for DECL. In
4663 general, there may be other instances of DECL created by
4664 the front end and since PARM_DECLs are generally shared,
4665 their DECL_CONTEXT changes as the replicas of DECL are
4666 created. The only time where DECL_CONTEXT is important
4667 is for the FUNCTION_DECLs that have a gimple body (since
4668 the PARM_DECL will be used in the function's body). */
4669 for (t
= DECL_ARGUMENTS (decl
); t
; t
= TREE_CHAIN (t
))
4670 DECL_CONTEXT (t
) = decl
;
4673 /* DECL_SAVED_TREE holds the GENERIC representation for DECL.
4674 At this point, it is not needed anymore. */
4675 DECL_SAVED_TREE (decl
) = NULL_TREE
;
4677 /* Clear the abstract origin if it refers to a method. Otherwise
4678 dwarf2out.c will ICE as we clear TYPE_METHODS and thus the
4679 origin will not be output correctly. */
4680 if (DECL_ABSTRACT_ORIGIN (decl
)
4681 && DECL_CONTEXT (DECL_ABSTRACT_ORIGIN (decl
))
4682 && RECORD_OR_UNION_TYPE_P
4683 (DECL_CONTEXT (DECL_ABSTRACT_ORIGIN (decl
))))
4684 DECL_ABSTRACT_ORIGIN (decl
) = NULL_TREE
;
4686 /* Sometimes the C++ frontend doesn't manage to transform a temporary
4687 DECL_VINDEX referring to itself into a vtable slot number as it
4688 should. Happens with functions that are copied and then forgotten
4689 about. Just clear it, it won't matter anymore. */
4690 if (DECL_VINDEX (decl
) && !host_integerp (DECL_VINDEX (decl
), 0))
4691 DECL_VINDEX (decl
) = NULL_TREE
;
4693 else if (TREE_CODE (decl
) == VAR_DECL
)
4695 if ((DECL_EXTERNAL (decl
)
4696 && (!TREE_STATIC (decl
) || !TREE_READONLY (decl
)))
4697 || (decl_function_context (decl
) && !TREE_STATIC (decl
)))
4698 DECL_INITIAL (decl
) = NULL_TREE
;
4700 else if (TREE_CODE (decl
) == TYPE_DECL
4701 || TREE_CODE (decl
) == FIELD_DECL
)
4702 DECL_INITIAL (decl
) = NULL_TREE
;
4703 else if (TREE_CODE (decl
) == TRANSLATION_UNIT_DECL
4704 && DECL_INITIAL (decl
)
4705 && TREE_CODE (DECL_INITIAL (decl
)) == BLOCK
)
4707 /* Strip builtins from the translation-unit BLOCK. We still have targets
4708 without builtin_decl_explicit support and also builtins are shared
4709 nodes and thus we can't use TREE_CHAIN in multiple lists. */
4710 tree
*nextp
= &BLOCK_VARS (DECL_INITIAL (decl
));
4714 if (TREE_CODE (var
) == FUNCTION_DECL
4715 && DECL_BUILT_IN (var
))
4716 *nextp
= TREE_CHAIN (var
);
4718 nextp
= &TREE_CHAIN (var
);
4724 /* Data used when collecting DECLs and TYPEs for language data removal. */
4726 struct free_lang_data_d
4728 /* Worklist to avoid excessive recursion. */
4729 VEC(tree
,heap
) *worklist
;
4731 /* Set of traversed objects. Used to avoid duplicate visits. */
4732 struct pointer_set_t
*pset
;
4734 /* Array of symbols to process with free_lang_data_in_decl. */
4735 VEC(tree
,heap
) *decls
;
4737 /* Array of types to process with free_lang_data_in_type. */
4738 VEC(tree
,heap
) *types
;
4742 /* Save all language fields needed to generate proper debug information
4743 for DECL. This saves most fields cleared out by free_lang_data_in_decl. */
4746 save_debug_info_for_decl (tree t
)
4748 /*struct saved_debug_info_d *sdi;*/
4750 gcc_assert (debug_info_level
> DINFO_LEVEL_TERSE
&& t
&& DECL_P (t
));
4752 /* FIXME. Partial implementation for saving debug info removed. */
4756 /* Save all language fields needed to generate proper debug information
4757 for TYPE. This saves most fields cleared out by free_lang_data_in_type. */
4760 save_debug_info_for_type (tree t
)
4762 /*struct saved_debug_info_d *sdi;*/
4764 gcc_assert (debug_info_level
> DINFO_LEVEL_TERSE
&& t
&& TYPE_P (t
));
4766 /* FIXME. Partial implementation for saving debug info removed. */
4770 /* Add type or decl T to one of the list of tree nodes that need their
4771 language data removed. The lists are held inside FLD. */
4774 add_tree_to_fld_list (tree t
, struct free_lang_data_d
*fld
)
4778 VEC_safe_push (tree
, heap
, fld
->decls
, t
);
4779 if (debug_info_level
> DINFO_LEVEL_TERSE
)
4780 save_debug_info_for_decl (t
);
4782 else if (TYPE_P (t
))
4784 VEC_safe_push (tree
, heap
, fld
->types
, t
);
4785 if (debug_info_level
> DINFO_LEVEL_TERSE
)
4786 save_debug_info_for_type (t
);
4792 /* Push tree node T into FLD->WORKLIST. */
4795 fld_worklist_push (tree t
, struct free_lang_data_d
*fld
)
4797 if (t
&& !is_lang_specific (t
) && !pointer_set_contains (fld
->pset
, t
))
4798 VEC_safe_push (tree
, heap
, fld
->worklist
, (t
));
4802 /* Operand callback helper for free_lang_data_in_node. *TP is the
4803 subtree operand being considered. */
4806 find_decls_types_r (tree
*tp
, int *ws
, void *data
)
4809 struct free_lang_data_d
*fld
= (struct free_lang_data_d
*) data
;
4811 if (TREE_CODE (t
) == TREE_LIST
)
4814 /* Language specific nodes will be removed, so there is no need
4815 to gather anything under them. */
4816 if (is_lang_specific (t
))
4824 /* Note that walk_tree does not traverse every possible field in
4825 decls, so we have to do our own traversals here. */
4826 add_tree_to_fld_list (t
, fld
);
4828 fld_worklist_push (DECL_NAME (t
), fld
);
4829 fld_worklist_push (DECL_CONTEXT (t
), fld
);
4830 fld_worklist_push (DECL_SIZE (t
), fld
);
4831 fld_worklist_push (DECL_SIZE_UNIT (t
), fld
);
4833 /* We are going to remove everything under DECL_INITIAL for
4834 TYPE_DECLs. No point walking them. */
4835 if (TREE_CODE (t
) != TYPE_DECL
)
4836 fld_worklist_push (DECL_INITIAL (t
), fld
);
4838 fld_worklist_push (DECL_ATTRIBUTES (t
), fld
);
4839 fld_worklist_push (DECL_ABSTRACT_ORIGIN (t
), fld
);
4841 if (TREE_CODE (t
) == FUNCTION_DECL
)
4843 fld_worklist_push (DECL_ARGUMENTS (t
), fld
);
4844 fld_worklist_push (DECL_RESULT (t
), fld
);
4846 else if (TREE_CODE (t
) == TYPE_DECL
)
4848 fld_worklist_push (DECL_ARGUMENT_FLD (t
), fld
);
4849 fld_worklist_push (DECL_VINDEX (t
), fld
);
4850 fld_worklist_push (DECL_ORIGINAL_TYPE (t
), fld
);
4852 else if (TREE_CODE (t
) == FIELD_DECL
)
4854 fld_worklist_push (DECL_FIELD_OFFSET (t
), fld
);
4855 fld_worklist_push (DECL_BIT_FIELD_TYPE (t
), fld
);
4856 fld_worklist_push (DECL_FIELD_BIT_OFFSET (t
), fld
);
4857 fld_worklist_push (DECL_FCONTEXT (t
), fld
);
4859 else if (TREE_CODE (t
) == VAR_DECL
)
4861 fld_worklist_push (DECL_SECTION_NAME (t
), fld
);
4862 fld_worklist_push (DECL_COMDAT_GROUP (t
), fld
);
4865 if ((TREE_CODE (t
) == VAR_DECL
|| TREE_CODE (t
) == PARM_DECL
)
4866 && DECL_HAS_VALUE_EXPR_P (t
))
4867 fld_worklist_push (DECL_VALUE_EXPR (t
), fld
);
4869 if (TREE_CODE (t
) != FIELD_DECL
4870 && TREE_CODE (t
) != TYPE_DECL
)
4871 fld_worklist_push (TREE_CHAIN (t
), fld
);
4874 else if (TYPE_P (t
))
4876 /* Note that walk_tree does not traverse every possible field in
4877 types, so we have to do our own traversals here. */
4878 add_tree_to_fld_list (t
, fld
);
4880 if (!RECORD_OR_UNION_TYPE_P (t
))
4881 fld_worklist_push (TYPE_CACHED_VALUES (t
), fld
);
4882 fld_worklist_push (TYPE_SIZE (t
), fld
);
4883 fld_worklist_push (TYPE_SIZE_UNIT (t
), fld
);
4884 fld_worklist_push (TYPE_ATTRIBUTES (t
), fld
);
4885 fld_worklist_push (TYPE_POINTER_TO (t
), fld
);
4886 fld_worklist_push (TYPE_REFERENCE_TO (t
), fld
);
4887 fld_worklist_push (TYPE_NAME (t
), fld
);
4888 /* Do not walk TYPE_NEXT_PTR_TO or TYPE_NEXT_REF_TO. We do not stream
4889 them and thus do not and want not to reach unused pointer types
4891 if (!POINTER_TYPE_P (t
))
4892 fld_worklist_push (TYPE_MINVAL (t
), fld
);
4893 if (!RECORD_OR_UNION_TYPE_P (t
))
4894 fld_worklist_push (TYPE_MAXVAL (t
), fld
);
4895 fld_worklist_push (TYPE_MAIN_VARIANT (t
), fld
);
4896 /* Do not walk TYPE_NEXT_VARIANT. We do not stream it and thus
4897 do not and want not to reach unused variants this way. */
4898 fld_worklist_push (TYPE_CONTEXT (t
), fld
);
4899 /* Do not walk TYPE_CANONICAL. We do not stream it and thus do not
4900 and want not to reach unused types this way. */
4902 if (RECORD_OR_UNION_TYPE_P (t
) && TYPE_BINFO (t
))
4906 for (i
= 0; VEC_iterate (tree
, BINFO_BASE_BINFOS (TYPE_BINFO (t
)),
4908 fld_worklist_push (TREE_TYPE (tem
), fld
);
4909 tem
= BINFO_VIRTUALS (TYPE_BINFO (t
));
4911 /* The Java FE overloads BINFO_VIRTUALS for its own purpose. */
4912 && TREE_CODE (tem
) == TREE_LIST
)
4915 fld_worklist_push (TREE_VALUE (tem
), fld
);
4916 tem
= TREE_CHAIN (tem
);
4920 if (RECORD_OR_UNION_TYPE_P (t
))
4923 /* Push all TYPE_FIELDS - there can be interleaving interesting
4924 and non-interesting things. */
4925 tem
= TYPE_FIELDS (t
);
4928 if (TREE_CODE (tem
) == FIELD_DECL
4929 || TREE_CODE (tem
) == TYPE_DECL
)
4930 fld_worklist_push (tem
, fld
);
4931 tem
= TREE_CHAIN (tem
);
4935 fld_worklist_push (TYPE_STUB_DECL (t
), fld
);
4938 else if (TREE_CODE (t
) == BLOCK
)
4941 for (tem
= BLOCK_VARS (t
); tem
; tem
= TREE_CHAIN (tem
))
4942 fld_worklist_push (tem
, fld
);
4943 for (tem
= BLOCK_SUBBLOCKS (t
); tem
; tem
= BLOCK_CHAIN (tem
))
4944 fld_worklist_push (tem
, fld
);
4945 fld_worklist_push (BLOCK_ABSTRACT_ORIGIN (t
), fld
);
4948 if (TREE_CODE (t
) != IDENTIFIER_NODE
4949 && CODE_CONTAINS_STRUCT (TREE_CODE (t
), TS_TYPED
))
4950 fld_worklist_push (TREE_TYPE (t
), fld
);
4956 /* Find decls and types in T. */
4959 find_decls_types (tree t
, struct free_lang_data_d
*fld
)
4963 if (!pointer_set_contains (fld
->pset
, t
))
4964 walk_tree (&t
, find_decls_types_r
, fld
, fld
->pset
);
4965 if (VEC_empty (tree
, fld
->worklist
))
4967 t
= VEC_pop (tree
, fld
->worklist
);
4971 /* Translate all the types in LIST with the corresponding runtime
4975 get_eh_types_for_runtime (tree list
)
4979 if (list
== NULL_TREE
)
4982 head
= build_tree_list (0, lookup_type_for_runtime (TREE_VALUE (list
)));
4984 list
= TREE_CHAIN (list
);
4987 tree n
= build_tree_list (0, lookup_type_for_runtime (TREE_VALUE (list
)));
4988 TREE_CHAIN (prev
) = n
;
4989 prev
= TREE_CHAIN (prev
);
4990 list
= TREE_CHAIN (list
);
4997 /* Find decls and types referenced in EH region R and store them in
4998 FLD->DECLS and FLD->TYPES. */
5001 find_decls_types_in_eh_region (eh_region r
, struct free_lang_data_d
*fld
)
5012 /* The types referenced in each catch must first be changed to the
5013 EH types used at runtime. This removes references to FE types
5015 for (c
= r
->u
.eh_try
.first_catch
; c
; c
= c
->next_catch
)
5017 c
->type_list
= get_eh_types_for_runtime (c
->type_list
);
5018 walk_tree (&c
->type_list
, find_decls_types_r
, fld
, fld
->pset
);
5023 case ERT_ALLOWED_EXCEPTIONS
:
5024 r
->u
.allowed
.type_list
5025 = get_eh_types_for_runtime (r
->u
.allowed
.type_list
);
5026 walk_tree (&r
->u
.allowed
.type_list
, find_decls_types_r
, fld
, fld
->pset
);
5029 case ERT_MUST_NOT_THROW
:
5030 walk_tree (&r
->u
.must_not_throw
.failure_decl
,
5031 find_decls_types_r
, fld
, fld
->pset
);
5037 /* Find decls and types referenced in cgraph node N and store them in
5038 FLD->DECLS and FLD->TYPES. Unlike pass_referenced_vars, this will
5039 look for *every* kind of DECL and TYPE node reachable from N,
5040 including those embedded inside types and decls (i.e,, TYPE_DECLs,
5041 NAMESPACE_DECLs, etc). */
5044 find_decls_types_in_node (struct cgraph_node
*n
, struct free_lang_data_d
*fld
)
5047 struct function
*fn
;
5051 find_decls_types (n
->decl
, fld
);
5053 if (!gimple_has_body_p (n
->decl
))
5056 gcc_assert (current_function_decl
== NULL_TREE
&& cfun
== NULL
);
5058 fn
= DECL_STRUCT_FUNCTION (n
->decl
);
5060 /* Traverse locals. */
5061 FOR_EACH_LOCAL_DECL (fn
, ix
, t
)
5062 find_decls_types (t
, fld
);
5064 /* Traverse EH regions in FN. */
5067 FOR_ALL_EH_REGION_FN (r
, fn
)
5068 find_decls_types_in_eh_region (r
, fld
);
5071 /* Traverse every statement in FN. */
5072 FOR_EACH_BB_FN (bb
, fn
)
5074 gimple_stmt_iterator si
;
5077 for (si
= gsi_start_phis (bb
); !gsi_end_p (si
); gsi_next (&si
))
5079 gimple phi
= gsi_stmt (si
);
5081 for (i
= 0; i
< gimple_phi_num_args (phi
); i
++)
5083 tree
*arg_p
= gimple_phi_arg_def_ptr (phi
, i
);
5084 find_decls_types (*arg_p
, fld
);
5088 for (si
= gsi_start_bb (bb
); !gsi_end_p (si
); gsi_next (&si
))
5090 gimple stmt
= gsi_stmt (si
);
5092 if (is_gimple_call (stmt
))
5093 find_decls_types (gimple_call_fntype (stmt
), fld
);
5095 for (i
= 0; i
< gimple_num_ops (stmt
); i
++)
5097 tree arg
= gimple_op (stmt
, i
);
5098 find_decls_types (arg
, fld
);
5105 /* Find decls and types referenced in varpool node N and store them in
5106 FLD->DECLS and FLD->TYPES. Unlike pass_referenced_vars, this will
5107 look for *every* kind of DECL and TYPE node reachable from N,
5108 including those embedded inside types and decls (i.e,, TYPE_DECLs,
5109 NAMESPACE_DECLs, etc). */
5112 find_decls_types_in_var (struct varpool_node
*v
, struct free_lang_data_d
*fld
)
5114 find_decls_types (v
->decl
, fld
);
5117 /* If T needs an assembler name, have one created for it. */
5120 assign_assembler_name_if_neeeded (tree t
)
5122 if (need_assembler_name_p (t
))
5124 /* When setting DECL_ASSEMBLER_NAME, the C++ mangler may emit
5125 diagnostics that use input_location to show locus
5126 information. The problem here is that, at this point,
5127 input_location is generally anchored to the end of the file
5128 (since the parser is long gone), so we don't have a good
5129 position to pin it to.
5131 To alleviate this problem, this uses the location of T's
5132 declaration. Examples of this are
5133 testsuite/g++.dg/template/cond2.C and
5134 testsuite/g++.dg/template/pr35240.C. */
5135 location_t saved_location
= input_location
;
5136 input_location
= DECL_SOURCE_LOCATION (t
);
5138 decl_assembler_name (t
);
5140 input_location
= saved_location
;
5145 /* Free language specific information for every operand and expression
5146 in every node of the call graph. This process operates in three stages:
5148 1- Every callgraph node and varpool node is traversed looking for
5149 decls and types embedded in them. This is a more exhaustive
5150 search than that done by find_referenced_vars, because it will
5151 also collect individual fields, decls embedded in types, etc.
5153 2- All the decls found are sent to free_lang_data_in_decl.
5155 3- All the types found are sent to free_lang_data_in_type.
5157 The ordering between decls and types is important because
5158 free_lang_data_in_decl sets assembler names, which includes
5159 mangling. So types cannot be freed up until assembler names have
5163 free_lang_data_in_cgraph (void)
5165 struct cgraph_node
*n
;
5166 struct varpool_node
*v
;
5167 struct free_lang_data_d fld
;
5172 /* Initialize sets and arrays to store referenced decls and types. */
5173 fld
.pset
= pointer_set_create ();
5174 fld
.worklist
= NULL
;
5175 fld
.decls
= VEC_alloc (tree
, heap
, 100);
5176 fld
.types
= VEC_alloc (tree
, heap
, 100);
5178 /* Find decls and types in the body of every function in the callgraph. */
5179 for (n
= cgraph_nodes
; n
; n
= n
->next
)
5180 find_decls_types_in_node (n
, &fld
);
5182 FOR_EACH_VEC_ELT (alias_pair
, alias_pairs
, i
, p
)
5183 find_decls_types (p
->decl
, &fld
);
5185 /* Find decls and types in every varpool symbol. */
5186 for (v
= varpool_nodes
; v
; v
= v
->next
)
5187 find_decls_types_in_var (v
, &fld
);
5189 /* Set the assembler name on every decl found. We need to do this
5190 now because free_lang_data_in_decl will invalidate data needed
5191 for mangling. This breaks mangling on interdependent decls. */
5192 FOR_EACH_VEC_ELT (tree
, fld
.decls
, i
, t
)
5193 assign_assembler_name_if_neeeded (t
);
5195 /* Traverse every decl found freeing its language data. */
5196 FOR_EACH_VEC_ELT (tree
, fld
.decls
, i
, t
)
5197 free_lang_data_in_decl (t
);
5199 /* Traverse every type found freeing its language data. */
5200 FOR_EACH_VEC_ELT (tree
, fld
.types
, i
, t
)
5201 free_lang_data_in_type (t
);
5203 pointer_set_destroy (fld
.pset
);
5204 VEC_free (tree
, heap
, fld
.worklist
);
5205 VEC_free (tree
, heap
, fld
.decls
);
5206 VEC_free (tree
, heap
, fld
.types
);
5210 /* Free resources that are used by FE but are not needed once they are done. */
5213 free_lang_data (void)
5217 /* If we are the LTO frontend we have freed lang-specific data already. */
5219 || !flag_generate_lto
)
5222 /* Allocate and assign alias sets to the standard integer types
5223 while the slots are still in the way the frontends generated them. */
5224 for (i
= 0; i
< itk_none
; ++i
)
5225 if (integer_types
[i
])
5226 TYPE_ALIAS_SET (integer_types
[i
]) = get_alias_set (integer_types
[i
]);
5228 /* Traverse the IL resetting language specific information for
5229 operands, expressions, etc. */
5230 free_lang_data_in_cgraph ();
5232 /* Create gimple variants for common types. */
5233 ptrdiff_type_node
= integer_type_node
;
5234 fileptr_type_node
= ptr_type_node
;
5236 /* Reset some langhooks. Do not reset types_compatible_p, it may
5237 still be used indirectly via the get_alias_set langhook. */
5238 lang_hooks
.callgraph
.analyze_expr
= NULL
;
5239 lang_hooks
.dwarf_name
= lhd_dwarf_name
;
5240 lang_hooks
.decl_printable_name
= gimple_decl_printable_name
;
5241 /* We do not want the default decl_assembler_name implementation,
5242 rather if we have fixed everything we want a wrapper around it
5243 asserting that all non-local symbols already got their assembler
5244 name and only produce assembler names for local symbols. Or rather
5245 make sure we never call decl_assembler_name on local symbols and
5246 devise a separate, middle-end private scheme for it. */
5248 /* Reset diagnostic machinery. */
5249 diagnostic_starter (global_dc
) = default_tree_diagnostic_starter
;
5250 diagnostic_finalizer (global_dc
) = default_diagnostic_finalizer
;
5251 diagnostic_format_decoder (global_dc
) = default_tree_printer
;
5257 struct simple_ipa_opt_pass pass_ipa_free_lang_data
=
5261 "*free_lang_data", /* name */
5263 free_lang_data
, /* execute */
5266 0, /* static_pass_number */
5267 TV_IPA_FREE_LANG_DATA
, /* tv_id */
5268 0, /* properties_required */
5269 0, /* properties_provided */
5270 0, /* properties_destroyed */
5271 0, /* todo_flags_start */
5272 TODO_ggc_collect
/* todo_flags_finish */
5276 /* The backbone of is_attribute_p(). ATTR_LEN is the string length of
5277 ATTR_NAME. Also used internally by remove_attribute(). */
5279 private_is_attribute_p (const char *attr_name
, size_t attr_len
, const_tree ident
)
5281 size_t ident_len
= IDENTIFIER_LENGTH (ident
);
5283 if (ident_len
== attr_len
)
5285 if (strcmp (attr_name
, IDENTIFIER_POINTER (ident
)) == 0)
5288 else if (ident_len
== attr_len
+ 4)
5290 /* There is the possibility that ATTR is 'text' and IDENT is
5292 const char *p
= IDENTIFIER_POINTER (ident
);
5293 if (p
[0] == '_' && p
[1] == '_'
5294 && p
[ident_len
- 2] == '_' && p
[ident_len
- 1] == '_'
5295 && strncmp (attr_name
, p
+ 2, attr_len
) == 0)
5302 /* The backbone of lookup_attribute(). ATTR_LEN is the string length
5303 of ATTR_NAME, and LIST is not NULL_TREE. */
5305 private_lookup_attribute (const char *attr_name
, size_t attr_len
, tree list
)
5309 size_t ident_len
= IDENTIFIER_LENGTH (TREE_PURPOSE (list
));
5311 if (ident_len
== attr_len
)
5313 if (strcmp (attr_name
, IDENTIFIER_POINTER (TREE_PURPOSE (list
))) == 0)
5316 /* TODO: If we made sure that attributes were stored in the
5317 canonical form without '__...__' (ie, as in 'text' as opposed
5318 to '__text__') then we could avoid the following case. */
5319 else if (ident_len
== attr_len
+ 4)
5321 const char *p
= IDENTIFIER_POINTER (TREE_PURPOSE (list
));
5322 if (p
[0] == '_' && p
[1] == '_'
5323 && p
[ident_len
- 2] == '_' && p
[ident_len
- 1] == '_'
5324 && strncmp (attr_name
, p
+ 2, attr_len
) == 0)
5327 list
= TREE_CHAIN (list
);
5333 /* A variant of lookup_attribute() that can be used with an identifier
5334 as the first argument, and where the identifier can be either
5335 'text' or '__text__'.
5337 Given an attribute ATTR_IDENTIFIER, and a list of attributes LIST,
5338 return a pointer to the attribute's list element if the attribute
5339 is part of the list, or NULL_TREE if not found. If the attribute
5340 appears more than once, this only returns the first occurrence; the
5341 TREE_CHAIN of the return value should be passed back in if further
5342 occurrences are wanted. ATTR_IDENTIFIER must be an identifier but
5343 can be in the form 'text' or '__text__'. */
5345 lookup_ident_attribute (tree attr_identifier
, tree list
)
5347 gcc_checking_assert (TREE_CODE (attr_identifier
) == IDENTIFIER_NODE
);
5351 gcc_checking_assert (TREE_CODE (TREE_PURPOSE (list
)) == IDENTIFIER_NODE
);
5353 /* Identifiers can be compared directly for equality. */
5354 if (attr_identifier
== TREE_PURPOSE (list
))
5357 /* If they are not equal, they may still be one in the form
5358 'text' while the other one is in the form '__text__'. TODO:
5359 If we were storing attributes in normalized 'text' form, then
5360 this could all go away and we could take full advantage of
5361 the fact that we're comparing identifiers. :-) */
5363 size_t attr_len
= IDENTIFIER_LENGTH (attr_identifier
);
5364 size_t ident_len
= IDENTIFIER_LENGTH (TREE_PURPOSE (list
));
5366 if (ident_len
== attr_len
+ 4)
5368 const char *p
= IDENTIFIER_POINTER (TREE_PURPOSE (list
));
5369 const char *q
= IDENTIFIER_POINTER (attr_identifier
);
5370 if (p
[0] == '_' && p
[1] == '_'
5371 && p
[ident_len
- 2] == '_' && p
[ident_len
- 1] == '_'
5372 && strncmp (q
, p
+ 2, attr_len
) == 0)
5375 else if (ident_len
+ 4 == attr_len
)
5377 const char *p
= IDENTIFIER_POINTER (TREE_PURPOSE (list
));
5378 const char *q
= IDENTIFIER_POINTER (attr_identifier
);
5379 if (q
[0] == '_' && q
[1] == '_'
5380 && q
[attr_len
- 2] == '_' && q
[attr_len
- 1] == '_'
5381 && strncmp (q
+ 2, p
, ident_len
) == 0)
5385 list
= TREE_CHAIN (list
);
5391 /* Remove any instances of attribute ATTR_NAME in LIST and return the
5395 remove_attribute (const char *attr_name
, tree list
)
5398 size_t attr_len
= strlen (attr_name
);
5400 gcc_checking_assert (attr_name
[0] != '_');
5402 for (p
= &list
; *p
; )
5405 /* TODO: If we were storing attributes in normalized form, here
5406 we could use a simple strcmp(). */
5407 if (private_is_attribute_p (attr_name
, attr_len
, TREE_PURPOSE (l
)))
5408 *p
= TREE_CHAIN (l
);
5410 p
= &TREE_CHAIN (l
);
5416 /* Return an attribute list that is the union of a1 and a2. */
5419 merge_attributes (tree a1
, tree a2
)
5423 /* Either one unset? Take the set one. */
5425 if ((attributes
= a1
) == 0)
5428 /* One that completely contains the other? Take it. */
5430 else if (a2
!= 0 && ! attribute_list_contained (a1
, a2
))
5432 if (attribute_list_contained (a2
, a1
))
5436 /* Pick the longest list, and hang on the other list. */
5438 if (list_length (a1
) < list_length (a2
))
5439 attributes
= a2
, a2
= a1
;
5441 for (; a2
!= 0; a2
= TREE_CHAIN (a2
))
5444 for (a
= lookup_ident_attribute (TREE_PURPOSE (a2
), attributes
);
5445 a
!= NULL_TREE
&& !attribute_value_equal (a
, a2
);
5446 a
= lookup_ident_attribute (TREE_PURPOSE (a2
), TREE_CHAIN (a
)))
5450 a1
= copy_node (a2
);
5451 TREE_CHAIN (a1
) = attributes
;
5460 /* Given types T1 and T2, merge their attributes and return
5464 merge_type_attributes (tree t1
, tree t2
)
5466 return merge_attributes (TYPE_ATTRIBUTES (t1
),
5467 TYPE_ATTRIBUTES (t2
));
5470 /* Given decls OLDDECL and NEWDECL, merge their attributes and return
5474 merge_decl_attributes (tree olddecl
, tree newdecl
)
5476 return merge_attributes (DECL_ATTRIBUTES (olddecl
),
5477 DECL_ATTRIBUTES (newdecl
));
5480 #if TARGET_DLLIMPORT_DECL_ATTRIBUTES
5482 /* Specialization of merge_decl_attributes for various Windows targets.
5484 This handles the following situation:
5486 __declspec (dllimport) int foo;
5489 The second instance of `foo' nullifies the dllimport. */
5492 merge_dllimport_decl_attributes (tree old
, tree new_tree
)
5495 int delete_dllimport_p
= 1;
5497 /* What we need to do here is remove from `old' dllimport if it doesn't
5498 appear in `new'. dllimport behaves like extern: if a declaration is
5499 marked dllimport and a definition appears later, then the object
5500 is not dllimport'd. We also remove a `new' dllimport if the old list
5501 contains dllexport: dllexport always overrides dllimport, regardless
5502 of the order of declaration. */
5503 if (!VAR_OR_FUNCTION_DECL_P (new_tree
))
5504 delete_dllimport_p
= 0;
5505 else if (DECL_DLLIMPORT_P (new_tree
)
5506 && lookup_attribute ("dllexport", DECL_ATTRIBUTES (old
)))
5508 DECL_DLLIMPORT_P (new_tree
) = 0;
5509 warning (OPT_Wattributes
, "%q+D already declared with dllexport attribute: "
5510 "dllimport ignored", new_tree
);
5512 else if (DECL_DLLIMPORT_P (old
) && !DECL_DLLIMPORT_P (new_tree
))
5514 /* Warn about overriding a symbol that has already been used, e.g.:
5515 extern int __attribute__ ((dllimport)) foo;
5516 int* bar () {return &foo;}
5519 if (TREE_USED (old
))
5521 warning (0, "%q+D redeclared without dllimport attribute "
5522 "after being referenced with dll linkage", new_tree
);
5523 /* If we have used a variable's address with dllimport linkage,
5524 keep the old DECL_DLLIMPORT_P flag: the ADDR_EXPR using the
5525 decl may already have had TREE_CONSTANT computed.
5526 We still remove the attribute so that assembler code refers
5527 to '&foo rather than '_imp__foo'. */
5528 if (TREE_CODE (old
) == VAR_DECL
&& TREE_ADDRESSABLE (old
))
5529 DECL_DLLIMPORT_P (new_tree
) = 1;
5532 /* Let an inline definition silently override the external reference,
5533 but otherwise warn about attribute inconsistency. */
5534 else if (TREE_CODE (new_tree
) == VAR_DECL
5535 || !DECL_DECLARED_INLINE_P (new_tree
))
5536 warning (OPT_Wattributes
, "%q+D redeclared without dllimport attribute: "
5537 "previous dllimport ignored", new_tree
);
5540 delete_dllimport_p
= 0;
5542 a
= merge_attributes (DECL_ATTRIBUTES (old
), DECL_ATTRIBUTES (new_tree
));
5544 if (delete_dllimport_p
)
5545 a
= remove_attribute ("dllimport", a
);
5550 /* Handle a "dllimport" or "dllexport" attribute; arguments as in
5551 struct attribute_spec.handler. */
5554 handle_dll_attribute (tree
* pnode
, tree name
, tree args
, int flags
,
5560 /* These attributes may apply to structure and union types being created,
5561 but otherwise should pass to the declaration involved. */
5564 if (flags
& ((int) ATTR_FLAG_DECL_NEXT
| (int) ATTR_FLAG_FUNCTION_NEXT
5565 | (int) ATTR_FLAG_ARRAY_NEXT
))
5567 *no_add_attrs
= true;
5568 return tree_cons (name
, args
, NULL_TREE
);
5570 if (TREE_CODE (node
) == RECORD_TYPE
5571 || TREE_CODE (node
) == UNION_TYPE
)
5573 node
= TYPE_NAME (node
);
5579 warning (OPT_Wattributes
, "%qE attribute ignored",
5581 *no_add_attrs
= true;
5586 if (TREE_CODE (node
) != FUNCTION_DECL
5587 && TREE_CODE (node
) != VAR_DECL
5588 && TREE_CODE (node
) != TYPE_DECL
)
5590 *no_add_attrs
= true;
5591 warning (OPT_Wattributes
, "%qE attribute ignored",
5596 if (TREE_CODE (node
) == TYPE_DECL
5597 && TREE_CODE (TREE_TYPE (node
)) != RECORD_TYPE
5598 && TREE_CODE (TREE_TYPE (node
)) != UNION_TYPE
)
5600 *no_add_attrs
= true;
5601 warning (OPT_Wattributes
, "%qE attribute ignored",
5606 is_dllimport
= is_attribute_p ("dllimport", name
);
5608 /* Report error on dllimport ambiguities seen now before they cause
5612 /* Honor any target-specific overrides. */
5613 if (!targetm
.valid_dllimport_attribute_p (node
))
5614 *no_add_attrs
= true;
5616 else if (TREE_CODE (node
) == FUNCTION_DECL
5617 && DECL_DECLARED_INLINE_P (node
))
5619 warning (OPT_Wattributes
, "inline function %q+D declared as "
5620 " dllimport: attribute ignored", node
);
5621 *no_add_attrs
= true;
5623 /* Like MS, treat definition of dllimported variables and
5624 non-inlined functions on declaration as syntax errors. */
5625 else if (TREE_CODE (node
) == FUNCTION_DECL
&& DECL_INITIAL (node
))
5627 error ("function %q+D definition is marked dllimport", node
);
5628 *no_add_attrs
= true;
5631 else if (TREE_CODE (node
) == VAR_DECL
)
5633 if (DECL_INITIAL (node
))
5635 error ("variable %q+D definition is marked dllimport",
5637 *no_add_attrs
= true;
5640 /* `extern' needn't be specified with dllimport.
5641 Specify `extern' now and hope for the best. Sigh. */
5642 DECL_EXTERNAL (node
) = 1;
5643 /* Also, implicitly give dllimport'd variables declared within
5644 a function global scope, unless declared static. */
5645 if (current_function_decl
!= NULL_TREE
&& !TREE_STATIC (node
))
5646 TREE_PUBLIC (node
) = 1;
5649 if (*no_add_attrs
== false)
5650 DECL_DLLIMPORT_P (node
) = 1;
5652 else if (TREE_CODE (node
) == FUNCTION_DECL
5653 && DECL_DECLARED_INLINE_P (node
)
5654 && flag_keep_inline_dllexport
)
5655 /* An exported function, even if inline, must be emitted. */
5656 DECL_EXTERNAL (node
) = 0;
5658 /* Report error if symbol is not accessible at global scope. */
5659 if (!TREE_PUBLIC (node
)
5660 && (TREE_CODE (node
) == VAR_DECL
5661 || TREE_CODE (node
) == FUNCTION_DECL
))
5663 error ("external linkage required for symbol %q+D because of "
5664 "%qE attribute", node
, name
);
5665 *no_add_attrs
= true;
5668 /* A dllexport'd entity must have default visibility so that other
5669 program units (shared libraries or the main executable) can see
5670 it. A dllimport'd entity must have default visibility so that
5671 the linker knows that undefined references within this program
5672 unit can be resolved by the dynamic linker. */
5675 if (DECL_VISIBILITY_SPECIFIED (node
)
5676 && DECL_VISIBILITY (node
) != VISIBILITY_DEFAULT
)
5677 error ("%qE implies default visibility, but %qD has already "
5678 "been declared with a different visibility",
5680 DECL_VISIBILITY (node
) = VISIBILITY_DEFAULT
;
5681 DECL_VISIBILITY_SPECIFIED (node
) = 1;
5687 #endif /* TARGET_DLLIMPORT_DECL_ATTRIBUTES */
5689 /* Set the type qualifiers for TYPE to TYPE_QUALS, which is a bitmask
5690 of the various TYPE_QUAL values. */
5693 set_type_quals (tree type
, int type_quals
)
5695 TYPE_READONLY (type
) = (type_quals
& TYPE_QUAL_CONST
) != 0;
5696 TYPE_VOLATILE (type
) = (type_quals
& TYPE_QUAL_VOLATILE
) != 0;
5697 TYPE_RESTRICT (type
) = (type_quals
& TYPE_QUAL_RESTRICT
) != 0;
5698 TYPE_ADDR_SPACE (type
) = DECODE_QUAL_ADDR_SPACE (type_quals
);
5701 /* Returns true iff CAND is equivalent to BASE with TYPE_QUALS. */
5704 check_qualified_type (const_tree cand
, const_tree base
, int type_quals
)
5706 return (TYPE_QUALS (cand
) == type_quals
5707 && TYPE_NAME (cand
) == TYPE_NAME (base
)
5708 /* Apparently this is needed for Objective-C. */
5709 && TYPE_CONTEXT (cand
) == TYPE_CONTEXT (base
)
5710 /* Check alignment. */
5711 && TYPE_ALIGN (cand
) == TYPE_ALIGN (base
)
5712 && attribute_list_equal (TYPE_ATTRIBUTES (cand
),
5713 TYPE_ATTRIBUTES (base
)));
5716 /* Returns true iff CAND is equivalent to BASE with ALIGN. */
5719 check_aligned_type (const_tree cand
, const_tree base
, unsigned int align
)
5721 return (TYPE_QUALS (cand
) == TYPE_QUALS (base
)
5722 && TYPE_NAME (cand
) == TYPE_NAME (base
)
5723 /* Apparently this is needed for Objective-C. */
5724 && TYPE_CONTEXT (cand
) == TYPE_CONTEXT (base
)
5725 /* Check alignment. */
5726 && TYPE_ALIGN (cand
) == align
5727 && attribute_list_equal (TYPE_ATTRIBUTES (cand
),
5728 TYPE_ATTRIBUTES (base
)));
5731 /* Return a version of the TYPE, qualified as indicated by the
5732 TYPE_QUALS, if one exists. If no qualified version exists yet,
5733 return NULL_TREE. */
5736 get_qualified_type (tree type
, int type_quals
)
5740 if (TYPE_QUALS (type
) == type_quals
)
5743 /* Search the chain of variants to see if there is already one there just
5744 like the one we need to have. If so, use that existing one. We must
5745 preserve the TYPE_NAME, since there is code that depends on this. */
5746 for (t
= TYPE_MAIN_VARIANT (type
); t
; t
= TYPE_NEXT_VARIANT (t
))
5747 if (check_qualified_type (t
, type
, type_quals
))
5753 /* Like get_qualified_type, but creates the type if it does not
5754 exist. This function never returns NULL_TREE. */
5757 build_qualified_type (tree type
, int type_quals
)
5761 /* See if we already have the appropriate qualified variant. */
5762 t
= get_qualified_type (type
, type_quals
);
5764 /* If not, build it. */
5767 t
= build_variant_type_copy (type
);
5768 set_type_quals (t
, type_quals
);
5770 if (TYPE_STRUCTURAL_EQUALITY_P (type
))
5771 /* Propagate structural equality. */
5772 SET_TYPE_STRUCTURAL_EQUALITY (t
);
5773 else if (TYPE_CANONICAL (type
) != type
)
5774 /* Build the underlying canonical type, since it is different
5776 TYPE_CANONICAL (t
) = build_qualified_type (TYPE_CANONICAL (type
),
5779 /* T is its own canonical type. */
5780 TYPE_CANONICAL (t
) = t
;
5787 /* Create a variant of type T with alignment ALIGN. */
5790 build_aligned_type (tree type
, unsigned int align
)
5794 if (TYPE_PACKED (type
)
5795 || TYPE_ALIGN (type
) == align
)
5798 for (t
= TYPE_MAIN_VARIANT (type
); t
; t
= TYPE_NEXT_VARIANT (t
))
5799 if (check_aligned_type (t
, type
, align
))
5802 t
= build_variant_type_copy (type
);
5803 TYPE_ALIGN (t
) = align
;
5808 /* Create a new distinct copy of TYPE. The new type is made its own
5809 MAIN_VARIANT. If TYPE requires structural equality checks, the
5810 resulting type requires structural equality checks; otherwise, its
5811 TYPE_CANONICAL points to itself. */
5814 build_distinct_type_copy (tree type
)
5816 tree t
= copy_node (type
);
5818 TYPE_POINTER_TO (t
) = 0;
5819 TYPE_REFERENCE_TO (t
) = 0;
5821 /* Set the canonical type either to a new equivalence class, or
5822 propagate the need for structural equality checks. */
5823 if (TYPE_STRUCTURAL_EQUALITY_P (type
))
5824 SET_TYPE_STRUCTURAL_EQUALITY (t
);
5826 TYPE_CANONICAL (t
) = t
;
5828 /* Make it its own variant. */
5829 TYPE_MAIN_VARIANT (t
) = t
;
5830 TYPE_NEXT_VARIANT (t
) = 0;
5832 /* Note that it is now possible for TYPE_MIN_VALUE to be a value
5833 whose TREE_TYPE is not t. This can also happen in the Ada
5834 frontend when using subtypes. */
5839 /* Create a new variant of TYPE, equivalent but distinct. This is so
5840 the caller can modify it. TYPE_CANONICAL for the return type will
5841 be equivalent to TYPE_CANONICAL of TYPE, indicating that the types
5842 are considered equal by the language itself (or that both types
5843 require structural equality checks). */
5846 build_variant_type_copy (tree type
)
5848 tree t
, m
= TYPE_MAIN_VARIANT (type
);
5850 t
= build_distinct_type_copy (type
);
5852 /* Since we're building a variant, assume that it is a non-semantic
5853 variant. This also propagates TYPE_STRUCTURAL_EQUALITY_P. */
5854 TYPE_CANONICAL (t
) = TYPE_CANONICAL (type
);
5856 /* Add the new type to the chain of variants of TYPE. */
5857 TYPE_NEXT_VARIANT (t
) = TYPE_NEXT_VARIANT (m
);
5858 TYPE_NEXT_VARIANT (m
) = t
;
5859 TYPE_MAIN_VARIANT (t
) = m
;
5864 /* Return true if the from tree in both tree maps are equal. */
5867 tree_map_base_eq (const void *va
, const void *vb
)
5869 const struct tree_map_base
*const a
= (const struct tree_map_base
*) va
,
5870 *const b
= (const struct tree_map_base
*) vb
;
5871 return (a
->from
== b
->from
);
5874 /* Hash a from tree in a tree_base_map. */
5877 tree_map_base_hash (const void *item
)
5879 return htab_hash_pointer (((const struct tree_map_base
*)item
)->from
);
5882 /* Return true if this tree map structure is marked for garbage collection
5883 purposes. We simply return true if the from tree is marked, so that this
5884 structure goes away when the from tree goes away. */
5887 tree_map_base_marked_p (const void *p
)
5889 return ggc_marked_p (((const struct tree_map_base
*) p
)->from
);
5892 /* Hash a from tree in a tree_map. */
5895 tree_map_hash (const void *item
)
5897 return (((const struct tree_map
*) item
)->hash
);
5900 /* Hash a from tree in a tree_decl_map. */
5903 tree_decl_map_hash (const void *item
)
5905 return DECL_UID (((const struct tree_decl_map
*) item
)->base
.from
);
5908 /* Return the initialization priority for DECL. */
5911 decl_init_priority_lookup (tree decl
)
5913 struct tree_priority_map
*h
;
5914 struct tree_map_base in
;
5916 gcc_assert (VAR_OR_FUNCTION_DECL_P (decl
));
5918 h
= (struct tree_priority_map
*) htab_find (init_priority_for_decl
, &in
);
5919 return h
? h
->init
: DEFAULT_INIT_PRIORITY
;
5922 /* Return the finalization priority for DECL. */
5925 decl_fini_priority_lookup (tree decl
)
5927 struct tree_priority_map
*h
;
5928 struct tree_map_base in
;
5930 gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
);
5932 h
= (struct tree_priority_map
*) htab_find (init_priority_for_decl
, &in
);
5933 return h
? h
->fini
: DEFAULT_INIT_PRIORITY
;
5936 /* Return the initialization and finalization priority information for
5937 DECL. If there is no previous priority information, a freshly
5938 allocated structure is returned. */
5940 static struct tree_priority_map
*
5941 decl_priority_info (tree decl
)
5943 struct tree_priority_map in
;
5944 struct tree_priority_map
*h
;
5947 in
.base
.from
= decl
;
5948 loc
= htab_find_slot (init_priority_for_decl
, &in
, INSERT
);
5949 h
= (struct tree_priority_map
*) *loc
;
5952 h
= ggc_alloc_cleared_tree_priority_map ();
5954 h
->base
.from
= decl
;
5955 h
->init
= DEFAULT_INIT_PRIORITY
;
5956 h
->fini
= DEFAULT_INIT_PRIORITY
;
5962 /* Set the initialization priority for DECL to PRIORITY. */
5965 decl_init_priority_insert (tree decl
, priority_type priority
)
5967 struct tree_priority_map
*h
;
5969 gcc_assert (VAR_OR_FUNCTION_DECL_P (decl
));
5970 if (priority
== DEFAULT_INIT_PRIORITY
)
5972 h
= decl_priority_info (decl
);
5976 /* Set the finalization priority for DECL to PRIORITY. */
5979 decl_fini_priority_insert (tree decl
, priority_type priority
)
5981 struct tree_priority_map
*h
;
5983 gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
);
5984 if (priority
== DEFAULT_INIT_PRIORITY
)
5986 h
= decl_priority_info (decl
);
5990 /* Print out the statistics for the DECL_DEBUG_EXPR hash table. */
5993 print_debug_expr_statistics (void)
5995 fprintf (stderr
, "DECL_DEBUG_EXPR hash: size %ld, %ld elements, %f collisions\n",
5996 (long) htab_size (debug_expr_for_decl
),
5997 (long) htab_elements (debug_expr_for_decl
),
5998 htab_collisions (debug_expr_for_decl
));
6001 /* Print out the statistics for the DECL_VALUE_EXPR hash table. */
6004 print_value_expr_statistics (void)
6006 fprintf (stderr
, "DECL_VALUE_EXPR hash: size %ld, %ld elements, %f collisions\n",
6007 (long) htab_size (value_expr_for_decl
),
6008 (long) htab_elements (value_expr_for_decl
),
6009 htab_collisions (value_expr_for_decl
));
6012 /* Lookup a debug expression for FROM, and return it if we find one. */
6015 decl_debug_expr_lookup (tree from
)
6017 struct tree_decl_map
*h
, in
;
6018 in
.base
.from
= from
;
6020 h
= (struct tree_decl_map
*)
6021 htab_find_with_hash (debug_expr_for_decl
, &in
, DECL_UID (from
));
6027 /* Insert a mapping FROM->TO in the debug expression hashtable. */
6030 decl_debug_expr_insert (tree from
, tree to
)
6032 struct tree_decl_map
*h
;
6035 h
= ggc_alloc_tree_decl_map ();
6036 h
->base
.from
= from
;
6038 loc
= htab_find_slot_with_hash (debug_expr_for_decl
, h
, DECL_UID (from
),
6040 *(struct tree_decl_map
**) loc
= h
;
6043 /* Lookup a value expression for FROM, and return it if we find one. */
6046 decl_value_expr_lookup (tree from
)
6048 struct tree_decl_map
*h
, in
;
6049 in
.base
.from
= from
;
6051 h
= (struct tree_decl_map
*)
6052 htab_find_with_hash (value_expr_for_decl
, &in
, DECL_UID (from
));
6058 /* Insert a mapping FROM->TO in the value expression hashtable. */
6061 decl_value_expr_insert (tree from
, tree to
)
6063 struct tree_decl_map
*h
;
6066 h
= ggc_alloc_tree_decl_map ();
6067 h
->base
.from
= from
;
6069 loc
= htab_find_slot_with_hash (value_expr_for_decl
, h
, DECL_UID (from
),
6071 *(struct tree_decl_map
**) loc
= h
;
6074 /* Lookup a vector of debug arguments for FROM, and return it if we
6078 decl_debug_args_lookup (tree from
)
6080 struct tree_vec_map
*h
, in
;
6082 if (!DECL_HAS_DEBUG_ARGS_P (from
))
6084 gcc_checking_assert (debug_args_for_decl
!= NULL
);
6085 in
.base
.from
= from
;
6086 h
= (struct tree_vec_map
*)
6087 htab_find_with_hash (debug_args_for_decl
, &in
, DECL_UID (from
));
6093 /* Insert a mapping FROM->empty vector of debug arguments in the value
6094 expression hashtable. */
6097 decl_debug_args_insert (tree from
)
6099 struct tree_vec_map
*h
;
6102 if (DECL_HAS_DEBUG_ARGS_P (from
))
6103 return decl_debug_args_lookup (from
);
6104 if (debug_args_for_decl
== NULL
)
6105 debug_args_for_decl
= htab_create_ggc (64, tree_vec_map_hash
,
6106 tree_vec_map_eq
, 0);
6107 h
= ggc_alloc_tree_vec_map ();
6108 h
->base
.from
= from
;
6110 loc
= htab_find_slot_with_hash (debug_args_for_decl
, h
, DECL_UID (from
),
6112 *(struct tree_vec_map
**) loc
= h
;
6113 DECL_HAS_DEBUG_ARGS_P (from
) = 1;
6117 /* Hashing of types so that we don't make duplicates.
6118 The entry point is `type_hash_canon'. */
6120 /* Compute a hash code for a list of types (chain of TREE_LIST nodes
6121 with types in the TREE_VALUE slots), by adding the hash codes
6122 of the individual types. */
6125 type_hash_list (const_tree list
, hashval_t hashcode
)
6129 for (tail
= list
; tail
; tail
= TREE_CHAIN (tail
))
6130 if (TREE_VALUE (tail
) != error_mark_node
)
6131 hashcode
= iterative_hash_object (TYPE_HASH (TREE_VALUE (tail
)),
6137 /* These are the Hashtable callback functions. */
6139 /* Returns true iff the types are equivalent. */
6142 type_hash_eq (const void *va
, const void *vb
)
6144 const struct type_hash
*const a
= (const struct type_hash
*) va
,
6145 *const b
= (const struct type_hash
*) vb
;
6147 /* First test the things that are the same for all types. */
6148 if (a
->hash
!= b
->hash
6149 || TREE_CODE (a
->type
) != TREE_CODE (b
->type
)
6150 || TREE_TYPE (a
->type
) != TREE_TYPE (b
->type
)
6151 || !attribute_list_equal (TYPE_ATTRIBUTES (a
->type
),
6152 TYPE_ATTRIBUTES (b
->type
))
6153 || (TREE_CODE (a
->type
) != COMPLEX_TYPE
6154 && TYPE_NAME (a
->type
) != TYPE_NAME (b
->type
)))
6157 /* Be careful about comparing arrays before and after the element type
6158 has been completed; don't compare TYPE_ALIGN unless both types are
6160 if (COMPLETE_TYPE_P (a
->type
) && COMPLETE_TYPE_P (b
->type
)
6161 && (TYPE_ALIGN (a
->type
) != TYPE_ALIGN (b
->type
)
6162 || TYPE_MODE (a
->type
) != TYPE_MODE (b
->type
)))
6165 switch (TREE_CODE (a
->type
))
6170 case REFERENCE_TYPE
:
6174 return TYPE_VECTOR_SUBPARTS (a
->type
) == TYPE_VECTOR_SUBPARTS (b
->type
);
6177 if (TYPE_VALUES (a
->type
) != TYPE_VALUES (b
->type
)
6178 && !(TYPE_VALUES (a
->type
)
6179 && TREE_CODE (TYPE_VALUES (a
->type
)) == TREE_LIST
6180 && TYPE_VALUES (b
->type
)
6181 && TREE_CODE (TYPE_VALUES (b
->type
)) == TREE_LIST
6182 && type_list_equal (TYPE_VALUES (a
->type
),
6183 TYPE_VALUES (b
->type
))))
6186 /* ... fall through ... */
6191 return ((TYPE_MAX_VALUE (a
->type
) == TYPE_MAX_VALUE (b
->type
)
6192 || tree_int_cst_equal (TYPE_MAX_VALUE (a
->type
),
6193 TYPE_MAX_VALUE (b
->type
)))
6194 && (TYPE_MIN_VALUE (a
->type
) == TYPE_MIN_VALUE (b
->type
)
6195 || tree_int_cst_equal (TYPE_MIN_VALUE (a
->type
),
6196 TYPE_MIN_VALUE (b
->type
))));
6198 case FIXED_POINT_TYPE
:
6199 return TYPE_SATURATING (a
->type
) == TYPE_SATURATING (b
->type
);
6202 return TYPE_OFFSET_BASETYPE (a
->type
) == TYPE_OFFSET_BASETYPE (b
->type
);
6205 if (TYPE_METHOD_BASETYPE (a
->type
) == TYPE_METHOD_BASETYPE (b
->type
)
6206 && (TYPE_ARG_TYPES (a
->type
) == TYPE_ARG_TYPES (b
->type
)
6207 || (TYPE_ARG_TYPES (a
->type
)
6208 && TREE_CODE (TYPE_ARG_TYPES (a
->type
)) == TREE_LIST
6209 && TYPE_ARG_TYPES (b
->type
)
6210 && TREE_CODE (TYPE_ARG_TYPES (b
->type
)) == TREE_LIST
6211 && type_list_equal (TYPE_ARG_TYPES (a
->type
),
6212 TYPE_ARG_TYPES (b
->type
)))))
6216 return TYPE_DOMAIN (a
->type
) == TYPE_DOMAIN (b
->type
);
6220 case QUAL_UNION_TYPE
:
6221 return (TYPE_FIELDS (a
->type
) == TYPE_FIELDS (b
->type
)
6222 || (TYPE_FIELDS (a
->type
)
6223 && TREE_CODE (TYPE_FIELDS (a
->type
)) == TREE_LIST
6224 && TYPE_FIELDS (b
->type
)
6225 && TREE_CODE (TYPE_FIELDS (b
->type
)) == TREE_LIST
6226 && type_list_equal (TYPE_FIELDS (a
->type
),
6227 TYPE_FIELDS (b
->type
))));
6230 if (TYPE_ARG_TYPES (a
->type
) == TYPE_ARG_TYPES (b
->type
)
6231 || (TYPE_ARG_TYPES (a
->type
)
6232 && TREE_CODE (TYPE_ARG_TYPES (a
->type
)) == TREE_LIST
6233 && TYPE_ARG_TYPES (b
->type
)
6234 && TREE_CODE (TYPE_ARG_TYPES (b
->type
)) == TREE_LIST
6235 && type_list_equal (TYPE_ARG_TYPES (a
->type
),
6236 TYPE_ARG_TYPES (b
->type
))))
6244 if (lang_hooks
.types
.type_hash_eq
!= NULL
)
6245 return lang_hooks
.types
.type_hash_eq (a
->type
, b
->type
);
6250 /* Return the cached hash value. */
6253 type_hash_hash (const void *item
)
6255 return ((const struct type_hash
*) item
)->hash
;
6258 /* Look in the type hash table for a type isomorphic to TYPE.
6259 If one is found, return it. Otherwise return 0. */
6262 type_hash_lookup (hashval_t hashcode
, tree type
)
6264 struct type_hash
*h
, in
;
6266 /* The TYPE_ALIGN field of a type is set by layout_type(), so we
6267 must call that routine before comparing TYPE_ALIGNs. */
6273 h
= (struct type_hash
*) htab_find_with_hash (type_hash_table
, &in
,
6280 /* Add an entry to the type-hash-table
6281 for a type TYPE whose hash code is HASHCODE. */
6284 type_hash_add (hashval_t hashcode
, tree type
)
6286 struct type_hash
*h
;
6289 h
= ggc_alloc_type_hash ();
6292 loc
= htab_find_slot_with_hash (type_hash_table
, h
, hashcode
, INSERT
);
6296 /* Given TYPE, and HASHCODE its hash code, return the canonical
6297 object for an identical type if one already exists.
6298 Otherwise, return TYPE, and record it as the canonical object.
6300 To use this function, first create a type of the sort you want.
6301 Then compute its hash code from the fields of the type that
6302 make it different from other similar types.
6303 Then call this function and use the value. */
6306 type_hash_canon (unsigned int hashcode
, tree type
)
6310 /* The hash table only contains main variants, so ensure that's what we're
6312 gcc_assert (TYPE_MAIN_VARIANT (type
) == type
);
6314 /* See if the type is in the hash table already. If so, return it.
6315 Otherwise, add the type. */
6316 t1
= type_hash_lookup (hashcode
, type
);
6319 #ifdef GATHER_STATISTICS
6320 tree_code_counts
[(int) TREE_CODE (type
)]--;
6321 tree_node_counts
[(int) t_kind
]--;
6322 tree_node_sizes
[(int) t_kind
] -= sizeof (struct tree_type_non_common
);
6328 type_hash_add (hashcode
, type
);
6333 /* See if the data pointed to by the type hash table is marked. We consider
6334 it marked if the type is marked or if a debug type number or symbol
6335 table entry has been made for the type. */
6338 type_hash_marked_p (const void *p
)
6340 const_tree
const type
= ((const struct type_hash
*) p
)->type
;
6342 return ggc_marked_p (type
);
6346 print_type_hash_statistics (void)
6348 fprintf (stderr
, "Type hash: size %ld, %ld elements, %f collisions\n",
6349 (long) htab_size (type_hash_table
),
6350 (long) htab_elements (type_hash_table
),
6351 htab_collisions (type_hash_table
));
6354 /* Compute a hash code for a list of attributes (chain of TREE_LIST nodes
6355 with names in the TREE_PURPOSE slots and args in the TREE_VALUE slots),
6356 by adding the hash codes of the individual attributes. */
6359 attribute_hash_list (const_tree list
, hashval_t hashcode
)
6363 for (tail
= list
; tail
; tail
= TREE_CHAIN (tail
))
6364 /* ??? Do we want to add in TREE_VALUE too? */
6365 hashcode
= iterative_hash_object
6366 (IDENTIFIER_HASH_VALUE (TREE_PURPOSE (tail
)), hashcode
);
6370 /* Given two lists of attributes, return true if list l2 is
6371 equivalent to l1. */
6374 attribute_list_equal (const_tree l1
, const_tree l2
)
6379 return attribute_list_contained (l1
, l2
)
6380 && attribute_list_contained (l2
, l1
);
6383 /* Given two lists of attributes, return true if list L2 is
6384 completely contained within L1. */
6385 /* ??? This would be faster if attribute names were stored in a canonicalized
6386 form. Otherwise, if L1 uses `foo' and L2 uses `__foo__', the long method
6387 must be used to show these elements are equivalent (which they are). */
6388 /* ??? It's not clear that attributes with arguments will always be handled
6392 attribute_list_contained (const_tree l1
, const_tree l2
)
6396 /* First check the obvious, maybe the lists are identical. */
6400 /* Maybe the lists are similar. */
6401 for (t1
= l1
, t2
= l2
;
6403 && TREE_PURPOSE (t1
) == TREE_PURPOSE (t2
)
6404 && TREE_VALUE (t1
) == TREE_VALUE (t2
);
6405 t1
= TREE_CHAIN (t1
), t2
= TREE_CHAIN (t2
))
6408 /* Maybe the lists are equal. */
6409 if (t1
== 0 && t2
== 0)
6412 for (; t2
!= 0; t2
= TREE_CHAIN (t2
))
6415 /* This CONST_CAST is okay because lookup_attribute does not
6416 modify its argument and the return value is assigned to a
6418 for (attr
= lookup_ident_attribute (TREE_PURPOSE (t2
), CONST_CAST_TREE(l1
));
6419 attr
!= NULL_TREE
&& !attribute_value_equal (t2
, attr
);
6420 attr
= lookup_ident_attribute (TREE_PURPOSE (t2
), TREE_CHAIN (attr
)))
6423 if (attr
== NULL_TREE
)
6430 /* Given two lists of types
6431 (chains of TREE_LIST nodes with types in the TREE_VALUE slots)
6432 return 1 if the lists contain the same types in the same order.
6433 Also, the TREE_PURPOSEs must match. */
6436 type_list_equal (const_tree l1
, const_tree l2
)
6440 for (t1
= l1
, t2
= l2
; t1
&& t2
; t1
= TREE_CHAIN (t1
), t2
= TREE_CHAIN (t2
))
6441 if (TREE_VALUE (t1
) != TREE_VALUE (t2
)
6442 || (TREE_PURPOSE (t1
) != TREE_PURPOSE (t2
)
6443 && ! (1 == simple_cst_equal (TREE_PURPOSE (t1
), TREE_PURPOSE (t2
))
6444 && (TREE_TYPE (TREE_PURPOSE (t1
))
6445 == TREE_TYPE (TREE_PURPOSE (t2
))))))
6451 /* Returns the number of arguments to the FUNCTION_TYPE or METHOD_TYPE
6452 given by TYPE. If the argument list accepts variable arguments,
6453 then this function counts only the ordinary arguments. */
6456 type_num_arguments (const_tree type
)
6461 for (t
= TYPE_ARG_TYPES (type
); t
; t
= TREE_CHAIN (t
))
6462 /* If the function does not take a variable number of arguments,
6463 the last element in the list will have type `void'. */
6464 if (VOID_TYPE_P (TREE_VALUE (t
)))
6472 /* Nonzero if integer constants T1 and T2
6473 represent the same constant value. */
6476 tree_int_cst_equal (const_tree t1
, const_tree t2
)
6481 if (t1
== 0 || t2
== 0)
6484 if (TREE_CODE (t1
) == INTEGER_CST
6485 && TREE_CODE (t2
) == INTEGER_CST
6486 && TREE_INT_CST_LOW (t1
) == TREE_INT_CST_LOW (t2
)
6487 && TREE_INT_CST_HIGH (t1
) == TREE_INT_CST_HIGH (t2
))
6493 /* Nonzero if integer constants T1 and T2 represent values that satisfy <.
6494 The precise way of comparison depends on their data type. */
6497 tree_int_cst_lt (const_tree t1
, const_tree t2
)
6502 if (TYPE_UNSIGNED (TREE_TYPE (t1
)) != TYPE_UNSIGNED (TREE_TYPE (t2
)))
6504 int t1_sgn
= tree_int_cst_sgn (t1
);
6505 int t2_sgn
= tree_int_cst_sgn (t2
);
6507 if (t1_sgn
< t2_sgn
)
6509 else if (t1_sgn
> t2_sgn
)
6511 /* Otherwise, both are non-negative, so we compare them as
6512 unsigned just in case one of them would overflow a signed
6515 else if (!TYPE_UNSIGNED (TREE_TYPE (t1
)))
6516 return INT_CST_LT (t1
, t2
);
6518 return INT_CST_LT_UNSIGNED (t1
, t2
);
6521 /* Returns -1 if T1 < T2, 0 if T1 == T2, and 1 if T1 > T2. */
6524 tree_int_cst_compare (const_tree t1
, const_tree t2
)
6526 if (tree_int_cst_lt (t1
, t2
))
6528 else if (tree_int_cst_lt (t2
, t1
))
6534 /* Return 1 if T is an INTEGER_CST that can be manipulated efficiently on
6535 the host. If POS is zero, the value can be represented in a single
6536 HOST_WIDE_INT. If POS is nonzero, the value must be non-negative and can
6537 be represented in a single unsigned HOST_WIDE_INT. */
6540 host_integerp (const_tree t
, int pos
)
6545 return (TREE_CODE (t
) == INTEGER_CST
6546 && ((TREE_INT_CST_HIGH (t
) == 0
6547 && (HOST_WIDE_INT
) TREE_INT_CST_LOW (t
) >= 0)
6548 || (! pos
&& TREE_INT_CST_HIGH (t
) == -1
6549 && (HOST_WIDE_INT
) TREE_INT_CST_LOW (t
) < 0
6550 && (!TYPE_UNSIGNED (TREE_TYPE (t
))
6551 || (TREE_CODE (TREE_TYPE (t
)) == INTEGER_TYPE
6552 && TYPE_IS_SIZETYPE (TREE_TYPE (t
)))))
6553 || (pos
&& TREE_INT_CST_HIGH (t
) == 0)));
6556 /* Return the HOST_WIDE_INT least significant bits of T if it is an
6557 INTEGER_CST and there is no overflow. POS is nonzero if the result must
6558 be non-negative. We must be able to satisfy the above conditions. */
6561 tree_low_cst (const_tree t
, int pos
)
6563 gcc_assert (host_integerp (t
, pos
));
6564 return TREE_INT_CST_LOW (t
);
6567 /* Return the HOST_WIDE_INT least significant bits of T, a sizetype
6568 kind INTEGER_CST. This makes sure to properly sign-extend the
6572 size_low_cst (const_tree t
)
6574 double_int d
= tree_to_double_int (t
);
6575 return double_int_sext (d
, TYPE_PRECISION (TREE_TYPE (t
))).low
;
6578 /* Return the most significant (sign) bit of T. */
6581 tree_int_cst_sign_bit (const_tree t
)
6583 unsigned bitno
= TYPE_PRECISION (TREE_TYPE (t
)) - 1;
6584 unsigned HOST_WIDE_INT w
;
6586 if (bitno
< HOST_BITS_PER_WIDE_INT
)
6587 w
= TREE_INT_CST_LOW (t
);
6590 w
= TREE_INT_CST_HIGH (t
);
6591 bitno
-= HOST_BITS_PER_WIDE_INT
;
6594 return (w
>> bitno
) & 1;
6597 /* Return an indication of the sign of the integer constant T.
6598 The return value is -1 if T < 0, 0 if T == 0, and 1 if T > 0.
6599 Note that -1 will never be returned if T's type is unsigned. */
6602 tree_int_cst_sgn (const_tree t
)
6604 if (TREE_INT_CST_LOW (t
) == 0 && TREE_INT_CST_HIGH (t
) == 0)
6606 else if (TYPE_UNSIGNED (TREE_TYPE (t
)))
6608 else if (TREE_INT_CST_HIGH (t
) < 0)
6614 /* Return the minimum number of bits needed to represent VALUE in a
6615 signed or unsigned type, UNSIGNEDP says which. */
6618 tree_int_cst_min_precision (tree value
, bool unsignedp
)
6622 /* If the value is negative, compute its negative minus 1. The latter
6623 adjustment is because the absolute value of the largest negative value
6624 is one larger than the largest positive value. This is equivalent to
6625 a bit-wise negation, so use that operation instead. */
6627 if (tree_int_cst_sgn (value
) < 0)
6628 value
= fold_build1 (BIT_NOT_EXPR
, TREE_TYPE (value
), value
);
6630 /* Return the number of bits needed, taking into account the fact
6631 that we need one more bit for a signed than unsigned type. */
6633 if (integer_zerop (value
))
6636 log
= tree_floor_log2 (value
);
6638 return log
+ 1 + !unsignedp
;
6641 /* Compare two constructor-element-type constants. Return 1 if the lists
6642 are known to be equal; otherwise return 0. */
6645 simple_cst_list_equal (const_tree l1
, const_tree l2
)
6647 while (l1
!= NULL_TREE
&& l2
!= NULL_TREE
)
6649 if (simple_cst_equal (TREE_VALUE (l1
), TREE_VALUE (l2
)) != 1)
6652 l1
= TREE_CHAIN (l1
);
6653 l2
= TREE_CHAIN (l2
);
6659 /* Return truthvalue of whether T1 is the same tree structure as T2.
6660 Return 1 if they are the same.
6661 Return 0 if they are understandably different.
6662 Return -1 if either contains tree structure not understood by
6666 simple_cst_equal (const_tree t1
, const_tree t2
)
6668 enum tree_code code1
, code2
;
6674 if (t1
== 0 || t2
== 0)
6677 code1
= TREE_CODE (t1
);
6678 code2
= TREE_CODE (t2
);
6680 if (CONVERT_EXPR_CODE_P (code1
) || code1
== NON_LVALUE_EXPR
)
6682 if (CONVERT_EXPR_CODE_P (code2
)
6683 || code2
== NON_LVALUE_EXPR
)
6684 return simple_cst_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
6686 return simple_cst_equal (TREE_OPERAND (t1
, 0), t2
);
6689 else if (CONVERT_EXPR_CODE_P (code2
)
6690 || code2
== NON_LVALUE_EXPR
)
6691 return simple_cst_equal (t1
, TREE_OPERAND (t2
, 0));
6699 return (TREE_INT_CST_LOW (t1
) == TREE_INT_CST_LOW (t2
)
6700 && TREE_INT_CST_HIGH (t1
) == TREE_INT_CST_HIGH (t2
));
6703 return REAL_VALUES_IDENTICAL (TREE_REAL_CST (t1
), TREE_REAL_CST (t2
));
6706 return FIXED_VALUES_IDENTICAL (TREE_FIXED_CST (t1
), TREE_FIXED_CST (t2
));
6709 return (TREE_STRING_LENGTH (t1
) == TREE_STRING_LENGTH (t2
)
6710 && ! memcmp (TREE_STRING_POINTER (t1
), TREE_STRING_POINTER (t2
),
6711 TREE_STRING_LENGTH (t1
)));
6715 unsigned HOST_WIDE_INT idx
;
6716 VEC(constructor_elt
, gc
) *v1
= CONSTRUCTOR_ELTS (t1
);
6717 VEC(constructor_elt
, gc
) *v2
= CONSTRUCTOR_ELTS (t2
);
6719 if (VEC_length (constructor_elt
, v1
) != VEC_length (constructor_elt
, v2
))
6722 for (idx
= 0; idx
< VEC_length (constructor_elt
, v1
); ++idx
)
6723 /* ??? Should we handle also fields here? */
6724 if (!simple_cst_equal (VEC_index (constructor_elt
, v1
, idx
)->value
,
6725 VEC_index (constructor_elt
, v2
, idx
)->value
))
6731 return simple_cst_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
6734 cmp
= simple_cst_equal (CALL_EXPR_FN (t1
), CALL_EXPR_FN (t2
));
6737 if (call_expr_nargs (t1
) != call_expr_nargs (t2
))
6740 const_tree arg1
, arg2
;
6741 const_call_expr_arg_iterator iter1
, iter2
;
6742 for (arg1
= first_const_call_expr_arg (t1
, &iter1
),
6743 arg2
= first_const_call_expr_arg (t2
, &iter2
);
6745 arg1
= next_const_call_expr_arg (&iter1
),
6746 arg2
= next_const_call_expr_arg (&iter2
))
6748 cmp
= simple_cst_equal (arg1
, arg2
);
6752 return arg1
== arg2
;
6756 /* Special case: if either target is an unallocated VAR_DECL,
6757 it means that it's going to be unified with whatever the
6758 TARGET_EXPR is really supposed to initialize, so treat it
6759 as being equivalent to anything. */
6760 if ((TREE_CODE (TREE_OPERAND (t1
, 0)) == VAR_DECL
6761 && DECL_NAME (TREE_OPERAND (t1
, 0)) == NULL_TREE
6762 && !DECL_RTL_SET_P (TREE_OPERAND (t1
, 0)))
6763 || (TREE_CODE (TREE_OPERAND (t2
, 0)) == VAR_DECL
6764 && DECL_NAME (TREE_OPERAND (t2
, 0)) == NULL_TREE
6765 && !DECL_RTL_SET_P (TREE_OPERAND (t2
, 0))))
6768 cmp
= simple_cst_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
6773 return simple_cst_equal (TREE_OPERAND (t1
, 1), TREE_OPERAND (t2
, 1));
6775 case WITH_CLEANUP_EXPR
:
6776 cmp
= simple_cst_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
6780 return simple_cst_equal (TREE_OPERAND (t1
, 1), TREE_OPERAND (t1
, 1));
6783 if (TREE_OPERAND (t1
, 1) == TREE_OPERAND (t2
, 1))
6784 return simple_cst_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
6798 /* This general rule works for most tree codes. All exceptions should be
6799 handled above. If this is a language-specific tree code, we can't
6800 trust what might be in the operand, so say we don't know
6802 if ((int) code1
>= (int) LAST_AND_UNUSED_TREE_CODE
)
6805 switch (TREE_CODE_CLASS (code1
))
6809 case tcc_comparison
:
6810 case tcc_expression
:
6814 for (i
= 0; i
< TREE_CODE_LENGTH (code1
); i
++)
6816 cmp
= simple_cst_equal (TREE_OPERAND (t1
, i
), TREE_OPERAND (t2
, i
));
6828 /* Compare the value of T, an INTEGER_CST, with U, an unsigned integer value.
6829 Return -1, 0, or 1 if the value of T is less than, equal to, or greater
6830 than U, respectively. */
6833 compare_tree_int (const_tree t
, unsigned HOST_WIDE_INT u
)
6835 if (tree_int_cst_sgn (t
) < 0)
6837 else if (TREE_INT_CST_HIGH (t
) != 0)
6839 else if (TREE_INT_CST_LOW (t
) == u
)
6841 else if (TREE_INT_CST_LOW (t
) < u
)
6847 /* Return true if CODE represents an associative tree code. Otherwise
6850 associative_tree_code (enum tree_code code
)
6869 /* Return true if CODE represents a commutative tree code. Otherwise
6872 commutative_tree_code (enum tree_code code
)
6885 case UNORDERED_EXPR
:
6889 case TRUTH_AND_EXPR
:
6890 case TRUTH_XOR_EXPR
:
6900 /* Return true if CODE represents a ternary tree code for which the
6901 first two operands are commutative. Otherwise return false. */
6903 commutative_ternary_tree_code (enum tree_code code
)
6907 case WIDEN_MULT_PLUS_EXPR
:
6908 case WIDEN_MULT_MINUS_EXPR
:
6917 /* Generate a hash value for an expression. This can be used iteratively
6918 by passing a previous result as the VAL argument.
6920 This function is intended to produce the same hash for expressions which
6921 would compare equal using operand_equal_p. */
6924 iterative_hash_expr (const_tree t
, hashval_t val
)
6927 enum tree_code code
;
6931 return iterative_hash_hashval_t (0, val
);
6933 code
= TREE_CODE (t
);
6937 /* Alas, constants aren't shared, so we can't rely on pointer
6940 val
= iterative_hash_host_wide_int (TREE_INT_CST_LOW (t
), val
);
6941 return iterative_hash_host_wide_int (TREE_INT_CST_HIGH (t
), val
);
6944 unsigned int val2
= real_hash (TREE_REAL_CST_PTR (t
));
6946 return iterative_hash_hashval_t (val2
, val
);
6950 unsigned int val2
= fixed_hash (TREE_FIXED_CST_PTR (t
));
6952 return iterative_hash_hashval_t (val2
, val
);
6955 return iterative_hash (TREE_STRING_POINTER (t
),
6956 TREE_STRING_LENGTH (t
), val
);
6958 val
= iterative_hash_expr (TREE_REALPART (t
), val
);
6959 return iterative_hash_expr (TREE_IMAGPART (t
), val
);
6963 for (i
= 0; i
< VECTOR_CST_NELTS (t
); ++i
)
6964 val
= iterative_hash_expr (VECTOR_CST_ELT (t
, i
), val
);
6968 /* We can just compare by pointer. */
6969 return iterative_hash_host_wide_int (SSA_NAME_VERSION (t
), val
);
6970 case PLACEHOLDER_EXPR
:
6971 /* The node itself doesn't matter. */
6974 /* A list of expressions, for a CALL_EXPR or as the elements of a
6976 for (; t
; t
= TREE_CHAIN (t
))
6977 val
= iterative_hash_expr (TREE_VALUE (t
), val
);
6981 unsigned HOST_WIDE_INT idx
;
6983 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t
), idx
, field
, value
)
6985 val
= iterative_hash_expr (field
, val
);
6986 val
= iterative_hash_expr (value
, val
);
6992 /* The type of the second operand is relevant, except for
6993 its top-level qualifiers. */
6994 tree type
= TYPE_MAIN_VARIANT (TREE_TYPE (TREE_OPERAND (t
, 1)));
6996 val
= iterative_hash_object (TYPE_HASH (type
), val
);
6998 /* We could use the standard hash computation from this point
7000 val
= iterative_hash_object (code
, val
);
7001 val
= iterative_hash_expr (TREE_OPERAND (t
, 1), val
);
7002 val
= iterative_hash_expr (TREE_OPERAND (t
, 0), val
);
7006 /* When referring to a built-in FUNCTION_DECL, use the __builtin__ form.
7007 Otherwise nodes that compare equal according to operand_equal_p might
7008 get different hash codes. However, don't do this for machine specific
7009 or front end builtins, since the function code is overloaded in those
7011 if (DECL_BUILT_IN_CLASS (t
) == BUILT_IN_NORMAL
7012 && builtin_decl_explicit_p (DECL_FUNCTION_CODE (t
)))
7014 t
= builtin_decl_explicit (DECL_FUNCTION_CODE (t
));
7015 code
= TREE_CODE (t
);
7019 tclass
= TREE_CODE_CLASS (code
);
7021 if (tclass
== tcc_declaration
)
7023 /* DECL's have a unique ID */
7024 val
= iterative_hash_host_wide_int (DECL_UID (t
), val
);
7028 gcc_assert (IS_EXPR_CODE_CLASS (tclass
));
7030 val
= iterative_hash_object (code
, val
);
7032 /* Don't hash the type, that can lead to having nodes which
7033 compare equal according to operand_equal_p, but which
7034 have different hash codes. */
7035 if (CONVERT_EXPR_CODE_P (code
)
7036 || code
== NON_LVALUE_EXPR
)
7038 /* Make sure to include signness in the hash computation. */
7039 val
+= TYPE_UNSIGNED (TREE_TYPE (t
));
7040 val
= iterative_hash_expr (TREE_OPERAND (t
, 0), val
);
7043 else if (commutative_tree_code (code
))
7045 /* It's a commutative expression. We want to hash it the same
7046 however it appears. We do this by first hashing both operands
7047 and then rehashing based on the order of their independent
7049 hashval_t one
= iterative_hash_expr (TREE_OPERAND (t
, 0), 0);
7050 hashval_t two
= iterative_hash_expr (TREE_OPERAND (t
, 1), 0);
7054 t
= one
, one
= two
, two
= t
;
7056 val
= iterative_hash_hashval_t (one
, val
);
7057 val
= iterative_hash_hashval_t (two
, val
);
7060 for (i
= TREE_OPERAND_LENGTH (t
) - 1; i
>= 0; --i
)
7061 val
= iterative_hash_expr (TREE_OPERAND (t
, i
), val
);
7067 /* Generate a hash value for a pair of expressions. This can be used
7068 iteratively by passing a previous result as the VAL argument.
7070 The same hash value is always returned for a given pair of expressions,
7071 regardless of the order in which they are presented. This is useful in
7072 hashing the operands of commutative functions. */
7075 iterative_hash_exprs_commutative (const_tree t1
,
7076 const_tree t2
, hashval_t val
)
7078 hashval_t one
= iterative_hash_expr (t1
, 0);
7079 hashval_t two
= iterative_hash_expr (t2
, 0);
7083 t
= one
, one
= two
, two
= t
;
7084 val
= iterative_hash_hashval_t (one
, val
);
7085 val
= iterative_hash_hashval_t (two
, val
);
7090 /* Constructors for pointer, array and function types.
7091 (RECORD_TYPE, UNION_TYPE and ENUMERAL_TYPE nodes are
7092 constructed by language-dependent code, not here.) */
7094 /* Construct, lay out and return the type of pointers to TO_TYPE with
7095 mode MODE. If CAN_ALIAS_ALL is TRUE, indicate this type can
7096 reference all of memory. If such a type has already been
7097 constructed, reuse it. */
7100 build_pointer_type_for_mode (tree to_type
, enum machine_mode mode
,
7105 if (to_type
== error_mark_node
)
7106 return error_mark_node
;
7108 /* If the pointed-to type has the may_alias attribute set, force
7109 a TYPE_REF_CAN_ALIAS_ALL pointer to be generated. */
7110 if (lookup_attribute ("may_alias", TYPE_ATTRIBUTES (to_type
)))
7111 can_alias_all
= true;
7113 /* In some cases, languages will have things that aren't a POINTER_TYPE
7114 (such as a RECORD_TYPE for fat pointers in Ada) as TYPE_POINTER_TO.
7115 In that case, return that type without regard to the rest of our
7118 ??? This is a kludge, but consistent with the way this function has
7119 always operated and there doesn't seem to be a good way to avoid this
7121 if (TYPE_POINTER_TO (to_type
) != 0
7122 && TREE_CODE (TYPE_POINTER_TO (to_type
)) != POINTER_TYPE
)
7123 return TYPE_POINTER_TO (to_type
);
7125 /* First, if we already have a type for pointers to TO_TYPE and it's
7126 the proper mode, use it. */
7127 for (t
= TYPE_POINTER_TO (to_type
); t
; t
= TYPE_NEXT_PTR_TO (t
))
7128 if (TYPE_MODE (t
) == mode
&& TYPE_REF_CAN_ALIAS_ALL (t
) == can_alias_all
)
7131 t
= make_node (POINTER_TYPE
);
7133 TREE_TYPE (t
) = to_type
;
7134 SET_TYPE_MODE (t
, mode
);
7135 TYPE_REF_CAN_ALIAS_ALL (t
) = can_alias_all
;
7136 TYPE_NEXT_PTR_TO (t
) = TYPE_POINTER_TO (to_type
);
7137 TYPE_POINTER_TO (to_type
) = t
;
7139 if (TYPE_STRUCTURAL_EQUALITY_P (to_type
))
7140 SET_TYPE_STRUCTURAL_EQUALITY (t
);
7141 else if (TYPE_CANONICAL (to_type
) != to_type
)
7143 = build_pointer_type_for_mode (TYPE_CANONICAL (to_type
),
7144 mode
, can_alias_all
);
7146 /* Lay out the type. This function has many callers that are concerned
7147 with expression-construction, and this simplifies them all. */
7153 /* By default build pointers in ptr_mode. */
7156 build_pointer_type (tree to_type
)
7158 addr_space_t as
= to_type
== error_mark_node
? ADDR_SPACE_GENERIC
7159 : TYPE_ADDR_SPACE (to_type
);
7160 enum machine_mode pointer_mode
= targetm
.addr_space
.pointer_mode (as
);
7161 return build_pointer_type_for_mode (to_type
, pointer_mode
, false);
7164 /* Same as build_pointer_type_for_mode, but for REFERENCE_TYPE. */
7167 build_reference_type_for_mode (tree to_type
, enum machine_mode mode
,
7172 if (to_type
== error_mark_node
)
7173 return error_mark_node
;
7175 /* If the pointed-to type has the may_alias attribute set, force
7176 a TYPE_REF_CAN_ALIAS_ALL pointer to be generated. */
7177 if (lookup_attribute ("may_alias", TYPE_ATTRIBUTES (to_type
)))
7178 can_alias_all
= true;
7180 /* In some cases, languages will have things that aren't a REFERENCE_TYPE
7181 (such as a RECORD_TYPE for fat pointers in Ada) as TYPE_REFERENCE_TO.
7182 In that case, return that type without regard to the rest of our
7185 ??? This is a kludge, but consistent with the way this function has
7186 always operated and there doesn't seem to be a good way to avoid this
7188 if (TYPE_REFERENCE_TO (to_type
) != 0
7189 && TREE_CODE (TYPE_REFERENCE_TO (to_type
)) != REFERENCE_TYPE
)
7190 return TYPE_REFERENCE_TO (to_type
);
7192 /* First, if we already have a type for pointers to TO_TYPE and it's
7193 the proper mode, use it. */
7194 for (t
= TYPE_REFERENCE_TO (to_type
); t
; t
= TYPE_NEXT_REF_TO (t
))
7195 if (TYPE_MODE (t
) == mode
&& TYPE_REF_CAN_ALIAS_ALL (t
) == can_alias_all
)
7198 t
= make_node (REFERENCE_TYPE
);
7200 TREE_TYPE (t
) = to_type
;
7201 SET_TYPE_MODE (t
, mode
);
7202 TYPE_REF_CAN_ALIAS_ALL (t
) = can_alias_all
;
7203 TYPE_NEXT_REF_TO (t
) = TYPE_REFERENCE_TO (to_type
);
7204 TYPE_REFERENCE_TO (to_type
) = t
;
7206 if (TYPE_STRUCTURAL_EQUALITY_P (to_type
))
7207 SET_TYPE_STRUCTURAL_EQUALITY (t
);
7208 else if (TYPE_CANONICAL (to_type
) != to_type
)
7210 = build_reference_type_for_mode (TYPE_CANONICAL (to_type
),
7211 mode
, can_alias_all
);
7219 /* Build the node for the type of references-to-TO_TYPE by default
7223 build_reference_type (tree to_type
)
7225 addr_space_t as
= to_type
== error_mark_node
? ADDR_SPACE_GENERIC
7226 : TYPE_ADDR_SPACE (to_type
);
7227 enum machine_mode pointer_mode
= targetm
.addr_space
.pointer_mode (as
);
7228 return build_reference_type_for_mode (to_type
, pointer_mode
, false);
7231 /* Build a type that is compatible with t but has no cv quals anywhere
7234 const char *const *const * -> char ***. */
7237 build_type_no_quals (tree t
)
7239 switch (TREE_CODE (t
))
7242 return build_pointer_type_for_mode (build_type_no_quals (TREE_TYPE (t
)),
7244 TYPE_REF_CAN_ALIAS_ALL (t
));
7245 case REFERENCE_TYPE
:
7247 build_reference_type_for_mode (build_type_no_quals (TREE_TYPE (t
)),
7249 TYPE_REF_CAN_ALIAS_ALL (t
));
7251 return TYPE_MAIN_VARIANT (t
);
7255 #define MAX_INT_CACHED_PREC \
7256 (HOST_BITS_PER_WIDE_INT > 64 ? HOST_BITS_PER_WIDE_INT : 64)
7257 static GTY(()) tree nonstandard_integer_type_cache
[2 * MAX_INT_CACHED_PREC
+ 2];
7259 /* Builds a signed or unsigned integer type of precision PRECISION.
7260 Used for C bitfields whose precision does not match that of
7261 built-in target types. */
7263 build_nonstandard_integer_type (unsigned HOST_WIDE_INT precision
,
7269 unsignedp
= MAX_INT_CACHED_PREC
+ 1;
7271 if (precision
<= MAX_INT_CACHED_PREC
)
7273 itype
= nonstandard_integer_type_cache
[precision
+ unsignedp
];
7278 itype
= make_node (INTEGER_TYPE
);
7279 TYPE_PRECISION (itype
) = precision
;
7282 fixup_unsigned_type (itype
);
7284 fixup_signed_type (itype
);
7287 if (host_integerp (TYPE_MAX_VALUE (itype
), 1))
7288 ret
= type_hash_canon (tree_low_cst (TYPE_MAX_VALUE (itype
), 1), itype
);
7289 if (precision
<= MAX_INT_CACHED_PREC
)
7290 nonstandard_integer_type_cache
[precision
+ unsignedp
] = ret
;
7295 /* Create a range of some discrete type TYPE (an INTEGER_TYPE, ENUMERAL_TYPE
7296 or BOOLEAN_TYPE) with low bound LOWVAL and high bound HIGHVAL. If SHARED
7297 is true, reuse such a type that has already been constructed. */
7300 build_range_type_1 (tree type
, tree lowval
, tree highval
, bool shared
)
7302 tree itype
= make_node (INTEGER_TYPE
);
7303 hashval_t hashcode
= 0;
7305 TREE_TYPE (itype
) = type
;
7307 TYPE_MIN_VALUE (itype
) = fold_convert (type
, lowval
);
7308 TYPE_MAX_VALUE (itype
) = highval
? fold_convert (type
, highval
) : NULL
;
7310 TYPE_PRECISION (itype
) = TYPE_PRECISION (type
);
7311 SET_TYPE_MODE (itype
, TYPE_MODE (type
));
7312 TYPE_SIZE (itype
) = TYPE_SIZE (type
);
7313 TYPE_SIZE_UNIT (itype
) = TYPE_SIZE_UNIT (type
);
7314 TYPE_ALIGN (itype
) = TYPE_ALIGN (type
);
7315 TYPE_USER_ALIGN (itype
) = TYPE_USER_ALIGN (type
);
7320 if ((TYPE_MIN_VALUE (itype
)
7321 && TREE_CODE (TYPE_MIN_VALUE (itype
)) != INTEGER_CST
)
7322 || (TYPE_MAX_VALUE (itype
)
7323 && TREE_CODE (TYPE_MAX_VALUE (itype
)) != INTEGER_CST
))
7325 /* Since we cannot reliably merge this type, we need to compare it using
7326 structural equality checks. */
7327 SET_TYPE_STRUCTURAL_EQUALITY (itype
);
7331 hashcode
= iterative_hash_expr (TYPE_MIN_VALUE (itype
), hashcode
);
7332 hashcode
= iterative_hash_expr (TYPE_MAX_VALUE (itype
), hashcode
);
7333 hashcode
= iterative_hash_hashval_t (TYPE_HASH (type
), hashcode
);
7334 itype
= type_hash_canon (hashcode
, itype
);
7339 /* Wrapper around build_range_type_1 with SHARED set to true. */
7342 build_range_type (tree type
, tree lowval
, tree highval
)
7344 return build_range_type_1 (type
, lowval
, highval
, true);
7347 /* Wrapper around build_range_type_1 with SHARED set to false. */
7350 build_nonshared_range_type (tree type
, tree lowval
, tree highval
)
7352 return build_range_type_1 (type
, lowval
, highval
, false);
7355 /* Create a type of integers to be the TYPE_DOMAIN of an ARRAY_TYPE.
7356 MAXVAL should be the maximum value in the domain
7357 (one less than the length of the array).
7359 The maximum value that MAXVAL can have is INT_MAX for a HOST_WIDE_INT.
7360 We don't enforce this limit, that is up to caller (e.g. language front end).
7361 The limit exists because the result is a signed type and we don't handle
7362 sizes that use more than one HOST_WIDE_INT. */
7365 build_index_type (tree maxval
)
7367 return build_range_type (sizetype
, size_zero_node
, maxval
);
7370 /* Return true if the debug information for TYPE, a subtype, should be emitted
7371 as a subrange type. If so, set LOWVAL to the low bound and HIGHVAL to the
7372 high bound, respectively. Sometimes doing so unnecessarily obfuscates the
7373 debug info and doesn't reflect the source code. */
7376 subrange_type_for_debug_p (const_tree type
, tree
*lowval
, tree
*highval
)
7378 tree base_type
= TREE_TYPE (type
), low
, high
;
7380 /* Subrange types have a base type which is an integral type. */
7381 if (!INTEGRAL_TYPE_P (base_type
))
7384 /* Get the real bounds of the subtype. */
7385 if (lang_hooks
.types
.get_subrange_bounds
)
7386 lang_hooks
.types
.get_subrange_bounds (type
, &low
, &high
);
7389 low
= TYPE_MIN_VALUE (type
);
7390 high
= TYPE_MAX_VALUE (type
);
7393 /* If the type and its base type have the same representation and the same
7394 name, then the type is not a subrange but a copy of the base type. */
7395 if ((TREE_CODE (base_type
) == INTEGER_TYPE
7396 || TREE_CODE (base_type
) == BOOLEAN_TYPE
)
7397 && int_size_in_bytes (type
) == int_size_in_bytes (base_type
)
7398 && tree_int_cst_equal (low
, TYPE_MIN_VALUE (base_type
))
7399 && tree_int_cst_equal (high
, TYPE_MAX_VALUE (base_type
)))
7401 tree type_name
= TYPE_NAME (type
);
7402 tree base_type_name
= TYPE_NAME (base_type
);
7404 if (type_name
&& TREE_CODE (type_name
) == TYPE_DECL
)
7405 type_name
= DECL_NAME (type_name
);
7407 if (base_type_name
&& TREE_CODE (base_type_name
) == TYPE_DECL
)
7408 base_type_name
= DECL_NAME (base_type_name
);
7410 if (type_name
== base_type_name
)
7421 /* Construct, lay out and return the type of arrays of elements with ELT_TYPE
7422 and number of elements specified by the range of values of INDEX_TYPE.
7423 If SHARED is true, reuse such a type that has already been constructed. */
7426 build_array_type_1 (tree elt_type
, tree index_type
, bool shared
)
7430 if (TREE_CODE (elt_type
) == FUNCTION_TYPE
)
7432 error ("arrays of functions are not meaningful");
7433 elt_type
= integer_type_node
;
7436 t
= make_node (ARRAY_TYPE
);
7437 TREE_TYPE (t
) = elt_type
;
7438 TYPE_DOMAIN (t
) = index_type
;
7439 TYPE_ADDR_SPACE (t
) = TYPE_ADDR_SPACE (elt_type
);
7442 /* If the element type is incomplete at this point we get marked for
7443 structural equality. Do not record these types in the canonical
7445 if (TYPE_STRUCTURAL_EQUALITY_P (t
))
7450 hashval_t hashcode
= iterative_hash_object (TYPE_HASH (elt_type
), 0);
7452 hashcode
= iterative_hash_object (TYPE_HASH (index_type
), hashcode
);
7453 t
= type_hash_canon (hashcode
, t
);
7456 if (TYPE_CANONICAL (t
) == t
)
7458 if (TYPE_STRUCTURAL_EQUALITY_P (elt_type
)
7459 || (index_type
&& TYPE_STRUCTURAL_EQUALITY_P (index_type
)))
7460 SET_TYPE_STRUCTURAL_EQUALITY (t
);
7461 else if (TYPE_CANONICAL (elt_type
) != elt_type
7462 || (index_type
&& TYPE_CANONICAL (index_type
) != index_type
))
7464 = build_array_type_1 (TYPE_CANONICAL (elt_type
),
7466 ? TYPE_CANONICAL (index_type
) : NULL_TREE
,
7473 /* Wrapper around build_array_type_1 with SHARED set to true. */
7476 build_array_type (tree elt_type
, tree index_type
)
7478 return build_array_type_1 (elt_type
, index_type
, true);
7481 /* Wrapper around build_array_type_1 with SHARED set to false. */
7484 build_nonshared_array_type (tree elt_type
, tree index_type
)
7486 return build_array_type_1 (elt_type
, index_type
, false);
7489 /* Return a representation of ELT_TYPE[NELTS], using indices of type
7493 build_array_type_nelts (tree elt_type
, unsigned HOST_WIDE_INT nelts
)
7495 return build_array_type (elt_type
, build_index_type (size_int (nelts
- 1)));
7498 /* Recursively examines the array elements of TYPE, until a non-array
7499 element type is found. */
7502 strip_array_types (tree type
)
7504 while (TREE_CODE (type
) == ARRAY_TYPE
)
7505 type
= TREE_TYPE (type
);
7510 /* Computes the canonical argument types from the argument type list
7513 Upon return, *ANY_STRUCTURAL_P will be true iff either it was true
7514 on entry to this function, or if any of the ARGTYPES are
7517 Upon return, *ANY_NONCANONICAL_P will be true iff either it was
7518 true on entry to this function, or if any of the ARGTYPES are
7521 Returns a canonical argument list, which may be ARGTYPES when the
7522 canonical argument list is unneeded (i.e., *ANY_STRUCTURAL_P is
7523 true) or would not differ from ARGTYPES. */
7526 maybe_canonicalize_argtypes(tree argtypes
,
7527 bool *any_structural_p
,
7528 bool *any_noncanonical_p
)
7531 bool any_noncanonical_argtypes_p
= false;
7533 for (arg
= argtypes
; arg
&& !(*any_structural_p
); arg
= TREE_CHAIN (arg
))
7535 if (!TREE_VALUE (arg
) || TREE_VALUE (arg
) == error_mark_node
)
7536 /* Fail gracefully by stating that the type is structural. */
7537 *any_structural_p
= true;
7538 else if (TYPE_STRUCTURAL_EQUALITY_P (TREE_VALUE (arg
)))
7539 *any_structural_p
= true;
7540 else if (TYPE_CANONICAL (TREE_VALUE (arg
)) != TREE_VALUE (arg
)
7541 || TREE_PURPOSE (arg
))
7542 /* If the argument has a default argument, we consider it
7543 non-canonical even though the type itself is canonical.
7544 That way, different variants of function and method types
7545 with default arguments will all point to the variant with
7546 no defaults as their canonical type. */
7547 any_noncanonical_argtypes_p
= true;
7550 if (*any_structural_p
)
7553 if (any_noncanonical_argtypes_p
)
7555 /* Build the canonical list of argument types. */
7556 tree canon_argtypes
= NULL_TREE
;
7557 bool is_void
= false;
7559 for (arg
= argtypes
; arg
; arg
= TREE_CHAIN (arg
))
7561 if (arg
== void_list_node
)
7564 canon_argtypes
= tree_cons (NULL_TREE
,
7565 TYPE_CANONICAL (TREE_VALUE (arg
)),
7569 canon_argtypes
= nreverse (canon_argtypes
);
7571 canon_argtypes
= chainon (canon_argtypes
, void_list_node
);
7573 /* There is a non-canonical type. */
7574 *any_noncanonical_p
= true;
7575 return canon_argtypes
;
7578 /* The canonical argument types are the same as ARGTYPES. */
7582 /* Construct, lay out and return
7583 the type of functions returning type VALUE_TYPE
7584 given arguments of types ARG_TYPES.
7585 ARG_TYPES is a chain of TREE_LIST nodes whose TREE_VALUEs
7586 are data type nodes for the arguments of the function.
7587 If such a type has already been constructed, reuse it. */
7590 build_function_type (tree value_type
, tree arg_types
)
7593 hashval_t hashcode
= 0;
7594 bool any_structural_p
, any_noncanonical_p
;
7595 tree canon_argtypes
;
7597 if (TREE_CODE (value_type
) == FUNCTION_TYPE
)
7599 error ("function return type cannot be function");
7600 value_type
= integer_type_node
;
7603 /* Make a node of the sort we want. */
7604 t
= make_node (FUNCTION_TYPE
);
7605 TREE_TYPE (t
) = value_type
;
7606 TYPE_ARG_TYPES (t
) = arg_types
;
7608 /* If we already have such a type, use the old one. */
7609 hashcode
= iterative_hash_object (TYPE_HASH (value_type
), hashcode
);
7610 hashcode
= type_hash_list (arg_types
, hashcode
);
7611 t
= type_hash_canon (hashcode
, t
);
7613 /* Set up the canonical type. */
7614 any_structural_p
= TYPE_STRUCTURAL_EQUALITY_P (value_type
);
7615 any_noncanonical_p
= TYPE_CANONICAL (value_type
) != value_type
;
7616 canon_argtypes
= maybe_canonicalize_argtypes (arg_types
,
7618 &any_noncanonical_p
);
7619 if (any_structural_p
)
7620 SET_TYPE_STRUCTURAL_EQUALITY (t
);
7621 else if (any_noncanonical_p
)
7622 TYPE_CANONICAL (t
) = build_function_type (TYPE_CANONICAL (value_type
),
7625 if (!COMPLETE_TYPE_P (t
))
7630 /* Build variant of function type ORIG_TYPE skipping ARGS_TO_SKIP and the
7631 return value if SKIP_RETURN is true. */
7634 build_function_type_skip_args (tree orig_type
, bitmap args_to_skip
,
7637 tree new_type
= NULL
;
7638 tree args
, new_args
= NULL
, t
;
7642 for (args
= TYPE_ARG_TYPES (orig_type
); args
&& args
!= void_list_node
;
7643 args
= TREE_CHAIN (args
), i
++)
7644 if (!args_to_skip
|| !bitmap_bit_p (args_to_skip
, i
))
7645 new_args
= tree_cons (NULL_TREE
, TREE_VALUE (args
), new_args
);
7647 new_reversed
= nreverse (new_args
);
7651 TREE_CHAIN (new_args
) = void_list_node
;
7653 new_reversed
= void_list_node
;
7656 /* Use copy_node to preserve as much as possible from original type
7657 (debug info, attribute lists etc.)
7658 Exception is METHOD_TYPEs must have THIS argument.
7659 When we are asked to remove it, we need to build new FUNCTION_TYPE
7661 if (TREE_CODE (orig_type
) != METHOD_TYPE
7663 || !bitmap_bit_p (args_to_skip
, 0))
7665 new_type
= build_distinct_type_copy (orig_type
);
7666 TYPE_ARG_TYPES (new_type
) = new_reversed
;
7671 = build_distinct_type_copy (build_function_type (TREE_TYPE (orig_type
),
7673 TYPE_CONTEXT (new_type
) = TYPE_CONTEXT (orig_type
);
7677 TREE_TYPE (new_type
) = void_type_node
;
7679 /* This is a new type, not a copy of an old type. Need to reassociate
7680 variants. We can handle everything except the main variant lazily. */
7681 t
= TYPE_MAIN_VARIANT (orig_type
);
7684 t
= build_function_type_skip_args (t
, args_to_skip
, skip_return
);
7685 TYPE_MAIN_VARIANT (new_type
) = t
;
7686 TYPE_NEXT_VARIANT (new_type
) = TYPE_NEXT_VARIANT (t
);
7687 TYPE_NEXT_VARIANT (t
) = new_type
;
7691 TYPE_MAIN_VARIANT (new_type
) = new_type
;
7692 TYPE_NEXT_VARIANT (new_type
) = NULL
;
7698 /* Build variant of function decl ORIG_DECL skipping ARGS_TO_SKIP and the
7699 return value if SKIP_RETURN is true.
7701 Arguments from DECL_ARGUMENTS list can't be removed now, since they are
7702 linked by TREE_CHAIN directly. The caller is responsible for eliminating
7703 them when they are being duplicated (i.e. copy_arguments_for_versioning). */
7706 build_function_decl_skip_args (tree orig_decl
, bitmap args_to_skip
,
7709 tree new_decl
= copy_node (orig_decl
);
7712 new_type
= TREE_TYPE (orig_decl
);
7713 if (prototype_p (new_type
)
7714 || (skip_return
&& !VOID_TYPE_P (TREE_TYPE (new_type
))))
7716 = build_function_type_skip_args (new_type
, args_to_skip
, skip_return
);
7717 TREE_TYPE (new_decl
) = new_type
;
7719 /* For declarations setting DECL_VINDEX (i.e. methods)
7720 we expect first argument to be THIS pointer. */
7721 if (args_to_skip
&& bitmap_bit_p (args_to_skip
, 0))
7722 DECL_VINDEX (new_decl
) = NULL_TREE
;
7724 /* When signature changes, we need to clear builtin info. */
7725 if (DECL_BUILT_IN (new_decl
)
7727 && !bitmap_empty_p (args_to_skip
))
7729 DECL_BUILT_IN_CLASS (new_decl
) = NOT_BUILT_IN
;
7730 DECL_FUNCTION_CODE (new_decl
) = (enum built_in_function
) 0;
7735 /* Build a function type. The RETURN_TYPE is the type returned by the
7736 function. If VAARGS is set, no void_type_node is appended to the
7737 the list. ARGP must be always be terminated be a NULL_TREE. */
7740 build_function_type_list_1 (bool vaargs
, tree return_type
, va_list argp
)
7744 t
= va_arg (argp
, tree
);
7745 for (args
= NULL_TREE
; t
!= NULL_TREE
; t
= va_arg (argp
, tree
))
7746 args
= tree_cons (NULL_TREE
, t
, args
);
7751 if (args
!= NULL_TREE
)
7752 args
= nreverse (args
);
7753 gcc_assert (last
!= void_list_node
);
7755 else if (args
== NULL_TREE
)
7756 args
= void_list_node
;
7760 args
= nreverse (args
);
7761 TREE_CHAIN (last
) = void_list_node
;
7763 args
= build_function_type (return_type
, args
);
7768 /* Build a function type. The RETURN_TYPE is the type returned by the
7769 function. If additional arguments are provided, they are
7770 additional argument types. The list of argument types must always
7771 be terminated by NULL_TREE. */
7774 build_function_type_list (tree return_type
, ...)
7779 va_start (p
, return_type
);
7780 args
= build_function_type_list_1 (false, return_type
, p
);
7785 /* Build a variable argument function type. The RETURN_TYPE is the
7786 type returned by the function. If additional arguments are provided,
7787 they are additional argument types. The list of argument types must
7788 always be terminated by NULL_TREE. */
7791 build_varargs_function_type_list (tree return_type
, ...)
7796 va_start (p
, return_type
);
7797 args
= build_function_type_list_1 (true, return_type
, p
);
7803 /* Build a function type. RETURN_TYPE is the type returned by the
7804 function; VAARGS indicates whether the function takes varargs. The
7805 function takes N named arguments, the types of which are provided in
7809 build_function_type_array_1 (bool vaargs
, tree return_type
, int n
,
7813 tree t
= vaargs
? NULL_TREE
: void_list_node
;
7815 for (i
= n
- 1; i
>= 0; i
--)
7816 t
= tree_cons (NULL_TREE
, arg_types
[i
], t
);
7818 return build_function_type (return_type
, t
);
7821 /* Build a function type. RETURN_TYPE is the type returned by the
7822 function. The function takes N named arguments, the types of which
7823 are provided in ARG_TYPES. */
7826 build_function_type_array (tree return_type
, int n
, tree
*arg_types
)
7828 return build_function_type_array_1 (false, return_type
, n
, arg_types
);
7831 /* Build a variable argument function type. RETURN_TYPE is the type
7832 returned by the function. The function takes N named arguments, the
7833 types of which are provided in ARG_TYPES. */
7836 build_varargs_function_type_array (tree return_type
, int n
, tree
*arg_types
)
7838 return build_function_type_array_1 (true, return_type
, n
, arg_types
);
7841 /* Build a METHOD_TYPE for a member of BASETYPE. The RETTYPE (a TYPE)
7842 and ARGTYPES (a TREE_LIST) are the return type and arguments types
7843 for the method. An implicit additional parameter (of type
7844 pointer-to-BASETYPE) is added to the ARGTYPES. */
7847 build_method_type_directly (tree basetype
,
7854 bool any_structural_p
, any_noncanonical_p
;
7855 tree canon_argtypes
;
7857 /* Make a node of the sort we want. */
7858 t
= make_node (METHOD_TYPE
);
7860 TYPE_METHOD_BASETYPE (t
) = TYPE_MAIN_VARIANT (basetype
);
7861 TREE_TYPE (t
) = rettype
;
7862 ptype
= build_pointer_type (basetype
);
7864 /* The actual arglist for this function includes a "hidden" argument
7865 which is "this". Put it into the list of argument types. */
7866 argtypes
= tree_cons (NULL_TREE
, ptype
, argtypes
);
7867 TYPE_ARG_TYPES (t
) = argtypes
;
7869 /* If we already have such a type, use the old one. */
7870 hashcode
= iterative_hash_object (TYPE_HASH (basetype
), hashcode
);
7871 hashcode
= iterative_hash_object (TYPE_HASH (rettype
), hashcode
);
7872 hashcode
= type_hash_list (argtypes
, hashcode
);
7873 t
= type_hash_canon (hashcode
, t
);
7875 /* Set up the canonical type. */
7877 = (TYPE_STRUCTURAL_EQUALITY_P (basetype
)
7878 || TYPE_STRUCTURAL_EQUALITY_P (rettype
));
7880 = (TYPE_CANONICAL (basetype
) != basetype
7881 || TYPE_CANONICAL (rettype
) != rettype
);
7882 canon_argtypes
= maybe_canonicalize_argtypes (TREE_CHAIN (argtypes
),
7884 &any_noncanonical_p
);
7885 if (any_structural_p
)
7886 SET_TYPE_STRUCTURAL_EQUALITY (t
);
7887 else if (any_noncanonical_p
)
7889 = build_method_type_directly (TYPE_CANONICAL (basetype
),
7890 TYPE_CANONICAL (rettype
),
7892 if (!COMPLETE_TYPE_P (t
))
7898 /* Construct, lay out and return the type of methods belonging to class
7899 BASETYPE and whose arguments and values are described by TYPE.
7900 If that type exists already, reuse it.
7901 TYPE must be a FUNCTION_TYPE node. */
7904 build_method_type (tree basetype
, tree type
)
7906 gcc_assert (TREE_CODE (type
) == FUNCTION_TYPE
);
7908 return build_method_type_directly (basetype
,
7910 TYPE_ARG_TYPES (type
));
7913 /* Construct, lay out and return the type of offsets to a value
7914 of type TYPE, within an object of type BASETYPE.
7915 If a suitable offset type exists already, reuse it. */
7918 build_offset_type (tree basetype
, tree type
)
7921 hashval_t hashcode
= 0;
7923 /* Make a node of the sort we want. */
7924 t
= make_node (OFFSET_TYPE
);
7926 TYPE_OFFSET_BASETYPE (t
) = TYPE_MAIN_VARIANT (basetype
);
7927 TREE_TYPE (t
) = type
;
7929 /* If we already have such a type, use the old one. */
7930 hashcode
= iterative_hash_object (TYPE_HASH (basetype
), hashcode
);
7931 hashcode
= iterative_hash_object (TYPE_HASH (type
), hashcode
);
7932 t
= type_hash_canon (hashcode
, t
);
7934 if (!COMPLETE_TYPE_P (t
))
7937 if (TYPE_CANONICAL (t
) == t
)
7939 if (TYPE_STRUCTURAL_EQUALITY_P (basetype
)
7940 || TYPE_STRUCTURAL_EQUALITY_P (type
))
7941 SET_TYPE_STRUCTURAL_EQUALITY (t
);
7942 else if (TYPE_CANONICAL (TYPE_MAIN_VARIANT (basetype
)) != basetype
7943 || TYPE_CANONICAL (type
) != type
)
7945 = build_offset_type (TYPE_CANONICAL (TYPE_MAIN_VARIANT (basetype
)),
7946 TYPE_CANONICAL (type
));
7952 /* Create a complex type whose components are COMPONENT_TYPE. */
7955 build_complex_type (tree component_type
)
7960 gcc_assert (INTEGRAL_TYPE_P (component_type
)
7961 || SCALAR_FLOAT_TYPE_P (component_type
)
7962 || FIXED_POINT_TYPE_P (component_type
));
7964 /* Make a node of the sort we want. */
7965 t
= make_node (COMPLEX_TYPE
);
7967 TREE_TYPE (t
) = TYPE_MAIN_VARIANT (component_type
);
7969 /* If we already have such a type, use the old one. */
7970 hashcode
= iterative_hash_object (TYPE_HASH (component_type
), 0);
7971 t
= type_hash_canon (hashcode
, t
);
7973 if (!COMPLETE_TYPE_P (t
))
7976 if (TYPE_CANONICAL (t
) == t
)
7978 if (TYPE_STRUCTURAL_EQUALITY_P (component_type
))
7979 SET_TYPE_STRUCTURAL_EQUALITY (t
);
7980 else if (TYPE_CANONICAL (component_type
) != component_type
)
7982 = build_complex_type (TYPE_CANONICAL (component_type
));
7985 /* We need to create a name, since complex is a fundamental type. */
7986 if (! TYPE_NAME (t
))
7989 if (component_type
== char_type_node
)
7990 name
= "complex char";
7991 else if (component_type
== signed_char_type_node
)
7992 name
= "complex signed char";
7993 else if (component_type
== unsigned_char_type_node
)
7994 name
= "complex unsigned char";
7995 else if (component_type
== short_integer_type_node
)
7996 name
= "complex short int";
7997 else if (component_type
== short_unsigned_type_node
)
7998 name
= "complex short unsigned int";
7999 else if (component_type
== integer_type_node
)
8000 name
= "complex int";
8001 else if (component_type
== unsigned_type_node
)
8002 name
= "complex unsigned int";
8003 else if (component_type
== long_integer_type_node
)
8004 name
= "complex long int";
8005 else if (component_type
== long_unsigned_type_node
)
8006 name
= "complex long unsigned int";
8007 else if (component_type
== long_long_integer_type_node
)
8008 name
= "complex long long int";
8009 else if (component_type
== long_long_unsigned_type_node
)
8010 name
= "complex long long unsigned int";
8015 TYPE_NAME (t
) = build_decl (UNKNOWN_LOCATION
, TYPE_DECL
,
8016 get_identifier (name
), t
);
8019 return build_qualified_type (t
, TYPE_QUALS (component_type
));
8022 /* If TYPE is a real or complex floating-point type and the target
8023 does not directly support arithmetic on TYPE then return the wider
8024 type to be used for arithmetic on TYPE. Otherwise, return
8028 excess_precision_type (tree type
)
8030 if (flag_excess_precision
!= EXCESS_PRECISION_FAST
)
8032 int flt_eval_method
= TARGET_FLT_EVAL_METHOD
;
8033 switch (TREE_CODE (type
))
8036 switch (flt_eval_method
)
8039 if (TYPE_MODE (type
) == TYPE_MODE (float_type_node
))
8040 return double_type_node
;
8043 if (TYPE_MODE (type
) == TYPE_MODE (float_type_node
)
8044 || TYPE_MODE (type
) == TYPE_MODE (double_type_node
))
8045 return long_double_type_node
;
8052 if (TREE_CODE (TREE_TYPE (type
)) != REAL_TYPE
)
8054 switch (flt_eval_method
)
8057 if (TYPE_MODE (TREE_TYPE (type
)) == TYPE_MODE (float_type_node
))
8058 return complex_double_type_node
;
8061 if (TYPE_MODE (TREE_TYPE (type
)) == TYPE_MODE (float_type_node
)
8062 || (TYPE_MODE (TREE_TYPE (type
))
8063 == TYPE_MODE (double_type_node
)))
8064 return complex_long_double_type_node
;
8077 /* Return OP, stripped of any conversions to wider types as much as is safe.
8078 Converting the value back to OP's type makes a value equivalent to OP.
8080 If FOR_TYPE is nonzero, we return a value which, if converted to
8081 type FOR_TYPE, would be equivalent to converting OP to type FOR_TYPE.
8083 OP must have integer, real or enumeral type. Pointers are not allowed!
8085 There are some cases where the obvious value we could return
8086 would regenerate to OP if converted to OP's type,
8087 but would not extend like OP to wider types.
8088 If FOR_TYPE indicates such extension is contemplated, we eschew such values.
8089 For example, if OP is (unsigned short)(signed char)-1,
8090 we avoid returning (signed char)-1 if FOR_TYPE is int,
8091 even though extending that to an unsigned short would regenerate OP,
8092 since the result of extending (signed char)-1 to (int)
8093 is different from (int) OP. */
8096 get_unwidened (tree op
, tree for_type
)
8098 /* Set UNS initially if converting OP to FOR_TYPE is a zero-extension. */
8099 tree type
= TREE_TYPE (op
);
8101 = TYPE_PRECISION (for_type
!= 0 ? for_type
: type
);
8103 = (for_type
!= 0 && for_type
!= type
8104 && final_prec
> TYPE_PRECISION (type
)
8105 && TYPE_UNSIGNED (type
));
8108 while (CONVERT_EXPR_P (op
))
8112 /* TYPE_PRECISION on vector types has different meaning
8113 (TYPE_VECTOR_SUBPARTS) and casts from vectors are view conversions,
8114 so avoid them here. */
8115 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (op
, 0))) == VECTOR_TYPE
)
8118 bitschange
= TYPE_PRECISION (TREE_TYPE (op
))
8119 - TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op
, 0)));
8121 /* Truncations are many-one so cannot be removed.
8122 Unless we are later going to truncate down even farther. */
8124 && final_prec
> TYPE_PRECISION (TREE_TYPE (op
)))
8127 /* See what's inside this conversion. If we decide to strip it,
8129 op
= TREE_OPERAND (op
, 0);
8131 /* If we have not stripped any zero-extensions (uns is 0),
8132 we can strip any kind of extension.
8133 If we have previously stripped a zero-extension,
8134 only zero-extensions can safely be stripped.
8135 Any extension can be stripped if the bits it would produce
8136 are all going to be discarded later by truncating to FOR_TYPE. */
8140 if (! uns
|| final_prec
<= TYPE_PRECISION (TREE_TYPE (op
)))
8142 /* TYPE_UNSIGNED says whether this is a zero-extension.
8143 Let's avoid computing it if it does not affect WIN
8144 and if UNS will not be needed again. */
8146 || CONVERT_EXPR_P (op
))
8147 && TYPE_UNSIGNED (TREE_TYPE (op
)))
8155 /* If we finally reach a constant see if it fits in for_type and
8156 in that case convert it. */
8158 && TREE_CODE (win
) == INTEGER_CST
8159 && TREE_TYPE (win
) != for_type
8160 && int_fits_type_p (win
, for_type
))
8161 win
= fold_convert (for_type
, win
);
8166 /* Return OP or a simpler expression for a narrower value
8167 which can be sign-extended or zero-extended to give back OP.
8168 Store in *UNSIGNEDP_PTR either 1 if the value should be zero-extended
8169 or 0 if the value should be sign-extended. */
8172 get_narrower (tree op
, int *unsignedp_ptr
)
8177 bool integral_p
= INTEGRAL_TYPE_P (TREE_TYPE (op
));
8179 while (TREE_CODE (op
) == NOP_EXPR
)
8182 = (TYPE_PRECISION (TREE_TYPE (op
))
8183 - TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op
, 0))));
8185 /* Truncations are many-one so cannot be removed. */
8189 /* See what's inside this conversion. If we decide to strip it,
8194 op
= TREE_OPERAND (op
, 0);
8195 /* An extension: the outermost one can be stripped,
8196 but remember whether it is zero or sign extension. */
8198 uns
= TYPE_UNSIGNED (TREE_TYPE (op
));
8199 /* Otherwise, if a sign extension has been stripped,
8200 only sign extensions can now be stripped;
8201 if a zero extension has been stripped, only zero-extensions. */
8202 else if (uns
!= TYPE_UNSIGNED (TREE_TYPE (op
)))
8206 else /* bitschange == 0 */
8208 /* A change in nominal type can always be stripped, but we must
8209 preserve the unsignedness. */
8211 uns
= TYPE_UNSIGNED (TREE_TYPE (op
));
8213 op
= TREE_OPERAND (op
, 0);
8214 /* Keep trying to narrow, but don't assign op to win if it
8215 would turn an integral type into something else. */
8216 if (INTEGRAL_TYPE_P (TREE_TYPE (op
)) != integral_p
)
8223 if (TREE_CODE (op
) == COMPONENT_REF
8224 /* Since type_for_size always gives an integer type. */
8225 && TREE_CODE (TREE_TYPE (op
)) != REAL_TYPE
8226 && TREE_CODE (TREE_TYPE (op
)) != FIXED_POINT_TYPE
8227 /* Ensure field is laid out already. */
8228 && DECL_SIZE (TREE_OPERAND (op
, 1)) != 0
8229 && host_integerp (DECL_SIZE (TREE_OPERAND (op
, 1)), 1))
8231 unsigned HOST_WIDE_INT innerprec
8232 = tree_low_cst (DECL_SIZE (TREE_OPERAND (op
, 1)), 1);
8233 int unsignedp
= (DECL_UNSIGNED (TREE_OPERAND (op
, 1))
8234 || TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op
, 1))));
8235 tree type
= lang_hooks
.types
.type_for_size (innerprec
, unsignedp
);
8237 /* We can get this structure field in a narrower type that fits it,
8238 but the resulting extension to its nominal type (a fullword type)
8239 must satisfy the same conditions as for other extensions.
8241 Do this only for fields that are aligned (not bit-fields),
8242 because when bit-field insns will be used there is no
8243 advantage in doing this. */
8245 if (innerprec
< TYPE_PRECISION (TREE_TYPE (op
))
8246 && ! DECL_BIT_FIELD (TREE_OPERAND (op
, 1))
8247 && (first
|| uns
== DECL_UNSIGNED (TREE_OPERAND (op
, 1)))
8251 uns
= DECL_UNSIGNED (TREE_OPERAND (op
, 1));
8252 win
= fold_convert (type
, op
);
8256 *unsignedp_ptr
= uns
;
8260 /* Returns true if integer constant C has a value that is permissible
8261 for type TYPE (an INTEGER_TYPE). */
8264 int_fits_type_p (const_tree c
, const_tree type
)
8266 tree type_low_bound
, type_high_bound
;
8267 bool ok_for_low_bound
, ok_for_high_bound
, unsc
;
8270 dc
= tree_to_double_int (c
);
8271 unsc
= TYPE_UNSIGNED (TREE_TYPE (c
));
8273 if (TREE_CODE (TREE_TYPE (c
)) == INTEGER_TYPE
8274 && TYPE_IS_SIZETYPE (TREE_TYPE (c
))
8276 /* So c is an unsigned integer whose type is sizetype and type is not.
8277 sizetype'd integers are sign extended even though they are
8278 unsigned. If the integer value fits in the lower end word of c,
8279 and if the higher end word has all its bits set to 1, that
8280 means the higher end bits are set to 1 only for sign extension.
8281 So let's convert c into an equivalent zero extended unsigned
8283 dc
= double_int_zext (dc
, TYPE_PRECISION (TREE_TYPE (c
)));
8286 type_low_bound
= TYPE_MIN_VALUE (type
);
8287 type_high_bound
= TYPE_MAX_VALUE (type
);
8289 /* If at least one bound of the type is a constant integer, we can check
8290 ourselves and maybe make a decision. If no such decision is possible, but
8291 this type is a subtype, try checking against that. Otherwise, use
8292 double_int_fits_to_tree_p, which checks against the precision.
8294 Compute the status for each possibly constant bound, and return if we see
8295 one does not match. Use ok_for_xxx_bound for this purpose, assigning -1
8296 for "unknown if constant fits", 0 for "constant known *not* to fit" and 1
8297 for "constant known to fit". */
8299 /* Check if c >= type_low_bound. */
8300 if (type_low_bound
&& TREE_CODE (type_low_bound
) == INTEGER_CST
)
8302 dd
= tree_to_double_int (type_low_bound
);
8303 if (TREE_CODE (type
) == INTEGER_TYPE
8304 && TYPE_IS_SIZETYPE (type
)
8305 && TYPE_UNSIGNED (type
))
8306 dd
= double_int_zext (dd
, TYPE_PRECISION (type
));
8307 if (unsc
!= TYPE_UNSIGNED (TREE_TYPE (type_low_bound
)))
8309 int c_neg
= (!unsc
&& double_int_negative_p (dc
));
8310 int t_neg
= (unsc
&& double_int_negative_p (dd
));
8312 if (c_neg
&& !t_neg
)
8314 if ((c_neg
|| !t_neg
) && double_int_ucmp (dc
, dd
) < 0)
8317 else if (double_int_cmp (dc
, dd
, unsc
) < 0)
8319 ok_for_low_bound
= true;
8322 ok_for_low_bound
= false;
8324 /* Check if c <= type_high_bound. */
8325 if (type_high_bound
&& TREE_CODE (type_high_bound
) == INTEGER_CST
)
8327 dd
= tree_to_double_int (type_high_bound
);
8328 if (TREE_CODE (type
) == INTEGER_TYPE
8329 && TYPE_IS_SIZETYPE (type
)
8330 && TYPE_UNSIGNED (type
))
8331 dd
= double_int_zext (dd
, TYPE_PRECISION (type
));
8332 if (unsc
!= TYPE_UNSIGNED (TREE_TYPE (type_high_bound
)))
8334 int c_neg
= (!unsc
&& double_int_negative_p (dc
));
8335 int t_neg
= (unsc
&& double_int_negative_p (dd
));
8337 if (t_neg
&& !c_neg
)
8339 if ((t_neg
|| !c_neg
) && double_int_ucmp (dc
, dd
) > 0)
8342 else if (double_int_cmp (dc
, dd
, unsc
) > 0)
8344 ok_for_high_bound
= true;
8347 ok_for_high_bound
= false;
8349 /* If the constant fits both bounds, the result is known. */
8350 if (ok_for_low_bound
&& ok_for_high_bound
)
8353 /* Perform some generic filtering which may allow making a decision
8354 even if the bounds are not constant. First, negative integers
8355 never fit in unsigned types, */
8356 if (TYPE_UNSIGNED (type
) && !unsc
&& double_int_negative_p (dc
))
8359 /* Second, narrower types always fit in wider ones. */
8360 if (TYPE_PRECISION (type
) > TYPE_PRECISION (TREE_TYPE (c
)))
8363 /* Third, unsigned integers with top bit set never fit signed types. */
8364 if (! TYPE_UNSIGNED (type
) && unsc
)
8366 int prec
= GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (c
))) - 1;
8367 if (prec
< HOST_BITS_PER_WIDE_INT
)
8369 if (((((unsigned HOST_WIDE_INT
) 1) << prec
) & dc
.low
) != 0)
8372 else if (((((unsigned HOST_WIDE_INT
) 1)
8373 << (prec
- HOST_BITS_PER_WIDE_INT
)) & dc
.high
) != 0)
8377 /* If we haven't been able to decide at this point, there nothing more we
8378 can check ourselves here. Look at the base type if we have one and it
8379 has the same precision. */
8380 if (TREE_CODE (type
) == INTEGER_TYPE
8381 && TREE_TYPE (type
) != 0
8382 && TYPE_PRECISION (type
) == TYPE_PRECISION (TREE_TYPE (type
)))
8384 type
= TREE_TYPE (type
);
8388 /* Or to double_int_fits_to_tree_p, if nothing else. */
8389 return double_int_fits_to_tree_p (type
, dc
);
8392 /* Stores bounds of an integer TYPE in MIN and MAX. If TYPE has non-constant
8393 bounds or is a POINTER_TYPE, the maximum and/or minimum values that can be
8394 represented (assuming two's-complement arithmetic) within the bit
8395 precision of the type are returned instead. */
8398 get_type_static_bounds (const_tree type
, mpz_t min
, mpz_t max
)
8400 if (!POINTER_TYPE_P (type
) && TYPE_MIN_VALUE (type
)
8401 && TREE_CODE (TYPE_MIN_VALUE (type
)) == INTEGER_CST
)
8402 mpz_set_double_int (min
, tree_to_double_int (TYPE_MIN_VALUE (type
)),
8403 TYPE_UNSIGNED (type
));
8406 if (TYPE_UNSIGNED (type
))
8407 mpz_set_ui (min
, 0);
8411 mn
= double_int_mask (TYPE_PRECISION (type
) - 1);
8412 mn
= double_int_sext (double_int_add (mn
, double_int_one
),
8413 TYPE_PRECISION (type
));
8414 mpz_set_double_int (min
, mn
, false);
8418 if (!POINTER_TYPE_P (type
) && TYPE_MAX_VALUE (type
)
8419 && TREE_CODE (TYPE_MAX_VALUE (type
)) == INTEGER_CST
)
8420 mpz_set_double_int (max
, tree_to_double_int (TYPE_MAX_VALUE (type
)),
8421 TYPE_UNSIGNED (type
));
8424 if (TYPE_UNSIGNED (type
))
8425 mpz_set_double_int (max
, double_int_mask (TYPE_PRECISION (type
)),
8428 mpz_set_double_int (max
, double_int_mask (TYPE_PRECISION (type
) - 1),
8433 /* Return true if VAR is an automatic variable defined in function FN. */
8436 auto_var_in_fn_p (const_tree var
, const_tree fn
)
8438 return (DECL_P (var
) && DECL_CONTEXT (var
) == fn
8439 && ((((TREE_CODE (var
) == VAR_DECL
&& ! DECL_EXTERNAL (var
))
8440 || TREE_CODE (var
) == PARM_DECL
)
8441 && ! TREE_STATIC (var
))
8442 || TREE_CODE (var
) == LABEL_DECL
8443 || TREE_CODE (var
) == RESULT_DECL
));
8446 /* Subprogram of following function. Called by walk_tree.
8448 Return *TP if it is an automatic variable or parameter of the
8449 function passed in as DATA. */
8452 find_var_from_fn (tree
*tp
, int *walk_subtrees
, void *data
)
8454 tree fn
= (tree
) data
;
8459 else if (DECL_P (*tp
)
8460 && auto_var_in_fn_p (*tp
, fn
))
8466 /* Returns true if T is, contains, or refers to a type with variable
8467 size. For METHOD_TYPEs and FUNCTION_TYPEs we exclude the
8468 arguments, but not the return type. If FN is nonzero, only return
8469 true if a modifier of the type or position of FN is a variable or
8470 parameter inside FN.
8472 This concept is more general than that of C99 'variably modified types':
8473 in C99, a struct type is never variably modified because a VLA may not
8474 appear as a structure member. However, in GNU C code like:
8476 struct S { int i[f()]; };
8478 is valid, and other languages may define similar constructs. */
8481 variably_modified_type_p (tree type
, tree fn
)
8485 /* Test if T is either variable (if FN is zero) or an expression containing
8486 a variable in FN. */
8487 #define RETURN_TRUE_IF_VAR(T) \
8488 do { tree _t = (T); \
8489 if (_t && _t != error_mark_node && TREE_CODE (_t) != INTEGER_CST \
8490 && (!fn || walk_tree (&_t, find_var_from_fn, fn, NULL))) \
8491 return true; } while (0)
8493 if (type
== error_mark_node
)
8496 /* If TYPE itself has variable size, it is variably modified. */
8497 RETURN_TRUE_IF_VAR (TYPE_SIZE (type
));
8498 RETURN_TRUE_IF_VAR (TYPE_SIZE_UNIT (type
));
8500 switch (TREE_CODE (type
))
8503 case REFERENCE_TYPE
:
8505 if (variably_modified_type_p (TREE_TYPE (type
), fn
))
8511 /* If TYPE is a function type, it is variably modified if the
8512 return type is variably modified. */
8513 if (variably_modified_type_p (TREE_TYPE (type
), fn
))
8519 case FIXED_POINT_TYPE
:
8522 /* Scalar types are variably modified if their end points
8524 RETURN_TRUE_IF_VAR (TYPE_MIN_VALUE (type
));
8525 RETURN_TRUE_IF_VAR (TYPE_MAX_VALUE (type
));
8530 case QUAL_UNION_TYPE
:
8531 /* We can't see if any of the fields are variably-modified by the
8532 definition we normally use, since that would produce infinite
8533 recursion via pointers. */
8534 /* This is variably modified if some field's type is. */
8535 for (t
= TYPE_FIELDS (type
); t
; t
= DECL_CHAIN (t
))
8536 if (TREE_CODE (t
) == FIELD_DECL
)
8538 RETURN_TRUE_IF_VAR (DECL_FIELD_OFFSET (t
));
8539 RETURN_TRUE_IF_VAR (DECL_SIZE (t
));
8540 RETURN_TRUE_IF_VAR (DECL_SIZE_UNIT (t
));
8542 if (TREE_CODE (type
) == QUAL_UNION_TYPE
)
8543 RETURN_TRUE_IF_VAR (DECL_QUALIFIER (t
));
8548 /* Do not call ourselves to avoid infinite recursion. This is
8549 variably modified if the element type is. */
8550 RETURN_TRUE_IF_VAR (TYPE_SIZE (TREE_TYPE (type
)));
8551 RETURN_TRUE_IF_VAR (TYPE_SIZE_UNIT (TREE_TYPE (type
)));
8558 /* The current language may have other cases to check, but in general,
8559 all other types are not variably modified. */
8560 return lang_hooks
.tree_inlining
.var_mod_type_p (type
, fn
);
8562 #undef RETURN_TRUE_IF_VAR
8565 /* Given a DECL or TYPE, return the scope in which it was declared, or
8566 NULL_TREE if there is no containing scope. */
8569 get_containing_scope (const_tree t
)
8571 return (TYPE_P (t
) ? TYPE_CONTEXT (t
) : DECL_CONTEXT (t
));
8574 /* Return the innermost context enclosing DECL that is
8575 a FUNCTION_DECL, or zero if none. */
8578 decl_function_context (const_tree decl
)
8582 if (TREE_CODE (decl
) == ERROR_MARK
)
8585 /* C++ virtual functions use DECL_CONTEXT for the class of the vtable
8586 where we look up the function at runtime. Such functions always take
8587 a first argument of type 'pointer to real context'.
8589 C++ should really be fixed to use DECL_CONTEXT for the real context,
8590 and use something else for the "virtual context". */
8591 else if (TREE_CODE (decl
) == FUNCTION_DECL
&& DECL_VINDEX (decl
))
8594 (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl
)))));
8596 context
= DECL_CONTEXT (decl
);
8598 while (context
&& TREE_CODE (context
) != FUNCTION_DECL
)
8600 if (TREE_CODE (context
) == BLOCK
)
8601 context
= BLOCK_SUPERCONTEXT (context
);
8603 context
= get_containing_scope (context
);
8609 /* Return the innermost context enclosing DECL that is
8610 a RECORD_TYPE, UNION_TYPE or QUAL_UNION_TYPE, or zero if none.
8611 TYPE_DECLs and FUNCTION_DECLs are transparent to this function. */
8614 decl_type_context (const_tree decl
)
8616 tree context
= DECL_CONTEXT (decl
);
8619 switch (TREE_CODE (context
))
8621 case NAMESPACE_DECL
:
8622 case TRANSLATION_UNIT_DECL
:
8627 case QUAL_UNION_TYPE
:
8632 context
= DECL_CONTEXT (context
);
8636 context
= BLOCK_SUPERCONTEXT (context
);
8646 /* CALL is a CALL_EXPR. Return the declaration for the function
8647 called, or NULL_TREE if the called function cannot be
8651 get_callee_fndecl (const_tree call
)
8655 if (call
== error_mark_node
)
8656 return error_mark_node
;
8658 /* It's invalid to call this function with anything but a
8660 gcc_assert (TREE_CODE (call
) == CALL_EXPR
);
8662 /* The first operand to the CALL is the address of the function
8664 addr
= CALL_EXPR_FN (call
);
8668 /* If this is a readonly function pointer, extract its initial value. */
8669 if (DECL_P (addr
) && TREE_CODE (addr
) != FUNCTION_DECL
8670 && TREE_READONLY (addr
) && ! TREE_THIS_VOLATILE (addr
)
8671 && DECL_INITIAL (addr
))
8672 addr
= DECL_INITIAL (addr
);
8674 /* If the address is just `&f' for some function `f', then we know
8675 that `f' is being called. */
8676 if (TREE_CODE (addr
) == ADDR_EXPR
8677 && TREE_CODE (TREE_OPERAND (addr
, 0)) == FUNCTION_DECL
)
8678 return TREE_OPERAND (addr
, 0);
8680 /* We couldn't figure out what was being called. */
8684 /* Print debugging information about tree nodes generated during the compile,
8685 and any language-specific information. */
8688 dump_tree_statistics (void)
8690 #ifdef GATHER_STATISTICS
8692 int total_nodes
, total_bytes
;
8695 fprintf (stderr
, "\n??? tree nodes created\n\n");
8696 #ifdef GATHER_STATISTICS
8697 fprintf (stderr
, "Kind Nodes Bytes\n");
8698 fprintf (stderr
, "---------------------------------------\n");
8699 total_nodes
= total_bytes
= 0;
8700 for (i
= 0; i
< (int) all_kinds
; i
++)
8702 fprintf (stderr
, "%-20s %7d %10d\n", tree_node_kind_names
[i
],
8703 tree_node_counts
[i
], tree_node_sizes
[i
]);
8704 total_nodes
+= tree_node_counts
[i
];
8705 total_bytes
+= tree_node_sizes
[i
];
8707 fprintf (stderr
, "---------------------------------------\n");
8708 fprintf (stderr
, "%-20s %7d %10d\n", "Total", total_nodes
, total_bytes
);
8709 fprintf (stderr
, "---------------------------------------\n");
8710 fprintf (stderr
, "Code Nodes\n");
8711 fprintf (stderr
, "----------------------------\n");
8712 for (i
= 0; i
< (int) MAX_TREE_CODES
; i
++)
8713 fprintf (stderr
, "%-20s %7d\n", tree_code_name
[i
], tree_code_counts
[i
]);
8714 fprintf (stderr
, "----------------------------\n");
8715 ssanames_print_statistics ();
8716 phinodes_print_statistics ();
8718 fprintf (stderr
, "(No per-node statistics)\n");
8720 print_type_hash_statistics ();
8721 print_debug_expr_statistics ();
8722 print_value_expr_statistics ();
8723 lang_hooks
.print_statistics ();
8726 #define FILE_FUNCTION_FORMAT "_GLOBAL__%s_%s"
8728 /* Generate a crc32 of a byte. */
8731 crc32_byte (unsigned chksum
, char byte
)
8733 unsigned value
= (unsigned) byte
<< 24;
8736 for (ix
= 8; ix
--; value
<<= 1)
8740 feedback
= (value
^ chksum
) & 0x80000000 ? 0x04c11db7 : 0;
8748 /* Generate a crc32 of a string. */
8751 crc32_string (unsigned chksum
, const char *string
)
8755 chksum
= crc32_byte (chksum
, *string
);
8761 /* P is a string that will be used in a symbol. Mask out any characters
8762 that are not valid in that context. */
8765 clean_symbol_name (char *p
)
8769 #ifndef NO_DOLLAR_IN_LABEL /* this for `$'; unlikely, but... -- kr */
8772 #ifndef NO_DOT_IN_LABEL /* this for `.'; unlikely, but... */
8779 /* Generate a name for a special-purpose function.
8780 The generated name may need to be unique across the whole link.
8781 Changes to this function may also require corresponding changes to
8782 xstrdup_mask_random.
8783 TYPE is some string to identify the purpose of this function to the
8784 linker or collect2; it must start with an uppercase letter,
8786 I - for constructors
8788 N - for C++ anonymous namespaces
8789 F - for DWARF unwind frame information. */
8792 get_file_function_name (const char *type
)
8798 /* If we already have a name we know to be unique, just use that. */
8799 if (first_global_object_name
)
8800 p
= q
= ASTRDUP (first_global_object_name
);
8801 /* If the target is handling the constructors/destructors, they
8802 will be local to this file and the name is only necessary for
8804 We also assign sub_I and sub_D sufixes to constructors called from
8805 the global static constructors. These are always local. */
8806 else if (((type
[0] == 'I' || type
[0] == 'D') && targetm
.have_ctors_dtors
)
8807 || (strncmp (type
, "sub_", 4) == 0
8808 && (type
[4] == 'I' || type
[4] == 'D')))
8810 const char *file
= main_input_filename
;
8812 file
= input_filename
;
8813 /* Just use the file's basename, because the full pathname
8814 might be quite long. */
8815 p
= q
= ASTRDUP (lbasename (file
));
8819 /* Otherwise, the name must be unique across the entire link.
8820 We don't have anything that we know to be unique to this translation
8821 unit, so use what we do have and throw in some randomness. */
8823 const char *name
= weak_global_object_name
;
8824 const char *file
= main_input_filename
;
8829 file
= input_filename
;
8831 len
= strlen (file
);
8832 q
= (char *) alloca (9 + 17 + len
+ 1);
8833 memcpy (q
, file
, len
+ 1);
8835 snprintf (q
+ len
, 9 + 17 + 1, "_%08X_" HOST_WIDE_INT_PRINT_HEX
,
8836 crc32_string (0, name
), get_random_seed (false));
8841 clean_symbol_name (q
);
8842 buf
= (char *) alloca (sizeof (FILE_FUNCTION_FORMAT
) + strlen (p
)
8845 /* Set up the name of the file-level functions we may need.
8846 Use a global object (which is already required to be unique over
8847 the program) rather than the file name (which imposes extra
8849 sprintf (buf
, FILE_FUNCTION_FORMAT
, type
, p
);
8851 return get_identifier (buf
);
8854 #if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
8856 /* Complain that the tree code of NODE does not match the expected 0
8857 terminated list of trailing codes. The trailing code list can be
8858 empty, for a more vague error message. FILE, LINE, and FUNCTION
8859 are of the caller. */
8862 tree_check_failed (const_tree node
, const char *file
,
8863 int line
, const char *function
, ...)
8867 unsigned length
= 0;
8870 va_start (args
, function
);
8871 while ((code
= va_arg (args
, int)))
8872 length
+= 4 + strlen (tree_code_name
[code
]);
8877 va_start (args
, function
);
8878 length
+= strlen ("expected ");
8879 buffer
= tmp
= (char *) alloca (length
);
8881 while ((code
= va_arg (args
, int)))
8883 const char *prefix
= length
? " or " : "expected ";
8885 strcpy (tmp
+ length
, prefix
);
8886 length
+= strlen (prefix
);
8887 strcpy (tmp
+ length
, tree_code_name
[code
]);
8888 length
+= strlen (tree_code_name
[code
]);
8893 buffer
= "unexpected node";
8895 internal_error ("tree check: %s, have %s in %s, at %s:%d",
8896 buffer
, tree_code_name
[TREE_CODE (node
)],
8897 function
, trim_filename (file
), line
);
8900 /* Complain that the tree code of NODE does match the expected 0
8901 terminated list of trailing codes. FILE, LINE, and FUNCTION are of
8905 tree_not_check_failed (const_tree node
, const char *file
,
8906 int line
, const char *function
, ...)
8910 unsigned length
= 0;
8913 va_start (args
, function
);
8914 while ((code
= va_arg (args
, int)))
8915 length
+= 4 + strlen (tree_code_name
[code
]);
8917 va_start (args
, function
);
8918 buffer
= (char *) alloca (length
);
8920 while ((code
= va_arg (args
, int)))
8924 strcpy (buffer
+ length
, " or ");
8927 strcpy (buffer
+ length
, tree_code_name
[code
]);
8928 length
+= strlen (tree_code_name
[code
]);
8932 internal_error ("tree check: expected none of %s, have %s in %s, at %s:%d",
8933 buffer
, tree_code_name
[TREE_CODE (node
)],
8934 function
, trim_filename (file
), line
);
8937 /* Similar to tree_check_failed, except that we check for a class of tree
8938 code, given in CL. */
8941 tree_class_check_failed (const_tree node
, const enum tree_code_class cl
,
8942 const char *file
, int line
, const char *function
)
8945 ("tree check: expected class %qs, have %qs (%s) in %s, at %s:%d",
8946 TREE_CODE_CLASS_STRING (cl
),
8947 TREE_CODE_CLASS_STRING (TREE_CODE_CLASS (TREE_CODE (node
))),
8948 tree_code_name
[TREE_CODE (node
)], function
, trim_filename (file
), line
);
8951 /* Similar to tree_check_failed, except that instead of specifying a
8952 dozen codes, use the knowledge that they're all sequential. */
8955 tree_range_check_failed (const_tree node
, const char *file
, int line
,
8956 const char *function
, enum tree_code c1
,
8960 unsigned length
= 0;
8963 for (c
= c1
; c
<= c2
; ++c
)
8964 length
+= 4 + strlen (tree_code_name
[c
]);
8966 length
+= strlen ("expected ");
8967 buffer
= (char *) alloca (length
);
8970 for (c
= c1
; c
<= c2
; ++c
)
8972 const char *prefix
= length
? " or " : "expected ";
8974 strcpy (buffer
+ length
, prefix
);
8975 length
+= strlen (prefix
);
8976 strcpy (buffer
+ length
, tree_code_name
[c
]);
8977 length
+= strlen (tree_code_name
[c
]);
8980 internal_error ("tree check: %s, have %s in %s, at %s:%d",
8981 buffer
, tree_code_name
[TREE_CODE (node
)],
8982 function
, trim_filename (file
), line
);
8986 /* Similar to tree_check_failed, except that we check that a tree does
8987 not have the specified code, given in CL. */
8990 tree_not_class_check_failed (const_tree node
, const enum tree_code_class cl
,
8991 const char *file
, int line
, const char *function
)
8994 ("tree check: did not expect class %qs, have %qs (%s) in %s, at %s:%d",
8995 TREE_CODE_CLASS_STRING (cl
),
8996 TREE_CODE_CLASS_STRING (TREE_CODE_CLASS (TREE_CODE (node
))),
8997 tree_code_name
[TREE_CODE (node
)], function
, trim_filename (file
), line
);
9001 /* Similar to tree_check_failed but applied to OMP_CLAUSE codes. */
9004 omp_clause_check_failed (const_tree node
, const char *file
, int line
,
9005 const char *function
, enum omp_clause_code code
)
9007 internal_error ("tree check: expected omp_clause %s, have %s in %s, at %s:%d",
9008 omp_clause_code_name
[code
], tree_code_name
[TREE_CODE (node
)],
9009 function
, trim_filename (file
), line
);
9013 /* Similar to tree_range_check_failed but applied to OMP_CLAUSE codes. */
9016 omp_clause_range_check_failed (const_tree node
, const char *file
, int line
,
9017 const char *function
, enum omp_clause_code c1
,
9018 enum omp_clause_code c2
)
9021 unsigned length
= 0;
9024 for (c
= c1
; c
<= c2
; ++c
)
9025 length
+= 4 + strlen (omp_clause_code_name
[c
]);
9027 length
+= strlen ("expected ");
9028 buffer
= (char *) alloca (length
);
9031 for (c
= c1
; c
<= c2
; ++c
)
9033 const char *prefix
= length
? " or " : "expected ";
9035 strcpy (buffer
+ length
, prefix
);
9036 length
+= strlen (prefix
);
9037 strcpy (buffer
+ length
, omp_clause_code_name
[c
]);
9038 length
+= strlen (omp_clause_code_name
[c
]);
9041 internal_error ("tree check: %s, have %s in %s, at %s:%d",
9042 buffer
, omp_clause_code_name
[TREE_CODE (node
)],
9043 function
, trim_filename (file
), line
);
9047 #undef DEFTREESTRUCT
9048 #define DEFTREESTRUCT(VAL, NAME) NAME,
9050 static const char *ts_enum_names
[] = {
9051 #include "treestruct.def"
9053 #undef DEFTREESTRUCT
9055 #define TS_ENUM_NAME(EN) (ts_enum_names[(EN)])
9057 /* Similar to tree_class_check_failed, except that we check for
9058 whether CODE contains the tree structure identified by EN. */
9061 tree_contains_struct_check_failed (const_tree node
,
9062 const enum tree_node_structure_enum en
,
9063 const char *file
, int line
,
9064 const char *function
)
9067 ("tree check: expected tree that contains %qs structure, have %qs in %s, at %s:%d",
9069 tree_code_name
[TREE_CODE (node
)], function
, trim_filename (file
), line
);
9073 /* Similar to above, except that the check is for the bounds of a TREE_VEC's
9074 (dynamically sized) vector. */
9077 tree_vec_elt_check_failed (int idx
, int len
, const char *file
, int line
,
9078 const char *function
)
9081 ("tree check: accessed elt %d of tree_vec with %d elts in %s, at %s:%d",
9082 idx
+ 1, len
, function
, trim_filename (file
), line
);
9085 /* Similar to above, except that the check is for the bounds of the operand
9086 vector of an expression node EXP. */
9089 tree_operand_check_failed (int idx
, const_tree exp
, const char *file
,
9090 int line
, const char *function
)
9092 int code
= TREE_CODE (exp
);
9094 ("tree check: accessed operand %d of %s with %d operands in %s, at %s:%d",
9095 idx
+ 1, tree_code_name
[code
], TREE_OPERAND_LENGTH (exp
),
9096 function
, trim_filename (file
), line
);
9099 /* Similar to above, except that the check is for the number of
9100 operands of an OMP_CLAUSE node. */
9103 omp_clause_operand_check_failed (int idx
, const_tree t
, const char *file
,
9104 int line
, const char *function
)
9107 ("tree check: accessed operand %d of omp_clause %s with %d operands "
9108 "in %s, at %s:%d", idx
+ 1, omp_clause_code_name
[OMP_CLAUSE_CODE (t
)],
9109 omp_clause_num_ops
[OMP_CLAUSE_CODE (t
)], function
,
9110 trim_filename (file
), line
);
9112 #endif /* ENABLE_TREE_CHECKING */
9114 /* Create a new vector type node holding SUBPARTS units of type INNERTYPE,
9115 and mapped to the machine mode MODE. Initialize its fields and build
9116 the information necessary for debugging output. */
9119 make_vector_type (tree innertype
, int nunits
, enum machine_mode mode
)
9122 hashval_t hashcode
= 0;
9124 t
= make_node (VECTOR_TYPE
);
9125 TREE_TYPE (t
) = TYPE_MAIN_VARIANT (innertype
);
9126 SET_TYPE_VECTOR_SUBPARTS (t
, nunits
);
9127 SET_TYPE_MODE (t
, mode
);
9129 if (TYPE_STRUCTURAL_EQUALITY_P (innertype
))
9130 SET_TYPE_STRUCTURAL_EQUALITY (t
);
9131 else if (TYPE_CANONICAL (innertype
) != innertype
9132 || mode
!= VOIDmode
)
9134 = make_vector_type (TYPE_CANONICAL (innertype
), nunits
, VOIDmode
);
9138 hashcode
= iterative_hash_host_wide_int (VECTOR_TYPE
, hashcode
);
9139 hashcode
= iterative_hash_host_wide_int (nunits
, hashcode
);
9140 hashcode
= iterative_hash_host_wide_int (mode
, hashcode
);
9141 hashcode
= iterative_hash_object (TYPE_HASH (TREE_TYPE (t
)), hashcode
);
9142 t
= type_hash_canon (hashcode
, t
);
9144 /* We have built a main variant, based on the main variant of the
9145 inner type. Use it to build the variant we return. */
9146 if ((TYPE_ATTRIBUTES (innertype
) || TYPE_QUALS (innertype
))
9147 && TREE_TYPE (t
) != innertype
)
9148 return build_type_attribute_qual_variant (t
,
9149 TYPE_ATTRIBUTES (innertype
),
9150 TYPE_QUALS (innertype
));
9156 make_or_reuse_type (unsigned size
, int unsignedp
)
9158 if (size
== INT_TYPE_SIZE
)
9159 return unsignedp
? unsigned_type_node
: integer_type_node
;
9160 if (size
== CHAR_TYPE_SIZE
)
9161 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
9162 if (size
== SHORT_TYPE_SIZE
)
9163 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
9164 if (size
== LONG_TYPE_SIZE
)
9165 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
9166 if (size
== LONG_LONG_TYPE_SIZE
)
9167 return (unsignedp
? long_long_unsigned_type_node
9168 : long_long_integer_type_node
);
9169 if (size
== 128 && int128_integer_type_node
)
9170 return (unsignedp
? int128_unsigned_type_node
9171 : int128_integer_type_node
);
9174 return make_unsigned_type (size
);
9176 return make_signed_type (size
);
9179 /* Create or reuse a fract type by SIZE, UNSIGNEDP, and SATP. */
9182 make_or_reuse_fract_type (unsigned size
, int unsignedp
, int satp
)
9186 if (size
== SHORT_FRACT_TYPE_SIZE
)
9187 return unsignedp
? sat_unsigned_short_fract_type_node
9188 : sat_short_fract_type_node
;
9189 if (size
== FRACT_TYPE_SIZE
)
9190 return unsignedp
? sat_unsigned_fract_type_node
: sat_fract_type_node
;
9191 if (size
== LONG_FRACT_TYPE_SIZE
)
9192 return unsignedp
? sat_unsigned_long_fract_type_node
9193 : sat_long_fract_type_node
;
9194 if (size
== LONG_LONG_FRACT_TYPE_SIZE
)
9195 return unsignedp
? sat_unsigned_long_long_fract_type_node
9196 : sat_long_long_fract_type_node
;
9200 if (size
== SHORT_FRACT_TYPE_SIZE
)
9201 return unsignedp
? unsigned_short_fract_type_node
9202 : short_fract_type_node
;
9203 if (size
== FRACT_TYPE_SIZE
)
9204 return unsignedp
? unsigned_fract_type_node
: fract_type_node
;
9205 if (size
== LONG_FRACT_TYPE_SIZE
)
9206 return unsignedp
? unsigned_long_fract_type_node
9207 : long_fract_type_node
;
9208 if (size
== LONG_LONG_FRACT_TYPE_SIZE
)
9209 return unsignedp
? unsigned_long_long_fract_type_node
9210 : long_long_fract_type_node
;
9213 return make_fract_type (size
, unsignedp
, satp
);
9216 /* Create or reuse an accum type by SIZE, UNSIGNEDP, and SATP. */
9219 make_or_reuse_accum_type (unsigned size
, int unsignedp
, int satp
)
9223 if (size
== SHORT_ACCUM_TYPE_SIZE
)
9224 return unsignedp
? sat_unsigned_short_accum_type_node
9225 : sat_short_accum_type_node
;
9226 if (size
== ACCUM_TYPE_SIZE
)
9227 return unsignedp
? sat_unsigned_accum_type_node
: sat_accum_type_node
;
9228 if (size
== LONG_ACCUM_TYPE_SIZE
)
9229 return unsignedp
? sat_unsigned_long_accum_type_node
9230 : sat_long_accum_type_node
;
9231 if (size
== LONG_LONG_ACCUM_TYPE_SIZE
)
9232 return unsignedp
? sat_unsigned_long_long_accum_type_node
9233 : sat_long_long_accum_type_node
;
9237 if (size
== SHORT_ACCUM_TYPE_SIZE
)
9238 return unsignedp
? unsigned_short_accum_type_node
9239 : short_accum_type_node
;
9240 if (size
== ACCUM_TYPE_SIZE
)
9241 return unsignedp
? unsigned_accum_type_node
: accum_type_node
;
9242 if (size
== LONG_ACCUM_TYPE_SIZE
)
9243 return unsignedp
? unsigned_long_accum_type_node
9244 : long_accum_type_node
;
9245 if (size
== LONG_LONG_ACCUM_TYPE_SIZE
)
9246 return unsignedp
? unsigned_long_long_accum_type_node
9247 : long_long_accum_type_node
;
9250 return make_accum_type (size
, unsignedp
, satp
);
9253 /* Create nodes for all integer types (and error_mark_node) using the sizes
9254 of C datatypes. SIGNED_CHAR specifies whether char is signed,
9255 SHORT_DOUBLE specifies whether double should be of the same precision
9259 build_common_tree_nodes (bool signed_char
, bool short_double
)
9261 error_mark_node
= make_node (ERROR_MARK
);
9262 TREE_TYPE (error_mark_node
) = error_mark_node
;
9264 initialize_sizetypes ();
9266 /* Define both `signed char' and `unsigned char'. */
9267 signed_char_type_node
= make_signed_type (CHAR_TYPE_SIZE
);
9268 TYPE_STRING_FLAG (signed_char_type_node
) = 1;
9269 unsigned_char_type_node
= make_unsigned_type (CHAR_TYPE_SIZE
);
9270 TYPE_STRING_FLAG (unsigned_char_type_node
) = 1;
9272 /* Define `char', which is like either `signed char' or `unsigned char'
9273 but not the same as either. */
9276 ? make_signed_type (CHAR_TYPE_SIZE
)
9277 : make_unsigned_type (CHAR_TYPE_SIZE
));
9278 TYPE_STRING_FLAG (char_type_node
) = 1;
9280 short_integer_type_node
= make_signed_type (SHORT_TYPE_SIZE
);
9281 short_unsigned_type_node
= make_unsigned_type (SHORT_TYPE_SIZE
);
9282 integer_type_node
= make_signed_type (INT_TYPE_SIZE
);
9283 unsigned_type_node
= make_unsigned_type (INT_TYPE_SIZE
);
9284 long_integer_type_node
= make_signed_type (LONG_TYPE_SIZE
);
9285 long_unsigned_type_node
= make_unsigned_type (LONG_TYPE_SIZE
);
9286 long_long_integer_type_node
= make_signed_type (LONG_LONG_TYPE_SIZE
);
9287 long_long_unsigned_type_node
= make_unsigned_type (LONG_LONG_TYPE_SIZE
);
9288 #if HOST_BITS_PER_WIDE_INT >= 64
9289 /* TODO: This isn't correct, but as logic depends at the moment on
9290 host's instead of target's wide-integer.
9291 If there is a target not supporting TImode, but has an 128-bit
9292 integer-scalar register, this target check needs to be adjusted. */
9293 if (targetm
.scalar_mode_supported_p (TImode
))
9295 int128_integer_type_node
= make_signed_type (128);
9296 int128_unsigned_type_node
= make_unsigned_type (128);
9300 /* Define a boolean type. This type only represents boolean values but
9301 may be larger than char depending on the value of BOOL_TYPE_SIZE.
9302 Front ends which want to override this size (i.e. Java) can redefine
9303 boolean_type_node before calling build_common_tree_nodes_2. */
9304 boolean_type_node
= make_unsigned_type (BOOL_TYPE_SIZE
);
9305 TREE_SET_CODE (boolean_type_node
, BOOLEAN_TYPE
);
9306 TYPE_MAX_VALUE (boolean_type_node
) = build_int_cst (boolean_type_node
, 1);
9307 TYPE_PRECISION (boolean_type_node
) = 1;
9309 /* Define what type to use for size_t. */
9310 if (strcmp (SIZE_TYPE
, "unsigned int") == 0)
9311 size_type_node
= unsigned_type_node
;
9312 else if (strcmp (SIZE_TYPE
, "long unsigned int") == 0)
9313 size_type_node
= long_unsigned_type_node
;
9314 else if (strcmp (SIZE_TYPE
, "long long unsigned int") == 0)
9315 size_type_node
= long_long_unsigned_type_node
;
9316 else if (strcmp (SIZE_TYPE
, "short unsigned int") == 0)
9317 size_type_node
= short_unsigned_type_node
;
9321 /* Fill in the rest of the sized types. Reuse existing type nodes
9323 intQI_type_node
= make_or_reuse_type (GET_MODE_BITSIZE (QImode
), 0);
9324 intHI_type_node
= make_or_reuse_type (GET_MODE_BITSIZE (HImode
), 0);
9325 intSI_type_node
= make_or_reuse_type (GET_MODE_BITSIZE (SImode
), 0);
9326 intDI_type_node
= make_or_reuse_type (GET_MODE_BITSIZE (DImode
), 0);
9327 intTI_type_node
= make_or_reuse_type (GET_MODE_BITSIZE (TImode
), 0);
9329 unsigned_intQI_type_node
= make_or_reuse_type (GET_MODE_BITSIZE (QImode
), 1);
9330 unsigned_intHI_type_node
= make_or_reuse_type (GET_MODE_BITSIZE (HImode
), 1);
9331 unsigned_intSI_type_node
= make_or_reuse_type (GET_MODE_BITSIZE (SImode
), 1);
9332 unsigned_intDI_type_node
= make_or_reuse_type (GET_MODE_BITSIZE (DImode
), 1);
9333 unsigned_intTI_type_node
= make_or_reuse_type (GET_MODE_BITSIZE (TImode
), 1);
9335 access_public_node
= get_identifier ("public");
9336 access_protected_node
= get_identifier ("protected");
9337 access_private_node
= get_identifier ("private");
9339 /* Define these next since types below may used them. */
9340 integer_zero_node
= build_int_cst (integer_type_node
, 0);
9341 integer_one_node
= build_int_cst (integer_type_node
, 1);
9342 integer_three_node
= build_int_cst (integer_type_node
, 3);
9343 integer_minus_one_node
= build_int_cst (integer_type_node
, -1);
9345 size_zero_node
= size_int (0);
9346 size_one_node
= size_int (1);
9347 bitsize_zero_node
= bitsize_int (0);
9348 bitsize_one_node
= bitsize_int (1);
9349 bitsize_unit_node
= bitsize_int (BITS_PER_UNIT
);
9351 boolean_false_node
= TYPE_MIN_VALUE (boolean_type_node
);
9352 boolean_true_node
= TYPE_MAX_VALUE (boolean_type_node
);
9354 void_type_node
= make_node (VOID_TYPE
);
9355 layout_type (void_type_node
);
9357 /* We are not going to have real types in C with less than byte alignment,
9358 so we might as well not have any types that claim to have it. */
9359 TYPE_ALIGN (void_type_node
) = BITS_PER_UNIT
;
9360 TYPE_USER_ALIGN (void_type_node
) = 0;
9362 null_pointer_node
= build_int_cst (build_pointer_type (void_type_node
), 0);
9363 layout_type (TREE_TYPE (null_pointer_node
));
9365 ptr_type_node
= build_pointer_type (void_type_node
);
9367 = build_pointer_type (build_type_variant (void_type_node
, 1, 0));
9368 fileptr_type_node
= ptr_type_node
;
9370 float_type_node
= make_node (REAL_TYPE
);
9371 TYPE_PRECISION (float_type_node
) = FLOAT_TYPE_SIZE
;
9372 layout_type (float_type_node
);
9374 double_type_node
= make_node (REAL_TYPE
);
9376 TYPE_PRECISION (double_type_node
) = FLOAT_TYPE_SIZE
;
9378 TYPE_PRECISION (double_type_node
) = DOUBLE_TYPE_SIZE
;
9379 layout_type (double_type_node
);
9381 long_double_type_node
= make_node (REAL_TYPE
);
9382 TYPE_PRECISION (long_double_type_node
) = LONG_DOUBLE_TYPE_SIZE
;
9383 layout_type (long_double_type_node
);
9385 float_ptr_type_node
= build_pointer_type (float_type_node
);
9386 double_ptr_type_node
= build_pointer_type (double_type_node
);
9387 long_double_ptr_type_node
= build_pointer_type (long_double_type_node
);
9388 integer_ptr_type_node
= build_pointer_type (integer_type_node
);
9390 /* Fixed size integer types. */
9391 uint16_type_node
= build_nonstandard_integer_type (16, true);
9392 uint32_type_node
= build_nonstandard_integer_type (32, true);
9393 uint64_type_node
= build_nonstandard_integer_type (64, true);
9395 /* Decimal float types. */
9396 dfloat32_type_node
= make_node (REAL_TYPE
);
9397 TYPE_PRECISION (dfloat32_type_node
) = DECIMAL32_TYPE_SIZE
;
9398 layout_type (dfloat32_type_node
);
9399 SET_TYPE_MODE (dfloat32_type_node
, SDmode
);
9400 dfloat32_ptr_type_node
= build_pointer_type (dfloat32_type_node
);
9402 dfloat64_type_node
= make_node (REAL_TYPE
);
9403 TYPE_PRECISION (dfloat64_type_node
) = DECIMAL64_TYPE_SIZE
;
9404 layout_type (dfloat64_type_node
);
9405 SET_TYPE_MODE (dfloat64_type_node
, DDmode
);
9406 dfloat64_ptr_type_node
= build_pointer_type (dfloat64_type_node
);
9408 dfloat128_type_node
= make_node (REAL_TYPE
);
9409 TYPE_PRECISION (dfloat128_type_node
) = DECIMAL128_TYPE_SIZE
;
9410 layout_type (dfloat128_type_node
);
9411 SET_TYPE_MODE (dfloat128_type_node
, TDmode
);
9412 dfloat128_ptr_type_node
= build_pointer_type (dfloat128_type_node
);
9414 complex_integer_type_node
= build_complex_type (integer_type_node
);
9415 complex_float_type_node
= build_complex_type (float_type_node
);
9416 complex_double_type_node
= build_complex_type (double_type_node
);
9417 complex_long_double_type_node
= build_complex_type (long_double_type_node
);
9419 /* Make fixed-point nodes based on sat/non-sat and signed/unsigned. */
9420 #define MAKE_FIXED_TYPE_NODE(KIND,SIZE) \
9421 sat_ ## KIND ## _type_node = \
9422 make_sat_signed_ ## KIND ## _type (SIZE); \
9423 sat_unsigned_ ## KIND ## _type_node = \
9424 make_sat_unsigned_ ## KIND ## _type (SIZE); \
9425 KIND ## _type_node = make_signed_ ## KIND ## _type (SIZE); \
9426 unsigned_ ## KIND ## _type_node = \
9427 make_unsigned_ ## KIND ## _type (SIZE);
9429 #define MAKE_FIXED_TYPE_NODE_WIDTH(KIND,WIDTH,SIZE) \
9430 sat_ ## WIDTH ## KIND ## _type_node = \
9431 make_sat_signed_ ## KIND ## _type (SIZE); \
9432 sat_unsigned_ ## WIDTH ## KIND ## _type_node = \
9433 make_sat_unsigned_ ## KIND ## _type (SIZE); \
9434 WIDTH ## KIND ## _type_node = make_signed_ ## KIND ## _type (SIZE); \
9435 unsigned_ ## WIDTH ## KIND ## _type_node = \
9436 make_unsigned_ ## KIND ## _type (SIZE);
9438 /* Make fixed-point type nodes based on four different widths. */
9439 #define MAKE_FIXED_TYPE_NODE_FAMILY(N1,N2) \
9440 MAKE_FIXED_TYPE_NODE_WIDTH (N1, short_, SHORT_ ## N2 ## _TYPE_SIZE) \
9441 MAKE_FIXED_TYPE_NODE (N1, N2 ## _TYPE_SIZE) \
9442 MAKE_FIXED_TYPE_NODE_WIDTH (N1, long_, LONG_ ## N2 ## _TYPE_SIZE) \
9443 MAKE_FIXED_TYPE_NODE_WIDTH (N1, long_long_, LONG_LONG_ ## N2 ## _TYPE_SIZE)
9445 /* Make fixed-point mode nodes based on sat/non-sat and signed/unsigned. */
9446 #define MAKE_FIXED_MODE_NODE(KIND,NAME,MODE) \
9447 NAME ## _type_node = \
9448 make_or_reuse_signed_ ## KIND ## _type (GET_MODE_BITSIZE (MODE ## mode)); \
9449 u ## NAME ## _type_node = \
9450 make_or_reuse_unsigned_ ## KIND ## _type \
9451 (GET_MODE_BITSIZE (U ## MODE ## mode)); \
9452 sat_ ## NAME ## _type_node = \
9453 make_or_reuse_sat_signed_ ## KIND ## _type \
9454 (GET_MODE_BITSIZE (MODE ## mode)); \
9455 sat_u ## NAME ## _type_node = \
9456 make_or_reuse_sat_unsigned_ ## KIND ## _type \
9457 (GET_MODE_BITSIZE (U ## MODE ## mode));
9459 /* Fixed-point type and mode nodes. */
9460 MAKE_FIXED_TYPE_NODE_FAMILY (fract
, FRACT
)
9461 MAKE_FIXED_TYPE_NODE_FAMILY (accum
, ACCUM
)
9462 MAKE_FIXED_MODE_NODE (fract
, qq
, QQ
)
9463 MAKE_FIXED_MODE_NODE (fract
, hq
, HQ
)
9464 MAKE_FIXED_MODE_NODE (fract
, sq
, SQ
)
9465 MAKE_FIXED_MODE_NODE (fract
, dq
, DQ
)
9466 MAKE_FIXED_MODE_NODE (fract
, tq
, TQ
)
9467 MAKE_FIXED_MODE_NODE (accum
, ha
, HA
)
9468 MAKE_FIXED_MODE_NODE (accum
, sa
, SA
)
9469 MAKE_FIXED_MODE_NODE (accum
, da
, DA
)
9470 MAKE_FIXED_MODE_NODE (accum
, ta
, TA
)
9473 tree t
= targetm
.build_builtin_va_list ();
9475 /* Many back-ends define record types without setting TYPE_NAME.
9476 If we copied the record type here, we'd keep the original
9477 record type without a name. This breaks name mangling. So,
9478 don't copy record types and let c_common_nodes_and_builtins()
9479 declare the type to be __builtin_va_list. */
9480 if (TREE_CODE (t
) != RECORD_TYPE
)
9481 t
= build_variant_type_copy (t
);
9483 va_list_type_node
= t
;
9487 /* A subroutine of build_common_builtin_nodes. Define a builtin function. */
9490 local_define_builtin (const char *name
, tree type
, enum built_in_function code
,
9491 const char *library_name
, int ecf_flags
)
9495 decl
= add_builtin_function (name
, type
, code
, BUILT_IN_NORMAL
,
9496 library_name
, NULL_TREE
);
9497 if (ecf_flags
& ECF_CONST
)
9498 TREE_READONLY (decl
) = 1;
9499 if (ecf_flags
& ECF_PURE
)
9500 DECL_PURE_P (decl
) = 1;
9501 if (ecf_flags
& ECF_LOOPING_CONST_OR_PURE
)
9502 DECL_LOOPING_CONST_OR_PURE_P (decl
) = 1;
9503 if (ecf_flags
& ECF_NORETURN
)
9504 TREE_THIS_VOLATILE (decl
) = 1;
9505 if (ecf_flags
& ECF_NOTHROW
)
9506 TREE_NOTHROW (decl
) = 1;
9507 if (ecf_flags
& ECF_MALLOC
)
9508 DECL_IS_MALLOC (decl
) = 1;
9509 if (ecf_flags
& ECF_LEAF
)
9510 DECL_ATTRIBUTES (decl
) = tree_cons (get_identifier ("leaf"),
9511 NULL
, DECL_ATTRIBUTES (decl
));
9512 if ((ecf_flags
& ECF_TM_PURE
) && flag_tm
)
9513 apply_tm_attr (decl
, get_identifier ("transaction_pure"));
9515 set_builtin_decl (code
, decl
, true);
9518 /* Call this function after instantiating all builtins that the language
9519 front end cares about. This will build the rest of the builtins that
9520 are relied upon by the tree optimizers and the middle-end. */
9523 build_common_builtin_nodes (void)
9528 if (!builtin_decl_explicit_p (BUILT_IN_MEMCPY
)
9529 || !builtin_decl_explicit_p (BUILT_IN_MEMMOVE
))
9531 ftype
= build_function_type_list (ptr_type_node
,
9532 ptr_type_node
, const_ptr_type_node
,
9533 size_type_node
, NULL_TREE
);
9535 if (!builtin_decl_explicit_p (BUILT_IN_MEMCPY
))
9536 local_define_builtin ("__builtin_memcpy", ftype
, BUILT_IN_MEMCPY
,
9537 "memcpy", ECF_NOTHROW
| ECF_LEAF
);
9538 if (!builtin_decl_explicit_p (BUILT_IN_MEMMOVE
))
9539 local_define_builtin ("__builtin_memmove", ftype
, BUILT_IN_MEMMOVE
,
9540 "memmove", ECF_NOTHROW
| ECF_LEAF
);
9543 if (!builtin_decl_explicit_p (BUILT_IN_MEMCMP
))
9545 ftype
= build_function_type_list (integer_type_node
, const_ptr_type_node
,
9546 const_ptr_type_node
, size_type_node
,
9548 local_define_builtin ("__builtin_memcmp", ftype
, BUILT_IN_MEMCMP
,
9549 "memcmp", ECF_PURE
| ECF_NOTHROW
| ECF_LEAF
);
9552 if (!builtin_decl_explicit_p (BUILT_IN_MEMSET
))
9554 ftype
= build_function_type_list (ptr_type_node
,
9555 ptr_type_node
, integer_type_node
,
9556 size_type_node
, NULL_TREE
);
9557 local_define_builtin ("__builtin_memset", ftype
, BUILT_IN_MEMSET
,
9558 "memset", ECF_NOTHROW
| ECF_LEAF
);
9561 if (!builtin_decl_explicit_p (BUILT_IN_ALLOCA
))
9563 ftype
= build_function_type_list (ptr_type_node
,
9564 size_type_node
, NULL_TREE
);
9565 local_define_builtin ("__builtin_alloca", ftype
, BUILT_IN_ALLOCA
,
9566 "alloca", ECF_MALLOC
| ECF_NOTHROW
| ECF_LEAF
);
9569 ftype
= build_function_type_list (ptr_type_node
, size_type_node
,
9570 size_type_node
, NULL_TREE
);
9571 local_define_builtin ("__builtin_alloca_with_align", ftype
,
9572 BUILT_IN_ALLOCA_WITH_ALIGN
, "alloca",
9573 ECF_MALLOC
| ECF_NOTHROW
| ECF_LEAF
);
9575 /* If we're checking the stack, `alloca' can throw. */
9576 if (flag_stack_check
)
9578 TREE_NOTHROW (builtin_decl_explicit (BUILT_IN_ALLOCA
)) = 0;
9579 TREE_NOTHROW (builtin_decl_explicit (BUILT_IN_ALLOCA_WITH_ALIGN
)) = 0;
9582 ftype
= build_function_type_list (void_type_node
,
9583 ptr_type_node
, ptr_type_node
,
9584 ptr_type_node
, NULL_TREE
);
9585 local_define_builtin ("__builtin_init_trampoline", ftype
,
9586 BUILT_IN_INIT_TRAMPOLINE
,
9587 "__builtin_init_trampoline", ECF_NOTHROW
| ECF_LEAF
);
9588 local_define_builtin ("__builtin_init_heap_trampoline", ftype
,
9589 BUILT_IN_INIT_HEAP_TRAMPOLINE
,
9590 "__builtin_init_heap_trampoline",
9591 ECF_NOTHROW
| ECF_LEAF
);
9593 ftype
= build_function_type_list (ptr_type_node
, ptr_type_node
, NULL_TREE
);
9594 local_define_builtin ("__builtin_adjust_trampoline", ftype
,
9595 BUILT_IN_ADJUST_TRAMPOLINE
,
9596 "__builtin_adjust_trampoline",
9597 ECF_CONST
| ECF_NOTHROW
);
9599 ftype
= build_function_type_list (void_type_node
,
9600 ptr_type_node
, ptr_type_node
, NULL_TREE
);
9601 local_define_builtin ("__builtin_nonlocal_goto", ftype
,
9602 BUILT_IN_NONLOCAL_GOTO
,
9603 "__builtin_nonlocal_goto",
9604 ECF_NORETURN
| ECF_NOTHROW
);
9606 ftype
= build_function_type_list (void_type_node
,
9607 ptr_type_node
, ptr_type_node
, NULL_TREE
);
9608 local_define_builtin ("__builtin_setjmp_setup", ftype
,
9609 BUILT_IN_SETJMP_SETUP
,
9610 "__builtin_setjmp_setup", ECF_NOTHROW
);
9612 ftype
= build_function_type_list (ptr_type_node
, ptr_type_node
, NULL_TREE
);
9613 local_define_builtin ("__builtin_setjmp_dispatcher", ftype
,
9614 BUILT_IN_SETJMP_DISPATCHER
,
9615 "__builtin_setjmp_dispatcher",
9616 ECF_PURE
| ECF_NOTHROW
);
9618 ftype
= build_function_type_list (void_type_node
, ptr_type_node
, NULL_TREE
);
9619 local_define_builtin ("__builtin_setjmp_receiver", ftype
,
9620 BUILT_IN_SETJMP_RECEIVER
,
9621 "__builtin_setjmp_receiver", ECF_NOTHROW
);
9623 ftype
= build_function_type_list (ptr_type_node
, NULL_TREE
);
9624 local_define_builtin ("__builtin_stack_save", ftype
, BUILT_IN_STACK_SAVE
,
9625 "__builtin_stack_save", ECF_NOTHROW
| ECF_LEAF
);
9627 ftype
= build_function_type_list (void_type_node
, ptr_type_node
, NULL_TREE
);
9628 local_define_builtin ("__builtin_stack_restore", ftype
,
9629 BUILT_IN_STACK_RESTORE
,
9630 "__builtin_stack_restore", ECF_NOTHROW
| ECF_LEAF
);
9632 /* If there's a possibility that we might use the ARM EABI, build the
9633 alternate __cxa_end_cleanup node used to resume from C++ and Java. */
9634 if (targetm
.arm_eabi_unwinder
)
9636 ftype
= build_function_type_list (void_type_node
, NULL_TREE
);
9637 local_define_builtin ("__builtin_cxa_end_cleanup", ftype
,
9638 BUILT_IN_CXA_END_CLEANUP
,
9639 "__cxa_end_cleanup", ECF_NORETURN
| ECF_LEAF
);
9642 ftype
= build_function_type_list (void_type_node
, ptr_type_node
, NULL_TREE
);
9643 local_define_builtin ("__builtin_unwind_resume", ftype
,
9644 BUILT_IN_UNWIND_RESUME
,
9645 ((targetm_common
.except_unwind_info (&global_options
)
9647 ? "_Unwind_SjLj_Resume" : "_Unwind_Resume"),
9650 if (builtin_decl_explicit (BUILT_IN_RETURN_ADDRESS
) == NULL_TREE
)
9652 ftype
= build_function_type_list (ptr_type_node
, integer_type_node
,
9654 local_define_builtin ("__builtin_return_address", ftype
,
9655 BUILT_IN_RETURN_ADDRESS
,
9656 "__builtin_return_address",
9660 if (!builtin_decl_explicit_p (BUILT_IN_PROFILE_FUNC_ENTER
)
9661 || !builtin_decl_explicit_p (BUILT_IN_PROFILE_FUNC_EXIT
))
9663 ftype
= build_function_type_list (void_type_node
, ptr_type_node
,
9664 ptr_type_node
, NULL_TREE
);
9665 if (!builtin_decl_explicit_p (BUILT_IN_PROFILE_FUNC_ENTER
))
9666 local_define_builtin ("__cyg_profile_func_enter", ftype
,
9667 BUILT_IN_PROFILE_FUNC_ENTER
,
9668 "__cyg_profile_func_enter", 0);
9669 if (!builtin_decl_explicit_p (BUILT_IN_PROFILE_FUNC_EXIT
))
9670 local_define_builtin ("__cyg_profile_func_exit", ftype
,
9671 BUILT_IN_PROFILE_FUNC_EXIT
,
9672 "__cyg_profile_func_exit", 0);
9675 /* The exception object and filter values from the runtime. The argument
9676 must be zero before exception lowering, i.e. from the front end. After
9677 exception lowering, it will be the region number for the exception
9678 landing pad. These functions are PURE instead of CONST to prevent
9679 them from being hoisted past the exception edge that will initialize
9680 its value in the landing pad. */
9681 ftype
= build_function_type_list (ptr_type_node
,
9682 integer_type_node
, NULL_TREE
);
9683 ecf_flags
= ECF_PURE
| ECF_NOTHROW
| ECF_LEAF
;
9684 /* Only use TM_PURE if we we have TM language support. */
9685 if (builtin_decl_explicit_p (BUILT_IN_TM_LOAD_1
))
9686 ecf_flags
|= ECF_TM_PURE
;
9687 local_define_builtin ("__builtin_eh_pointer", ftype
, BUILT_IN_EH_POINTER
,
9688 "__builtin_eh_pointer", ecf_flags
);
9690 tmp
= lang_hooks
.types
.type_for_mode (targetm
.eh_return_filter_mode (), 0);
9691 ftype
= build_function_type_list (tmp
, integer_type_node
, NULL_TREE
);
9692 local_define_builtin ("__builtin_eh_filter", ftype
, BUILT_IN_EH_FILTER
,
9693 "__builtin_eh_filter", ECF_PURE
| ECF_NOTHROW
| ECF_LEAF
);
9695 ftype
= build_function_type_list (void_type_node
,
9696 integer_type_node
, integer_type_node
,
9698 local_define_builtin ("__builtin_eh_copy_values", ftype
,
9699 BUILT_IN_EH_COPY_VALUES
,
9700 "__builtin_eh_copy_values", ECF_NOTHROW
);
9702 /* Complex multiplication and division. These are handled as builtins
9703 rather than optabs because emit_library_call_value doesn't support
9704 complex. Further, we can do slightly better with folding these
9705 beasties if the real and complex parts of the arguments are separate. */
9709 for (mode
= MIN_MODE_COMPLEX_FLOAT
; mode
<= MAX_MODE_COMPLEX_FLOAT
; ++mode
)
9711 char mode_name_buf
[4], *q
;
9713 enum built_in_function mcode
, dcode
;
9714 tree type
, inner_type
;
9715 const char *prefix
= "__";
9717 if (targetm
.libfunc_gnu_prefix
)
9720 type
= lang_hooks
.types
.type_for_mode ((enum machine_mode
) mode
, 0);
9723 inner_type
= TREE_TYPE (type
);
9725 ftype
= build_function_type_list (type
, inner_type
, inner_type
,
9726 inner_type
, inner_type
, NULL_TREE
);
9728 mcode
= ((enum built_in_function
)
9729 (BUILT_IN_COMPLEX_MUL_MIN
+ mode
- MIN_MODE_COMPLEX_FLOAT
));
9730 dcode
= ((enum built_in_function
)
9731 (BUILT_IN_COMPLEX_DIV_MIN
+ mode
- MIN_MODE_COMPLEX_FLOAT
));
9733 for (p
= GET_MODE_NAME (mode
), q
= mode_name_buf
; *p
; p
++, q
++)
9737 built_in_names
[mcode
] = concat (prefix
, "mul", mode_name_buf
, "3",
9739 local_define_builtin (built_in_names
[mcode
], ftype
, mcode
,
9740 built_in_names
[mcode
],
9741 ECF_CONST
| ECF_NOTHROW
| ECF_LEAF
);
9743 built_in_names
[dcode
] = concat (prefix
, "div", mode_name_buf
, "3",
9745 local_define_builtin (built_in_names
[dcode
], ftype
, dcode
,
9746 built_in_names
[dcode
],
9747 ECF_CONST
| ECF_NOTHROW
| ECF_LEAF
);
9752 /* HACK. GROSS. This is absolutely disgusting. I wish there was a
9755 If we requested a pointer to a vector, build up the pointers that
9756 we stripped off while looking for the inner type. Similarly for
9757 return values from functions.
9759 The argument TYPE is the top of the chain, and BOTTOM is the
9760 new type which we will point to. */
9763 reconstruct_complex_type (tree type
, tree bottom
)
9767 if (TREE_CODE (type
) == POINTER_TYPE
)
9769 inner
= reconstruct_complex_type (TREE_TYPE (type
), bottom
);
9770 outer
= build_pointer_type_for_mode (inner
, TYPE_MODE (type
),
9771 TYPE_REF_CAN_ALIAS_ALL (type
));
9773 else if (TREE_CODE (type
) == REFERENCE_TYPE
)
9775 inner
= reconstruct_complex_type (TREE_TYPE (type
), bottom
);
9776 outer
= build_reference_type_for_mode (inner
, TYPE_MODE (type
),
9777 TYPE_REF_CAN_ALIAS_ALL (type
));
9779 else if (TREE_CODE (type
) == ARRAY_TYPE
)
9781 inner
= reconstruct_complex_type (TREE_TYPE (type
), bottom
);
9782 outer
= build_array_type (inner
, TYPE_DOMAIN (type
));
9784 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
9786 inner
= reconstruct_complex_type (TREE_TYPE (type
), bottom
);
9787 outer
= build_function_type (inner
, TYPE_ARG_TYPES (type
));
9789 else if (TREE_CODE (type
) == METHOD_TYPE
)
9791 inner
= reconstruct_complex_type (TREE_TYPE (type
), bottom
);
9792 /* The build_method_type_directly() routine prepends 'this' to argument list,
9793 so we must compensate by getting rid of it. */
9795 = build_method_type_directly
9796 (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (type
))),
9798 TREE_CHAIN (TYPE_ARG_TYPES (type
)));
9800 else if (TREE_CODE (type
) == OFFSET_TYPE
)
9802 inner
= reconstruct_complex_type (TREE_TYPE (type
), bottom
);
9803 outer
= build_offset_type (TYPE_OFFSET_BASETYPE (type
), inner
);
9808 return build_type_attribute_qual_variant (outer
, TYPE_ATTRIBUTES (type
),
9812 /* Returns a vector tree node given a mode (integer, vector, or BLKmode) and
9815 build_vector_type_for_mode (tree innertype
, enum machine_mode mode
)
9819 switch (GET_MODE_CLASS (mode
))
9821 case MODE_VECTOR_INT
:
9822 case MODE_VECTOR_FLOAT
:
9823 case MODE_VECTOR_FRACT
:
9824 case MODE_VECTOR_UFRACT
:
9825 case MODE_VECTOR_ACCUM
:
9826 case MODE_VECTOR_UACCUM
:
9827 nunits
= GET_MODE_NUNITS (mode
);
9831 /* Check that there are no leftover bits. */
9832 gcc_assert (GET_MODE_BITSIZE (mode
)
9833 % TREE_INT_CST_LOW (TYPE_SIZE (innertype
)) == 0);
9835 nunits
= GET_MODE_BITSIZE (mode
)
9836 / TREE_INT_CST_LOW (TYPE_SIZE (innertype
));
9843 return make_vector_type (innertype
, nunits
, mode
);
9846 /* Similarly, but takes the inner type and number of units, which must be
9850 build_vector_type (tree innertype
, int nunits
)
9852 return make_vector_type (innertype
, nunits
, VOIDmode
);
9855 /* Similarly, but builds a variant type with TYPE_VECTOR_OPAQUE set. */
9858 build_opaque_vector_type (tree innertype
, int nunits
)
9860 tree t
= make_vector_type (innertype
, nunits
, VOIDmode
);
9862 /* We always build the non-opaque variant before the opaque one,
9863 so if it already exists, it is TYPE_NEXT_VARIANT of this one. */
9864 cand
= TYPE_NEXT_VARIANT (t
);
9866 && TYPE_VECTOR_OPAQUE (cand
)
9867 && check_qualified_type (cand
, t
, TYPE_QUALS (t
)))
9869 /* Othewise build a variant type and make sure to queue it after
9870 the non-opaque type. */
9871 cand
= build_distinct_type_copy (t
);
9872 TYPE_VECTOR_OPAQUE (cand
) = true;
9873 TYPE_CANONICAL (cand
) = TYPE_CANONICAL (t
);
9874 TYPE_NEXT_VARIANT (cand
) = TYPE_NEXT_VARIANT (t
);
9875 TYPE_NEXT_VARIANT (t
) = cand
;
9876 TYPE_MAIN_VARIANT (cand
) = TYPE_MAIN_VARIANT (t
);
9881 /* Given an initializer INIT, return TRUE if INIT is zero or some
9882 aggregate of zeros. Otherwise return FALSE. */
9884 initializer_zerop (const_tree init
)
9890 switch (TREE_CODE (init
))
9893 return integer_zerop (init
);
9896 /* ??? Note that this is not correct for C4X float formats. There,
9897 a bit pattern of all zeros is 1.0; 0.0 is encoded with the most
9898 negative exponent. */
9899 return real_zerop (init
)
9900 && ! REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (init
));
9903 return fixed_zerop (init
);
9906 return integer_zerop (init
)
9907 || (real_zerop (init
)
9908 && ! REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (TREE_REALPART (init
)))
9909 && ! REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (TREE_IMAGPART (init
))));
9914 for (i
= 0; i
< VECTOR_CST_NELTS (init
); ++i
)
9915 if (!initializer_zerop (VECTOR_CST_ELT (init
, i
)))
9922 unsigned HOST_WIDE_INT idx
;
9924 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (init
), idx
, elt
)
9925 if (!initializer_zerop (elt
))
9934 /* We need to loop through all elements to handle cases like
9935 "\0" and "\0foobar". */
9936 for (i
= 0; i
< TREE_STRING_LENGTH (init
); ++i
)
9937 if (TREE_STRING_POINTER (init
)[i
] != '\0')
9948 /* Build an empty statement at location LOC. */
9951 build_empty_stmt (location_t loc
)
9953 tree t
= build1 (NOP_EXPR
, void_type_node
, size_zero_node
);
9954 SET_EXPR_LOCATION (t
, loc
);
9959 /* Build an OpenMP clause with code CODE. LOC is the location of the
9963 build_omp_clause (location_t loc
, enum omp_clause_code code
)
9968 length
= omp_clause_num_ops
[code
];
9969 size
= (sizeof (struct tree_omp_clause
) + (length
- 1) * sizeof (tree
));
9971 record_node_allocation_statistics (OMP_CLAUSE
, size
);
9973 t
= ggc_alloc_tree_node (size
);
9974 memset (t
, 0, size
);
9975 TREE_SET_CODE (t
, OMP_CLAUSE
);
9976 OMP_CLAUSE_SET_CODE (t
, code
);
9977 OMP_CLAUSE_LOCATION (t
) = loc
;
9982 /* Build a tcc_vl_exp object with code CODE and room for LEN operands. LEN
9983 includes the implicit operand count in TREE_OPERAND 0, and so must be >= 1.
9984 Except for the CODE and operand count field, other storage for the
9985 object is initialized to zeros. */
9988 build_vl_exp_stat (enum tree_code code
, int len MEM_STAT_DECL
)
9991 int length
= (len
- 1) * sizeof (tree
) + sizeof (struct tree_exp
);
9993 gcc_assert (TREE_CODE_CLASS (code
) == tcc_vl_exp
);
9994 gcc_assert (len
>= 1);
9996 record_node_allocation_statistics (code
, length
);
9998 t
= ggc_alloc_zone_cleared_tree_node_stat (&tree_zone
, length PASS_MEM_STAT
);
10000 TREE_SET_CODE (t
, code
);
10002 /* Can't use TREE_OPERAND to store the length because if checking is
10003 enabled, it will try to check the length before we store it. :-P */
10004 t
->exp
.operands
[0] = build_int_cst (sizetype
, len
);
10009 /* Helper function for build_call_* functions; build a CALL_EXPR with
10010 indicated RETURN_TYPE, FN, and NARGS, but do not initialize any of
10011 the argument slots. */
10014 build_call_1 (tree return_type
, tree fn
, int nargs
)
10018 t
= build_vl_exp (CALL_EXPR
, nargs
+ 3);
10019 TREE_TYPE (t
) = return_type
;
10020 CALL_EXPR_FN (t
) = fn
;
10021 CALL_EXPR_STATIC_CHAIN (t
) = NULL
;
10026 /* Build a CALL_EXPR of class tcc_vl_exp with the indicated RETURN_TYPE and
10027 FN and a null static chain slot. NARGS is the number of call arguments
10028 which are specified as "..." arguments. */
10031 build_call_nary (tree return_type
, tree fn
, int nargs
, ...)
10035 va_start (args
, nargs
);
10036 ret
= build_call_valist (return_type
, fn
, nargs
, args
);
10041 /* Build a CALL_EXPR of class tcc_vl_exp with the indicated RETURN_TYPE and
10042 FN and a null static chain slot. NARGS is the number of call arguments
10043 which are specified as a va_list ARGS. */
10046 build_call_valist (tree return_type
, tree fn
, int nargs
, va_list args
)
10051 t
= build_call_1 (return_type
, fn
, nargs
);
10052 for (i
= 0; i
< nargs
; i
++)
10053 CALL_EXPR_ARG (t
, i
) = va_arg (args
, tree
);
10054 process_call_operands (t
);
10058 /* Build a CALL_EXPR of class tcc_vl_exp with the indicated RETURN_TYPE and
10059 FN and a null static chain slot. NARGS is the number of call arguments
10060 which are specified as a tree array ARGS. */
10063 build_call_array_loc (location_t loc
, tree return_type
, tree fn
,
10064 int nargs
, const tree
*args
)
10069 t
= build_call_1 (return_type
, fn
, nargs
);
10070 for (i
= 0; i
< nargs
; i
++)
10071 CALL_EXPR_ARG (t
, i
) = args
[i
];
10072 process_call_operands (t
);
10073 SET_EXPR_LOCATION (t
, loc
);
10077 /* Like build_call_array, but takes a VEC. */
10080 build_call_vec (tree return_type
, tree fn
, VEC(tree
,gc
) *args
)
10085 ret
= build_call_1 (return_type
, fn
, VEC_length (tree
, args
));
10086 FOR_EACH_VEC_ELT (tree
, args
, ix
, t
)
10087 CALL_EXPR_ARG (ret
, ix
) = t
;
10088 process_call_operands (ret
);
10093 /* Returns true if it is possible to prove that the index of
10094 an array access REF (an ARRAY_REF expression) falls into the
10098 in_array_bounds_p (tree ref
)
10100 tree idx
= TREE_OPERAND (ref
, 1);
10103 if (TREE_CODE (idx
) != INTEGER_CST
)
10106 min
= array_ref_low_bound (ref
);
10107 max
= array_ref_up_bound (ref
);
10110 || TREE_CODE (min
) != INTEGER_CST
10111 || TREE_CODE (max
) != INTEGER_CST
)
10114 if (tree_int_cst_lt (idx
, min
)
10115 || tree_int_cst_lt (max
, idx
))
10121 /* Returns true if it is possible to prove that the range of
10122 an array access REF (an ARRAY_RANGE_REF expression) falls
10123 into the array bounds. */
10126 range_in_array_bounds_p (tree ref
)
10128 tree domain_type
= TYPE_DOMAIN (TREE_TYPE (ref
));
10129 tree range_min
, range_max
, min
, max
;
10131 range_min
= TYPE_MIN_VALUE (domain_type
);
10132 range_max
= TYPE_MAX_VALUE (domain_type
);
10135 || TREE_CODE (range_min
) != INTEGER_CST
10136 || TREE_CODE (range_max
) != INTEGER_CST
)
10139 min
= array_ref_low_bound (ref
);
10140 max
= array_ref_up_bound (ref
);
10143 || TREE_CODE (min
) != INTEGER_CST
10144 || TREE_CODE (max
) != INTEGER_CST
)
10147 if (tree_int_cst_lt (range_min
, min
)
10148 || tree_int_cst_lt (max
, range_max
))
10154 /* Return true if T (assumed to be a DECL) must be assigned a memory
10158 needs_to_live_in_memory (const_tree t
)
10160 if (TREE_CODE (t
) == SSA_NAME
)
10161 t
= SSA_NAME_VAR (t
);
10163 return (TREE_ADDRESSABLE (t
)
10164 || is_global_var (t
)
10165 || (TREE_CODE (t
) == RESULT_DECL
10166 && !DECL_BY_REFERENCE (t
)
10167 && aggregate_value_p (t
, current_function_decl
)));
10170 /* Return value of a constant X and sign-extend it. */
10173 int_cst_value (const_tree x
)
10175 unsigned bits
= TYPE_PRECISION (TREE_TYPE (x
));
10176 unsigned HOST_WIDE_INT val
= TREE_INT_CST_LOW (x
);
10178 /* Make sure the sign-extended value will fit in a HOST_WIDE_INT. */
10179 gcc_assert (TREE_INT_CST_HIGH (x
) == 0
10180 || TREE_INT_CST_HIGH (x
) == -1);
10182 if (bits
< HOST_BITS_PER_WIDE_INT
)
10184 bool negative
= ((val
>> (bits
- 1)) & 1) != 0;
10186 val
|= (~(unsigned HOST_WIDE_INT
) 0) << (bits
- 1) << 1;
10188 val
&= ~((~(unsigned HOST_WIDE_INT
) 0) << (bits
- 1) << 1);
10194 /* Return value of a constant X and sign-extend it. */
10197 widest_int_cst_value (const_tree x
)
10199 unsigned bits
= TYPE_PRECISION (TREE_TYPE (x
));
10200 unsigned HOST_WIDEST_INT val
= TREE_INT_CST_LOW (x
);
10202 #if HOST_BITS_PER_WIDEST_INT > HOST_BITS_PER_WIDE_INT
10203 gcc_assert (HOST_BITS_PER_WIDEST_INT
>= 2 * HOST_BITS_PER_WIDE_INT
);
10204 val
|= (((unsigned HOST_WIDEST_INT
) TREE_INT_CST_HIGH (x
))
10205 << HOST_BITS_PER_WIDE_INT
);
10207 /* Make sure the sign-extended value will fit in a HOST_WIDE_INT. */
10208 gcc_assert (TREE_INT_CST_HIGH (x
) == 0
10209 || TREE_INT_CST_HIGH (x
) == -1);
10212 if (bits
< HOST_BITS_PER_WIDEST_INT
)
10214 bool negative
= ((val
>> (bits
- 1)) & 1) != 0;
10216 val
|= (~(unsigned HOST_WIDEST_INT
) 0) << (bits
- 1) << 1;
10218 val
&= ~((~(unsigned HOST_WIDEST_INT
) 0) << (bits
- 1) << 1);
10224 /* If TYPE is an integral or pointer type, return an integer type with
10225 the same precision which is unsigned iff UNSIGNEDP is true, or itself
10226 if TYPE is already an integer type of signedness UNSIGNEDP. */
10229 signed_or_unsigned_type_for (int unsignedp
, tree type
)
10231 if (TREE_CODE (type
) == INTEGER_TYPE
&& TYPE_UNSIGNED (type
) == unsignedp
)
10234 if (!INTEGRAL_TYPE_P (type
)
10235 && !POINTER_TYPE_P (type
))
10238 return build_nonstandard_integer_type (TYPE_PRECISION (type
), unsignedp
);
10241 /* If TYPE is an integral or pointer type, return an integer type with
10242 the same precision which is unsigned, or itself if TYPE is already an
10243 unsigned integer type. */
10246 unsigned_type_for (tree type
)
10248 return signed_or_unsigned_type_for (1, type
);
10251 /* If TYPE is an integral or pointer type, return an integer type with
10252 the same precision which is signed, or itself if TYPE is already a
10253 signed integer type. */
10256 signed_type_for (tree type
)
10258 return signed_or_unsigned_type_for (0, type
);
10261 /* Returns the largest value obtainable by casting something in INNER type to
10265 upper_bound_in_type (tree outer
, tree inner
)
10268 unsigned int det
= 0;
10269 unsigned oprec
= TYPE_PRECISION (outer
);
10270 unsigned iprec
= TYPE_PRECISION (inner
);
10273 /* Compute a unique number for every combination. */
10274 det
|= (oprec
> iprec
) ? 4 : 0;
10275 det
|= TYPE_UNSIGNED (outer
) ? 2 : 0;
10276 det
|= TYPE_UNSIGNED (inner
) ? 1 : 0;
10278 /* Determine the exponent to use. */
10283 /* oprec <= iprec, outer: signed, inner: don't care. */
10288 /* oprec <= iprec, outer: unsigned, inner: don't care. */
10292 /* oprec > iprec, outer: signed, inner: signed. */
10296 /* oprec > iprec, outer: signed, inner: unsigned. */
10300 /* oprec > iprec, outer: unsigned, inner: signed. */
10304 /* oprec > iprec, outer: unsigned, inner: unsigned. */
10308 gcc_unreachable ();
10311 /* Compute 2^^prec - 1. */
10312 if (prec
<= HOST_BITS_PER_WIDE_INT
)
10315 high
.low
= ((~(unsigned HOST_WIDE_INT
) 0)
10316 >> (HOST_BITS_PER_WIDE_INT
- prec
));
10320 high
.high
= ((~(unsigned HOST_WIDE_INT
) 0)
10321 >> (2 * HOST_BITS_PER_WIDE_INT
- prec
));
10322 high
.low
= ~(unsigned HOST_WIDE_INT
) 0;
10325 return double_int_to_tree (outer
, high
);
10328 /* Returns the smallest value obtainable by casting something in INNER type to
10332 lower_bound_in_type (tree outer
, tree inner
)
10335 unsigned oprec
= TYPE_PRECISION (outer
);
10336 unsigned iprec
= TYPE_PRECISION (inner
);
10338 /* If OUTER type is unsigned, we can definitely cast 0 to OUTER type
10340 if (TYPE_UNSIGNED (outer
)
10341 /* If we are widening something of an unsigned type, OUTER type
10342 contains all values of INNER type. In particular, both INNER
10343 and OUTER types have zero in common. */
10344 || (oprec
> iprec
&& TYPE_UNSIGNED (inner
)))
10345 low
.low
= low
.high
= 0;
10348 /* If we are widening a signed type to another signed type, we
10349 want to obtain -2^^(iprec-1). If we are keeping the
10350 precision or narrowing to a signed type, we want to obtain
10352 unsigned prec
= oprec
> iprec
? iprec
: oprec
;
10354 if (prec
<= HOST_BITS_PER_WIDE_INT
)
10356 low
.high
= ~(unsigned HOST_WIDE_INT
) 0;
10357 low
.low
= (~(unsigned HOST_WIDE_INT
) 0) << (prec
- 1);
10361 low
.high
= ((~(unsigned HOST_WIDE_INT
) 0)
10362 << (prec
- HOST_BITS_PER_WIDE_INT
- 1));
10367 return double_int_to_tree (outer
, low
);
10370 /* Return nonzero if two operands that are suitable for PHI nodes are
10371 necessarily equal. Specifically, both ARG0 and ARG1 must be either
10372 SSA_NAME or invariant. Note that this is strictly an optimization.
10373 That is, callers of this function can directly call operand_equal_p
10374 and get the same result, only slower. */
10377 operand_equal_for_phi_arg_p (const_tree arg0
, const_tree arg1
)
10381 if (TREE_CODE (arg0
) == SSA_NAME
|| TREE_CODE (arg1
) == SSA_NAME
)
10383 return operand_equal_p (arg0
, arg1
, 0);
10386 /* Returns number of zeros at the end of binary representation of X.
10388 ??? Use ffs if available? */
10391 num_ending_zeros (const_tree x
)
10393 unsigned HOST_WIDE_INT fr
, nfr
;
10394 unsigned num
, abits
;
10395 tree type
= TREE_TYPE (x
);
10397 if (TREE_INT_CST_LOW (x
) == 0)
10399 num
= HOST_BITS_PER_WIDE_INT
;
10400 fr
= TREE_INT_CST_HIGH (x
);
10405 fr
= TREE_INT_CST_LOW (x
);
10408 for (abits
= HOST_BITS_PER_WIDE_INT
/ 2; abits
; abits
/= 2)
10411 if (nfr
<< abits
== fr
)
10418 if (num
> TYPE_PRECISION (type
))
10419 num
= TYPE_PRECISION (type
);
10421 return build_int_cst_type (type
, num
);
10425 #define WALK_SUBTREE(NODE) \
10428 result = walk_tree_1 (&(NODE), func, data, pset, lh); \
10434 /* This is a subroutine of walk_tree that walks field of TYPE that are to
10435 be walked whenever a type is seen in the tree. Rest of operands and return
10436 value are as for walk_tree. */
10439 walk_type_fields (tree type
, walk_tree_fn func
, void *data
,
10440 struct pointer_set_t
*pset
, walk_tree_lh lh
)
10442 tree result
= NULL_TREE
;
10444 switch (TREE_CODE (type
))
10447 case REFERENCE_TYPE
:
10448 /* We have to worry about mutually recursive pointers. These can't
10449 be written in C. They can in Ada. It's pathological, but
10450 there's an ACATS test (c38102a) that checks it. Deal with this
10451 by checking if we're pointing to another pointer, that one
10452 points to another pointer, that one does too, and we have no htab.
10453 If so, get a hash table. We check three levels deep to avoid
10454 the cost of the hash table if we don't need one. */
10455 if (POINTER_TYPE_P (TREE_TYPE (type
))
10456 && POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (type
)))
10457 && POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (TREE_TYPE (type
))))
10460 result
= walk_tree_without_duplicates (&TREE_TYPE (type
),
10468 /* ... fall through ... */
10471 WALK_SUBTREE (TREE_TYPE (type
));
10475 WALK_SUBTREE (TYPE_METHOD_BASETYPE (type
));
10477 /* Fall through. */
10479 case FUNCTION_TYPE
:
10480 WALK_SUBTREE (TREE_TYPE (type
));
10484 /* We never want to walk into default arguments. */
10485 for (arg
= TYPE_ARG_TYPES (type
); arg
; arg
= TREE_CHAIN (arg
))
10486 WALK_SUBTREE (TREE_VALUE (arg
));
10491 /* Don't follow this nodes's type if a pointer for fear that
10492 we'll have infinite recursion. If we have a PSET, then we
10495 || (!POINTER_TYPE_P (TREE_TYPE (type
))
10496 && TREE_CODE (TREE_TYPE (type
)) != OFFSET_TYPE
))
10497 WALK_SUBTREE (TREE_TYPE (type
));
10498 WALK_SUBTREE (TYPE_DOMAIN (type
));
10502 WALK_SUBTREE (TREE_TYPE (type
));
10503 WALK_SUBTREE (TYPE_OFFSET_BASETYPE (type
));
10513 /* Apply FUNC to all the sub-trees of TP in a pre-order traversal. FUNC is
10514 called with the DATA and the address of each sub-tree. If FUNC returns a
10515 non-NULL value, the traversal is stopped, and the value returned by FUNC
10516 is returned. If PSET is non-NULL it is used to record the nodes visited,
10517 and to avoid visiting a node more than once. */
10520 walk_tree_1 (tree
*tp
, walk_tree_fn func
, void *data
,
10521 struct pointer_set_t
*pset
, walk_tree_lh lh
)
10523 enum tree_code code
;
10527 #define WALK_SUBTREE_TAIL(NODE) \
10531 goto tail_recurse; \
10536 /* Skip empty subtrees. */
10540 /* Don't walk the same tree twice, if the user has requested
10541 that we avoid doing so. */
10542 if (pset
&& pointer_set_insert (pset
, *tp
))
10545 /* Call the function. */
10547 result
= (*func
) (tp
, &walk_subtrees
, data
);
10549 /* If we found something, return it. */
10553 code
= TREE_CODE (*tp
);
10555 /* Even if we didn't, FUNC may have decided that there was nothing
10556 interesting below this point in the tree. */
10557 if (!walk_subtrees
)
10559 /* But we still need to check our siblings. */
10560 if (code
== TREE_LIST
)
10561 WALK_SUBTREE_TAIL (TREE_CHAIN (*tp
));
10562 else if (code
== OMP_CLAUSE
)
10563 WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp
));
10570 result
= (*lh
) (tp
, &walk_subtrees
, func
, data
, pset
);
10571 if (result
|| !walk_subtrees
)
10578 case IDENTIFIER_NODE
:
10585 case PLACEHOLDER_EXPR
:
10589 /* None of these have subtrees other than those already walked
10594 WALK_SUBTREE (TREE_VALUE (*tp
));
10595 WALK_SUBTREE_TAIL (TREE_CHAIN (*tp
));
10600 int len
= TREE_VEC_LENGTH (*tp
);
10605 /* Walk all elements but the first. */
10607 WALK_SUBTREE (TREE_VEC_ELT (*tp
, len
));
10609 /* Now walk the first one as a tail call. */
10610 WALK_SUBTREE_TAIL (TREE_VEC_ELT (*tp
, 0));
10614 WALK_SUBTREE (TREE_REALPART (*tp
));
10615 WALK_SUBTREE_TAIL (TREE_IMAGPART (*tp
));
10619 unsigned HOST_WIDE_INT idx
;
10620 constructor_elt
*ce
;
10623 VEC_iterate(constructor_elt
, CONSTRUCTOR_ELTS (*tp
), idx
, ce
);
10625 WALK_SUBTREE (ce
->value
);
10630 WALK_SUBTREE_TAIL (TREE_OPERAND (*tp
, 0));
10635 for (decl
= BIND_EXPR_VARS (*tp
); decl
; decl
= DECL_CHAIN (decl
))
10637 /* Walk the DECL_INITIAL and DECL_SIZE. We don't want to walk
10638 into declarations that are just mentioned, rather than
10639 declared; they don't really belong to this part of the tree.
10640 And, we can see cycles: the initializer for a declaration
10641 can refer to the declaration itself. */
10642 WALK_SUBTREE (DECL_INITIAL (decl
));
10643 WALK_SUBTREE (DECL_SIZE (decl
));
10644 WALK_SUBTREE (DECL_SIZE_UNIT (decl
));
10646 WALK_SUBTREE_TAIL (BIND_EXPR_BODY (*tp
));
10649 case STATEMENT_LIST
:
10651 tree_stmt_iterator i
;
10652 for (i
= tsi_start (*tp
); !tsi_end_p (i
); tsi_next (&i
))
10653 WALK_SUBTREE (*tsi_stmt_ptr (i
));
10658 switch (OMP_CLAUSE_CODE (*tp
))
10660 case OMP_CLAUSE_PRIVATE
:
10661 case OMP_CLAUSE_SHARED
:
10662 case OMP_CLAUSE_FIRSTPRIVATE
:
10663 case OMP_CLAUSE_COPYIN
:
10664 case OMP_CLAUSE_COPYPRIVATE
:
10665 case OMP_CLAUSE_FINAL
:
10666 case OMP_CLAUSE_IF
:
10667 case OMP_CLAUSE_NUM_THREADS
:
10668 case OMP_CLAUSE_SCHEDULE
:
10669 WALK_SUBTREE (OMP_CLAUSE_OPERAND (*tp
, 0));
10672 case OMP_CLAUSE_NOWAIT
:
10673 case OMP_CLAUSE_ORDERED
:
10674 case OMP_CLAUSE_DEFAULT
:
10675 case OMP_CLAUSE_UNTIED
:
10676 case OMP_CLAUSE_MERGEABLE
:
10677 WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp
));
10679 case OMP_CLAUSE_LASTPRIVATE
:
10680 WALK_SUBTREE (OMP_CLAUSE_DECL (*tp
));
10681 WALK_SUBTREE (OMP_CLAUSE_LASTPRIVATE_STMT (*tp
));
10682 WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp
));
10684 case OMP_CLAUSE_COLLAPSE
:
10687 for (i
= 0; i
< 3; i
++)
10688 WALK_SUBTREE (OMP_CLAUSE_OPERAND (*tp
, i
));
10689 WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp
));
10692 case OMP_CLAUSE_REDUCTION
:
10695 for (i
= 0; i
< 4; i
++)
10696 WALK_SUBTREE (OMP_CLAUSE_OPERAND (*tp
, i
));
10697 WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp
));
10701 gcc_unreachable ();
10709 /* TARGET_EXPRs are peculiar: operands 1 and 3 can be the same.
10710 But, we only want to walk once. */
10711 len
= (TREE_OPERAND (*tp
, 3) == TREE_OPERAND (*tp
, 1)) ? 2 : 3;
10712 for (i
= 0; i
< len
; ++i
)
10713 WALK_SUBTREE (TREE_OPERAND (*tp
, i
));
10714 WALK_SUBTREE_TAIL (TREE_OPERAND (*tp
, len
));
10718 /* If this is a TYPE_DECL, walk into the fields of the type that it's
10719 defining. We only want to walk into these fields of a type in this
10720 case and not in the general case of a mere reference to the type.
10722 The criterion is as follows: if the field can be an expression, it
10723 must be walked only here. This should be in keeping with the fields
10724 that are directly gimplified in gimplify_type_sizes in order for the
10725 mark/copy-if-shared/unmark machinery of the gimplifier to work with
10726 variable-sized types.
10728 Note that DECLs get walked as part of processing the BIND_EXPR. */
10729 if (TREE_CODE (DECL_EXPR_DECL (*tp
)) == TYPE_DECL
)
10731 tree
*type_p
= &TREE_TYPE (DECL_EXPR_DECL (*tp
));
10732 if (TREE_CODE (*type_p
) == ERROR_MARK
)
10735 /* Call the function for the type. See if it returns anything or
10736 doesn't want us to continue. If we are to continue, walk both
10737 the normal fields and those for the declaration case. */
10738 result
= (*func
) (type_p
, &walk_subtrees
, data
);
10739 if (result
|| !walk_subtrees
)
10742 /* But do not walk a pointed-to type since it may itself need to
10743 be walked in the declaration case if it isn't anonymous. */
10744 if (!POINTER_TYPE_P (*type_p
))
10746 result
= walk_type_fields (*type_p
, func
, data
, pset
, lh
);
10751 /* If this is a record type, also walk the fields. */
10752 if (RECORD_OR_UNION_TYPE_P (*type_p
))
10756 for (field
= TYPE_FIELDS (*type_p
); field
;
10757 field
= DECL_CHAIN (field
))
10759 /* We'd like to look at the type of the field, but we can
10760 easily get infinite recursion. So assume it's pointed
10761 to elsewhere in the tree. Also, ignore things that
10763 if (TREE_CODE (field
) != FIELD_DECL
)
10766 WALK_SUBTREE (DECL_FIELD_OFFSET (field
));
10767 WALK_SUBTREE (DECL_SIZE (field
));
10768 WALK_SUBTREE (DECL_SIZE_UNIT (field
));
10769 if (TREE_CODE (*type_p
) == QUAL_UNION_TYPE
)
10770 WALK_SUBTREE (DECL_QUALIFIER (field
));
10774 /* Same for scalar types. */
10775 else if (TREE_CODE (*type_p
) == BOOLEAN_TYPE
10776 || TREE_CODE (*type_p
) == ENUMERAL_TYPE
10777 || TREE_CODE (*type_p
) == INTEGER_TYPE
10778 || TREE_CODE (*type_p
) == FIXED_POINT_TYPE
10779 || TREE_CODE (*type_p
) == REAL_TYPE
)
10781 WALK_SUBTREE (TYPE_MIN_VALUE (*type_p
));
10782 WALK_SUBTREE (TYPE_MAX_VALUE (*type_p
));
10785 WALK_SUBTREE (TYPE_SIZE (*type_p
));
10786 WALK_SUBTREE_TAIL (TYPE_SIZE_UNIT (*type_p
));
10791 if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (code
)))
10795 /* Walk over all the sub-trees of this operand. */
10796 len
= TREE_OPERAND_LENGTH (*tp
);
10798 /* Go through the subtrees. We need to do this in forward order so
10799 that the scope of a FOR_EXPR is handled properly. */
10802 for (i
= 0; i
< len
- 1; ++i
)
10803 WALK_SUBTREE (TREE_OPERAND (*tp
, i
));
10804 WALK_SUBTREE_TAIL (TREE_OPERAND (*tp
, len
- 1));
10807 /* If this is a type, walk the needed fields in the type. */
10808 else if (TYPE_P (*tp
))
10809 return walk_type_fields (*tp
, func
, data
, pset
, lh
);
10813 /* We didn't find what we were looking for. */
10816 #undef WALK_SUBTREE_TAIL
10818 #undef WALK_SUBTREE
10820 /* Like walk_tree, but does not walk duplicate nodes more than once. */
10823 walk_tree_without_duplicates_1 (tree
*tp
, walk_tree_fn func
, void *data
,
10827 struct pointer_set_t
*pset
;
10829 pset
= pointer_set_create ();
10830 result
= walk_tree_1 (tp
, func
, data
, pset
, lh
);
10831 pointer_set_destroy (pset
);
10837 tree_block (tree t
)
10839 char const c
= TREE_CODE_CLASS (TREE_CODE (t
));
10841 if (IS_EXPR_CODE_CLASS (c
))
10842 return &t
->exp
.block
;
10843 gcc_unreachable ();
10847 /* Create a nameless artificial label and put it in the current
10848 function context. The label has a location of LOC. Returns the
10849 newly created label. */
10852 create_artificial_label (location_t loc
)
10854 tree lab
= build_decl (loc
,
10855 LABEL_DECL
, NULL_TREE
, void_type_node
);
10857 DECL_ARTIFICIAL (lab
) = 1;
10858 DECL_IGNORED_P (lab
) = 1;
10859 DECL_CONTEXT (lab
) = current_function_decl
;
10863 /* Given a tree, try to return a useful variable name that we can use
10864 to prefix a temporary that is being assigned the value of the tree.
10865 I.E. given <temp> = &A, return A. */
10870 tree stripped_decl
;
10873 STRIP_NOPS (stripped_decl
);
10874 if (DECL_P (stripped_decl
) && DECL_NAME (stripped_decl
))
10875 return IDENTIFIER_POINTER (DECL_NAME (stripped_decl
));
10878 switch (TREE_CODE (stripped_decl
))
10881 return get_name (TREE_OPERAND (stripped_decl
, 0));
10888 /* Return true if TYPE has a variable argument list. */
10891 stdarg_p (const_tree fntype
)
10893 function_args_iterator args_iter
;
10894 tree n
= NULL_TREE
, t
;
10899 FOREACH_FUNCTION_ARGS(fntype
, t
, args_iter
)
10904 return n
!= NULL_TREE
&& n
!= void_type_node
;
10907 /* Return true if TYPE has a prototype. */
10910 prototype_p (tree fntype
)
10914 gcc_assert (fntype
!= NULL_TREE
);
10916 t
= TYPE_ARG_TYPES (fntype
);
10917 return (t
!= NULL_TREE
);
10920 /* If BLOCK is inlined from an __attribute__((__artificial__))
10921 routine, return pointer to location from where it has been
10924 block_nonartificial_location (tree block
)
10926 location_t
*ret
= NULL
;
10928 while (block
&& TREE_CODE (block
) == BLOCK
10929 && BLOCK_ABSTRACT_ORIGIN (block
))
10931 tree ao
= BLOCK_ABSTRACT_ORIGIN (block
);
10933 while (TREE_CODE (ao
) == BLOCK
10934 && BLOCK_ABSTRACT_ORIGIN (ao
)
10935 && BLOCK_ABSTRACT_ORIGIN (ao
) != ao
)
10936 ao
= BLOCK_ABSTRACT_ORIGIN (ao
);
10938 if (TREE_CODE (ao
) == FUNCTION_DECL
)
10940 /* If AO is an artificial inline, point RET to the
10941 call site locus at which it has been inlined and continue
10942 the loop, in case AO's caller is also an artificial
10944 if (DECL_DECLARED_INLINE_P (ao
)
10945 && lookup_attribute ("artificial", DECL_ATTRIBUTES (ao
)))
10946 ret
= &BLOCK_SOURCE_LOCATION (block
);
10950 else if (TREE_CODE (ao
) != BLOCK
)
10953 block
= BLOCK_SUPERCONTEXT (block
);
10959 /* If EXP is inlined from an __attribute__((__artificial__))
10960 function, return the location of the original call expression. */
10963 tree_nonartificial_location (tree exp
)
10965 location_t
*loc
= block_nonartificial_location (TREE_BLOCK (exp
));
10970 return EXPR_LOCATION (exp
);
10974 /* These are the hash table functions for the hash table of OPTIMIZATION_NODEq
10977 /* Return the hash code code X, an OPTIMIZATION_NODE or TARGET_OPTION code. */
10980 cl_option_hash_hash (const void *x
)
10982 const_tree
const t
= (const_tree
) x
;
10986 hashval_t hash
= 0;
10988 if (TREE_CODE (t
) == OPTIMIZATION_NODE
)
10990 p
= (const char *)TREE_OPTIMIZATION (t
);
10991 len
= sizeof (struct cl_optimization
);
10994 else if (TREE_CODE (t
) == TARGET_OPTION_NODE
)
10996 p
= (const char *)TREE_TARGET_OPTION (t
);
10997 len
= sizeof (struct cl_target_option
);
11001 gcc_unreachable ();
11003 /* assume most opt flags are just 0/1, some are 2-3, and a few might be
11005 for (i
= 0; i
< len
; i
++)
11007 hash
= (hash
<< 4) ^ ((i
<< 2) | p
[i
]);
11012 /* Return nonzero if the value represented by *X (an OPTIMIZATION or
11013 TARGET_OPTION tree node) is the same as that given by *Y, which is the
11017 cl_option_hash_eq (const void *x
, const void *y
)
11019 const_tree
const xt
= (const_tree
) x
;
11020 const_tree
const yt
= (const_tree
) y
;
11025 if (TREE_CODE (xt
) != TREE_CODE (yt
))
11028 if (TREE_CODE (xt
) == OPTIMIZATION_NODE
)
11030 xp
= (const char *)TREE_OPTIMIZATION (xt
);
11031 yp
= (const char *)TREE_OPTIMIZATION (yt
);
11032 len
= sizeof (struct cl_optimization
);
11035 else if (TREE_CODE (xt
) == TARGET_OPTION_NODE
)
11037 xp
= (const char *)TREE_TARGET_OPTION (xt
);
11038 yp
= (const char *)TREE_TARGET_OPTION (yt
);
11039 len
= sizeof (struct cl_target_option
);
11043 gcc_unreachable ();
11045 return (memcmp (xp
, yp
, len
) == 0);
11048 /* Build an OPTIMIZATION_NODE based on the current options. */
11051 build_optimization_node (void)
11056 /* Use the cache of optimization nodes. */
11058 cl_optimization_save (TREE_OPTIMIZATION (cl_optimization_node
),
11061 slot
= htab_find_slot (cl_option_hash_table
, cl_optimization_node
, INSERT
);
11065 /* Insert this one into the hash table. */
11066 t
= cl_optimization_node
;
11069 /* Make a new node for next time round. */
11070 cl_optimization_node
= make_node (OPTIMIZATION_NODE
);
11076 /* Build a TARGET_OPTION_NODE based on the current options. */
11079 build_target_option_node (void)
11084 /* Use the cache of optimization nodes. */
11086 cl_target_option_save (TREE_TARGET_OPTION (cl_target_option_node
),
11089 slot
= htab_find_slot (cl_option_hash_table
, cl_target_option_node
, INSERT
);
11093 /* Insert this one into the hash table. */
11094 t
= cl_target_option_node
;
11097 /* Make a new node for next time round. */
11098 cl_target_option_node
= make_node (TARGET_OPTION_NODE
);
11104 /* Determine the "ultimate origin" of a block. The block may be an inlined
11105 instance of an inlined instance of a block which is local to an inline
11106 function, so we have to trace all of the way back through the origin chain
11107 to find out what sort of node actually served as the original seed for the
11111 block_ultimate_origin (const_tree block
)
11113 tree immediate_origin
= BLOCK_ABSTRACT_ORIGIN (block
);
11115 /* output_inline_function sets BLOCK_ABSTRACT_ORIGIN for all the
11116 nodes in the function to point to themselves; ignore that if
11117 we're trying to output the abstract instance of this function. */
11118 if (BLOCK_ABSTRACT (block
) && immediate_origin
== block
)
11121 if (immediate_origin
== NULL_TREE
)
11126 tree lookahead
= immediate_origin
;
11130 ret_val
= lookahead
;
11131 lookahead
= (TREE_CODE (ret_val
) == BLOCK
11132 ? BLOCK_ABSTRACT_ORIGIN (ret_val
) : NULL
);
11134 while (lookahead
!= NULL
&& lookahead
!= ret_val
);
11136 /* The block's abstract origin chain may not be the *ultimate* origin of
11137 the block. It could lead to a DECL that has an abstract origin set.
11138 If so, we want that DECL's abstract origin (which is what DECL_ORIGIN
11139 will give us if it has one). Note that DECL's abstract origins are
11140 supposed to be the most distant ancestor (or so decl_ultimate_origin
11141 claims), so we don't need to loop following the DECL origins. */
11142 if (DECL_P (ret_val
))
11143 return DECL_ORIGIN (ret_val
);
11149 /* Return true if T1 and T2 are equivalent lists. */
11152 list_equal_p (const_tree t1
, const_tree t2
)
11154 for (; t1
&& t2
; t1
= TREE_CHAIN (t1
) , t2
= TREE_CHAIN (t2
))
11155 if (TREE_VALUE (t1
) != TREE_VALUE (t2
))
11160 /* Return true iff conversion in EXP generates no instruction. Mark
11161 it inline so that we fully inline into the stripping functions even
11162 though we have two uses of this function. */
11165 tree_nop_conversion (const_tree exp
)
11167 tree outer_type
, inner_type
;
11169 if (!CONVERT_EXPR_P (exp
)
11170 && TREE_CODE (exp
) != NON_LVALUE_EXPR
)
11172 if (TREE_OPERAND (exp
, 0) == error_mark_node
)
11175 outer_type
= TREE_TYPE (exp
);
11176 inner_type
= TREE_TYPE (TREE_OPERAND (exp
, 0));
11181 /* Use precision rather then machine mode when we can, which gives
11182 the correct answer even for submode (bit-field) types. */
11183 if ((INTEGRAL_TYPE_P (outer_type
)
11184 || POINTER_TYPE_P (outer_type
)
11185 || TREE_CODE (outer_type
) == OFFSET_TYPE
)
11186 && (INTEGRAL_TYPE_P (inner_type
)
11187 || POINTER_TYPE_P (inner_type
)
11188 || TREE_CODE (inner_type
) == OFFSET_TYPE
))
11189 return TYPE_PRECISION (outer_type
) == TYPE_PRECISION (inner_type
);
11191 /* Otherwise fall back on comparing machine modes (e.g. for
11192 aggregate types, floats). */
11193 return TYPE_MODE (outer_type
) == TYPE_MODE (inner_type
);
11196 /* Return true iff conversion in EXP generates no instruction. Don't
11197 consider conversions changing the signedness. */
11200 tree_sign_nop_conversion (const_tree exp
)
11202 tree outer_type
, inner_type
;
11204 if (!tree_nop_conversion (exp
))
11207 outer_type
= TREE_TYPE (exp
);
11208 inner_type
= TREE_TYPE (TREE_OPERAND (exp
, 0));
11210 return (TYPE_UNSIGNED (outer_type
) == TYPE_UNSIGNED (inner_type
)
11211 && POINTER_TYPE_P (outer_type
) == POINTER_TYPE_P (inner_type
));
11214 /* Strip conversions from EXP according to tree_nop_conversion and
11215 return the resulting expression. */
11218 tree_strip_nop_conversions (tree exp
)
11220 while (tree_nop_conversion (exp
))
11221 exp
= TREE_OPERAND (exp
, 0);
11225 /* Strip conversions from EXP according to tree_sign_nop_conversion
11226 and return the resulting expression. */
11229 tree_strip_sign_nop_conversions (tree exp
)
11231 while (tree_sign_nop_conversion (exp
))
11232 exp
= TREE_OPERAND (exp
, 0);
11236 /* Avoid any floating point extensions from EXP. */
11238 strip_float_extensions (tree exp
)
11240 tree sub
, expt
, subt
;
11242 /* For floating point constant look up the narrowest type that can hold
11243 it properly and handle it like (type)(narrowest_type)constant.
11244 This way we can optimize for instance a=a*2.0 where "a" is float
11245 but 2.0 is double constant. */
11246 if (TREE_CODE (exp
) == REAL_CST
&& !DECIMAL_FLOAT_TYPE_P (TREE_TYPE (exp
)))
11248 REAL_VALUE_TYPE orig
;
11251 orig
= TREE_REAL_CST (exp
);
11252 if (TYPE_PRECISION (TREE_TYPE (exp
)) > TYPE_PRECISION (float_type_node
)
11253 && exact_real_truncate (TYPE_MODE (float_type_node
), &orig
))
11254 type
= float_type_node
;
11255 else if (TYPE_PRECISION (TREE_TYPE (exp
))
11256 > TYPE_PRECISION (double_type_node
)
11257 && exact_real_truncate (TYPE_MODE (double_type_node
), &orig
))
11258 type
= double_type_node
;
11260 return build_real (type
, real_value_truncate (TYPE_MODE (type
), orig
));
11263 if (!CONVERT_EXPR_P (exp
))
11266 sub
= TREE_OPERAND (exp
, 0);
11267 subt
= TREE_TYPE (sub
);
11268 expt
= TREE_TYPE (exp
);
11270 if (!FLOAT_TYPE_P (subt
))
11273 if (DECIMAL_FLOAT_TYPE_P (expt
) != DECIMAL_FLOAT_TYPE_P (subt
))
11276 if (TYPE_PRECISION (subt
) > TYPE_PRECISION (expt
))
11279 return strip_float_extensions (sub
);
11282 /* Strip out all handled components that produce invariant
11286 strip_invariant_refs (const_tree op
)
11288 while (handled_component_p (op
))
11290 switch (TREE_CODE (op
))
11293 case ARRAY_RANGE_REF
:
11294 if (!is_gimple_constant (TREE_OPERAND (op
, 1))
11295 || TREE_OPERAND (op
, 2) != NULL_TREE
11296 || TREE_OPERAND (op
, 3) != NULL_TREE
)
11300 case COMPONENT_REF
:
11301 if (TREE_OPERAND (op
, 2) != NULL_TREE
)
11307 op
= TREE_OPERAND (op
, 0);
11313 static GTY(()) tree gcc_eh_personality_decl
;
11315 /* Return the GCC personality function decl. */
11318 lhd_gcc_personality (void)
11320 if (!gcc_eh_personality_decl
)
11321 gcc_eh_personality_decl
= build_personality_function ("gcc");
11322 return gcc_eh_personality_decl
;
11325 /* Try to find a base info of BINFO that would have its field decl at offset
11326 OFFSET within the BINFO type and which is of EXPECTED_TYPE. If it can be
11327 found, return, otherwise return NULL_TREE. */
11330 get_binfo_at_offset (tree binfo
, HOST_WIDE_INT offset
, tree expected_type
)
11332 tree type
= BINFO_TYPE (binfo
);
11336 HOST_WIDE_INT pos
, size
;
11340 if (TYPE_MAIN_VARIANT (type
) == TYPE_MAIN_VARIANT (expected_type
))
11345 for (fld
= TYPE_FIELDS (type
); fld
; fld
= DECL_CHAIN (fld
))
11347 if (TREE_CODE (fld
) != FIELD_DECL
)
11350 pos
= int_bit_position (fld
);
11351 size
= tree_low_cst (DECL_SIZE (fld
), 1);
11352 if (pos
<= offset
&& (pos
+ size
) > offset
)
11355 if (!fld
|| TREE_CODE (TREE_TYPE (fld
)) != RECORD_TYPE
)
11358 if (!DECL_ARTIFICIAL (fld
))
11360 binfo
= TYPE_BINFO (TREE_TYPE (fld
));
11364 /* Offset 0 indicates the primary base, whose vtable contents are
11365 represented in the binfo for the derived class. */
11366 else if (offset
!= 0)
11368 tree base_binfo
, found_binfo
= NULL_TREE
;
11369 for (i
= 0; BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
11370 if (TREE_TYPE (base_binfo
) == TREE_TYPE (fld
))
11372 found_binfo
= base_binfo
;
11377 binfo
= found_binfo
;
11380 type
= TREE_TYPE (fld
);
11385 /* Returns true if X is a typedef decl. */
11388 is_typedef_decl (tree x
)
11390 return (x
&& TREE_CODE (x
) == TYPE_DECL
11391 && DECL_ORIGINAL_TYPE (x
) != NULL_TREE
);
11394 /* Returns true iff TYPE is a type variant created for a typedef. */
11397 typedef_variant_p (tree type
)
11399 return is_typedef_decl (TYPE_NAME (type
));
11402 /* Warn about a use of an identifier which was marked deprecated. */
11404 warn_deprecated_use (tree node
, tree attr
)
11408 if (node
== 0 || !warn_deprecated_decl
)
11414 attr
= DECL_ATTRIBUTES (node
);
11415 else if (TYPE_P (node
))
11417 tree decl
= TYPE_STUB_DECL (node
);
11419 attr
= lookup_attribute ("deprecated",
11420 TYPE_ATTRIBUTES (TREE_TYPE (decl
)));
11425 attr
= lookup_attribute ("deprecated", attr
);
11428 msg
= TREE_STRING_POINTER (TREE_VALUE (TREE_VALUE (attr
)));
11434 expanded_location xloc
= expand_location (DECL_SOURCE_LOCATION (node
));
11436 warning (OPT_Wdeprecated_declarations
,
11437 "%qD is deprecated (declared at %s:%d): %s",
11438 node
, xloc
.file
, xloc
.line
, msg
);
11440 warning (OPT_Wdeprecated_declarations
,
11441 "%qD is deprecated (declared at %s:%d)",
11442 node
, xloc
.file
, xloc
.line
);
11444 else if (TYPE_P (node
))
11446 tree what
= NULL_TREE
;
11447 tree decl
= TYPE_STUB_DECL (node
);
11449 if (TYPE_NAME (node
))
11451 if (TREE_CODE (TYPE_NAME (node
)) == IDENTIFIER_NODE
)
11452 what
= TYPE_NAME (node
);
11453 else if (TREE_CODE (TYPE_NAME (node
)) == TYPE_DECL
11454 && DECL_NAME (TYPE_NAME (node
)))
11455 what
= DECL_NAME (TYPE_NAME (node
));
11460 expanded_location xloc
11461 = expand_location (DECL_SOURCE_LOCATION (decl
));
11465 warning (OPT_Wdeprecated_declarations
,
11466 "%qE is deprecated (declared at %s:%d): %s",
11467 what
, xloc
.file
, xloc
.line
, msg
);
11469 warning (OPT_Wdeprecated_declarations
,
11470 "%qE is deprecated (declared at %s:%d)", what
,
11471 xloc
.file
, xloc
.line
);
11476 warning (OPT_Wdeprecated_declarations
,
11477 "type is deprecated (declared at %s:%d): %s",
11478 xloc
.file
, xloc
.line
, msg
);
11480 warning (OPT_Wdeprecated_declarations
,
11481 "type is deprecated (declared at %s:%d)",
11482 xloc
.file
, xloc
.line
);
11490 warning (OPT_Wdeprecated_declarations
, "%qE is deprecated: %s",
11493 warning (OPT_Wdeprecated_declarations
, "%qE is deprecated", what
);
11498 warning (OPT_Wdeprecated_declarations
, "type is deprecated: %s",
11501 warning (OPT_Wdeprecated_declarations
, "type is deprecated");
11507 #include "gt-tree.h"