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 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 "langhooks.h"
48 #include "tree-inline.h"
49 #include "tree-iterator.h"
50 #include "basic-block.h"
51 #include "tree-flow.h"
53 #include "pointer-set.h"
54 #include "tree-pass.h"
55 #include "langhooks-def.h"
56 #include "diagnostic.h"
57 #include "tree-diagnostic.h"
58 #include "tree-pretty-print.h"
65 /* Tree code classes. */
67 #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) TYPE,
68 #define END_OF_BASE_TREE_CODES tcc_exceptional,
70 const enum tree_code_class tree_code_type
[] = {
71 #include "all-tree.def"
75 #undef END_OF_BASE_TREE_CODES
77 /* Table indexed by tree code giving number of expression
78 operands beyond the fixed part of the node structure.
79 Not used for types or decls. */
81 #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) LENGTH,
82 #define END_OF_BASE_TREE_CODES 0,
84 const unsigned char tree_code_length
[] = {
85 #include "all-tree.def"
89 #undef END_OF_BASE_TREE_CODES
91 /* Names of tree components.
92 Used for printing out the tree and error messages. */
93 #define DEFTREECODE(SYM, NAME, TYPE, LEN) NAME,
94 #define END_OF_BASE_TREE_CODES "@dummy",
96 const char *const tree_code_name
[] = {
97 #include "all-tree.def"
101 #undef END_OF_BASE_TREE_CODES
103 /* Each tree code class has an associated string representation.
104 These must correspond to the tree_code_class entries. */
106 const char *const tree_code_class_strings
[] =
121 /* obstack.[ch] explicitly declined to prototype this. */
122 extern int _obstack_allocated_p (struct obstack
*h
, void *obj
);
124 #ifdef GATHER_STATISTICS
125 /* Statistics-gathering stuff. */
127 static int tree_code_counts
[MAX_TREE_CODES
];
128 int tree_node_counts
[(int) all_kinds
];
129 int tree_node_sizes
[(int) all_kinds
];
131 /* Keep in sync with tree.h:enum tree_node_kind. */
132 static const char * const tree_node_kind_names
[] = {
150 #endif /* GATHER_STATISTICS */
152 /* Unique id for next decl created. */
153 static GTY(()) int next_decl_uid
;
154 /* Unique id for next type created. */
155 static GTY(()) int next_type_uid
= 1;
156 /* Unique id for next debug decl created. Use negative numbers,
157 to catch erroneous uses. */
158 static GTY(()) int next_debug_decl_uid
;
160 /* Since we cannot rehash a type after it is in the table, we have to
161 keep the hash code. */
163 struct GTY(()) type_hash
{
168 /* Initial size of the hash table (rounded to next prime). */
169 #define TYPE_HASH_INITIAL_SIZE 1000
171 /* Now here is the hash table. When recording a type, it is added to
172 the slot whose index is the hash code. Note that the hash table is
173 used for several kinds of types (function types, array types and
174 array index range types, for now). While all these live in the
175 same table, they are completely independent, and the hash code is
176 computed differently for each of these. */
178 static GTY ((if_marked ("type_hash_marked_p"), param_is (struct type_hash
)))
179 htab_t type_hash_table
;
181 /* Hash table and temporary node for larger integer const values. */
182 static GTY (()) tree int_cst_node
;
183 static GTY ((if_marked ("ggc_marked_p"), param_is (union tree_node
)))
184 htab_t int_cst_hash_table
;
186 /* Hash table for optimization flags and target option flags. Use the same
187 hash table for both sets of options. Nodes for building the current
188 optimization and target option nodes. The assumption is most of the time
189 the options created will already be in the hash table, so we avoid
190 allocating and freeing up a node repeatably. */
191 static GTY (()) tree cl_optimization_node
;
192 static GTY (()) tree cl_target_option_node
;
193 static GTY ((if_marked ("ggc_marked_p"), param_is (union tree_node
)))
194 htab_t cl_option_hash_table
;
196 /* General tree->tree mapping structure for use in hash tables. */
199 static GTY ((if_marked ("tree_decl_map_marked_p"), param_is (struct tree_decl_map
)))
200 htab_t debug_expr_for_decl
;
202 static GTY ((if_marked ("tree_decl_map_marked_p"), param_is (struct tree_decl_map
)))
203 htab_t value_expr_for_decl
;
205 static GTY ((if_marked ("tree_priority_map_marked_p"),
206 param_is (struct tree_priority_map
)))
207 htab_t init_priority_for_decl
;
209 static void set_type_quals (tree
, int);
210 static int type_hash_eq (const void *, const void *);
211 static hashval_t
type_hash_hash (const void *);
212 static hashval_t
int_cst_hash_hash (const void *);
213 static int int_cst_hash_eq (const void *, const void *);
214 static hashval_t
cl_option_hash_hash (const void *);
215 static int cl_option_hash_eq (const void *, const void *);
216 static void print_type_hash_statistics (void);
217 static void print_debug_expr_statistics (void);
218 static void print_value_expr_statistics (void);
219 static int type_hash_marked_p (const void *);
220 static unsigned int type_hash_list (const_tree
, hashval_t
);
221 static unsigned int attribute_hash_list (const_tree
, hashval_t
);
223 tree global_trees
[TI_MAX
];
224 tree integer_types
[itk_none
];
226 unsigned char tree_contains_struct
[MAX_TREE_CODES
][64];
228 /* Number of operands for each OpenMP clause. */
229 unsigned const char omp_clause_num_ops
[] =
231 0, /* OMP_CLAUSE_ERROR */
232 1, /* OMP_CLAUSE_PRIVATE */
233 1, /* OMP_CLAUSE_SHARED */
234 1, /* OMP_CLAUSE_FIRSTPRIVATE */
235 2, /* OMP_CLAUSE_LASTPRIVATE */
236 4, /* OMP_CLAUSE_REDUCTION */
237 1, /* OMP_CLAUSE_COPYIN */
238 1, /* OMP_CLAUSE_COPYPRIVATE */
239 1, /* OMP_CLAUSE_IF */
240 1, /* OMP_CLAUSE_NUM_THREADS */
241 1, /* OMP_CLAUSE_SCHEDULE */
242 0, /* OMP_CLAUSE_NOWAIT */
243 0, /* OMP_CLAUSE_ORDERED */
244 0, /* OMP_CLAUSE_DEFAULT */
245 3, /* OMP_CLAUSE_COLLAPSE */
246 0 /* OMP_CLAUSE_UNTIED */
249 const char * const omp_clause_code_name
[] =
270 /* Return the tree node structure used by tree code CODE. */
272 static inline enum tree_node_structure_enum
273 tree_node_structure_for_code (enum tree_code code
)
275 switch (TREE_CODE_CLASS (code
))
277 case tcc_declaration
:
282 return TS_FIELD_DECL
;
288 return TS_LABEL_DECL
;
290 return TS_RESULT_DECL
;
291 case DEBUG_EXPR_DECL
:
294 return TS_CONST_DECL
;
298 return TS_FUNCTION_DECL
;
299 case TRANSLATION_UNIT_DECL
:
300 return TS_TRANSLATION_UNIT_DECL
;
302 return TS_DECL_NON_COMMON
;
315 default: /* tcc_constant and tcc_exceptional */
320 /* tcc_constant cases. */
321 case INTEGER_CST
: return TS_INT_CST
;
322 case REAL_CST
: return TS_REAL_CST
;
323 case FIXED_CST
: return TS_FIXED_CST
;
324 case COMPLEX_CST
: return TS_COMPLEX
;
325 case VECTOR_CST
: return TS_VECTOR
;
326 case STRING_CST
: return TS_STRING
;
327 /* tcc_exceptional cases. */
328 case ERROR_MARK
: return TS_COMMON
;
329 case IDENTIFIER_NODE
: return TS_IDENTIFIER
;
330 case TREE_LIST
: return TS_LIST
;
331 case TREE_VEC
: return TS_VEC
;
332 case SSA_NAME
: return TS_SSA_NAME
;
333 case PLACEHOLDER_EXPR
: return TS_COMMON
;
334 case STATEMENT_LIST
: return TS_STATEMENT_LIST
;
335 case BLOCK
: return TS_BLOCK
;
336 case CONSTRUCTOR
: return TS_CONSTRUCTOR
;
337 case TREE_BINFO
: return TS_BINFO
;
338 case OMP_CLAUSE
: return TS_OMP_CLAUSE
;
339 case OPTIMIZATION_NODE
: return TS_OPTIMIZATION
;
340 case TARGET_OPTION_NODE
: return TS_TARGET_OPTION
;
348 /* Initialize tree_contains_struct to describe the hierarchy of tree
352 initialize_tree_contains_struct (void)
356 for (i
= ERROR_MARK
; i
< LAST_AND_UNUSED_TREE_CODE
; i
++)
359 enum tree_node_structure_enum ts_code
;
361 code
= (enum tree_code
) i
;
362 ts_code
= tree_node_structure_for_code (code
);
364 /* Mark the TS structure itself. */
365 tree_contains_struct
[code
][ts_code
] = 1;
367 /* Mark all the structures that TS is derived from. */
383 MARK_TS_TYPED (code
);
387 case TS_DECL_MINIMAL
:
394 case TS_STATEMENT_LIST
:
396 case TS_OPTIMIZATION
:
397 case TS_TARGET_OPTION
:
398 MARK_TS_COMMON (code
);
402 MARK_TS_DECL_MINIMAL (code
);
407 MARK_TS_DECL_COMMON (code
);
410 case TS_DECL_NON_COMMON
:
411 MARK_TS_DECL_WITH_VIS (code
);
414 case TS_DECL_WITH_VIS
:
418 MARK_TS_DECL_WRTL (code
);
422 MARK_TS_DECL_COMMON (code
);
426 MARK_TS_DECL_WITH_VIS (code
);
430 case TS_FUNCTION_DECL
:
431 MARK_TS_DECL_NON_COMMON (code
);
434 case TS_TRANSLATION_UNIT_DECL
:
435 MARK_TS_DECL_COMMON (code
);
443 /* Basic consistency checks for attributes used in fold. */
444 gcc_assert (tree_contains_struct
[FUNCTION_DECL
][TS_DECL_NON_COMMON
]);
445 gcc_assert (tree_contains_struct
[TYPE_DECL
][TS_DECL_NON_COMMON
]);
446 gcc_assert (tree_contains_struct
[CONST_DECL
][TS_DECL_COMMON
]);
447 gcc_assert (tree_contains_struct
[VAR_DECL
][TS_DECL_COMMON
]);
448 gcc_assert (tree_contains_struct
[PARM_DECL
][TS_DECL_COMMON
]);
449 gcc_assert (tree_contains_struct
[RESULT_DECL
][TS_DECL_COMMON
]);
450 gcc_assert (tree_contains_struct
[FUNCTION_DECL
][TS_DECL_COMMON
]);
451 gcc_assert (tree_contains_struct
[TYPE_DECL
][TS_DECL_COMMON
]);
452 gcc_assert (tree_contains_struct
[TRANSLATION_UNIT_DECL
][TS_DECL_COMMON
]);
453 gcc_assert (tree_contains_struct
[LABEL_DECL
][TS_DECL_COMMON
]);
454 gcc_assert (tree_contains_struct
[FIELD_DECL
][TS_DECL_COMMON
]);
455 gcc_assert (tree_contains_struct
[VAR_DECL
][TS_DECL_WRTL
]);
456 gcc_assert (tree_contains_struct
[PARM_DECL
][TS_DECL_WRTL
]);
457 gcc_assert (tree_contains_struct
[RESULT_DECL
][TS_DECL_WRTL
]);
458 gcc_assert (tree_contains_struct
[FUNCTION_DECL
][TS_DECL_WRTL
]);
459 gcc_assert (tree_contains_struct
[LABEL_DECL
][TS_DECL_WRTL
]);
460 gcc_assert (tree_contains_struct
[CONST_DECL
][TS_DECL_MINIMAL
]);
461 gcc_assert (tree_contains_struct
[VAR_DECL
][TS_DECL_MINIMAL
]);
462 gcc_assert (tree_contains_struct
[PARM_DECL
][TS_DECL_MINIMAL
]);
463 gcc_assert (tree_contains_struct
[RESULT_DECL
][TS_DECL_MINIMAL
]);
464 gcc_assert (tree_contains_struct
[FUNCTION_DECL
][TS_DECL_MINIMAL
]);
465 gcc_assert (tree_contains_struct
[TYPE_DECL
][TS_DECL_MINIMAL
]);
466 gcc_assert (tree_contains_struct
[TRANSLATION_UNIT_DECL
][TS_DECL_MINIMAL
]);
467 gcc_assert (tree_contains_struct
[LABEL_DECL
][TS_DECL_MINIMAL
]);
468 gcc_assert (tree_contains_struct
[FIELD_DECL
][TS_DECL_MINIMAL
]);
469 gcc_assert (tree_contains_struct
[VAR_DECL
][TS_DECL_WITH_VIS
]);
470 gcc_assert (tree_contains_struct
[FUNCTION_DECL
][TS_DECL_WITH_VIS
]);
471 gcc_assert (tree_contains_struct
[TYPE_DECL
][TS_DECL_WITH_VIS
]);
472 gcc_assert (tree_contains_struct
[VAR_DECL
][TS_VAR_DECL
]);
473 gcc_assert (tree_contains_struct
[FIELD_DECL
][TS_FIELD_DECL
]);
474 gcc_assert (tree_contains_struct
[PARM_DECL
][TS_PARM_DECL
]);
475 gcc_assert (tree_contains_struct
[LABEL_DECL
][TS_LABEL_DECL
]);
476 gcc_assert (tree_contains_struct
[RESULT_DECL
][TS_RESULT_DECL
]);
477 gcc_assert (tree_contains_struct
[CONST_DECL
][TS_CONST_DECL
]);
478 gcc_assert (tree_contains_struct
[TYPE_DECL
][TS_TYPE_DECL
]);
479 gcc_assert (tree_contains_struct
[FUNCTION_DECL
][TS_FUNCTION_DECL
]);
480 gcc_assert (tree_contains_struct
[IMPORTED_DECL
][TS_DECL_MINIMAL
]);
481 gcc_assert (tree_contains_struct
[IMPORTED_DECL
][TS_DECL_COMMON
]);
490 /* Initialize the hash table of types. */
491 type_hash_table
= htab_create_ggc (TYPE_HASH_INITIAL_SIZE
, type_hash_hash
,
494 debug_expr_for_decl
= htab_create_ggc (512, tree_decl_map_hash
,
495 tree_decl_map_eq
, 0);
497 value_expr_for_decl
= htab_create_ggc (512, tree_decl_map_hash
,
498 tree_decl_map_eq
, 0);
499 init_priority_for_decl
= htab_create_ggc (512, tree_priority_map_hash
,
500 tree_priority_map_eq
, 0);
502 int_cst_hash_table
= htab_create_ggc (1024, int_cst_hash_hash
,
503 int_cst_hash_eq
, NULL
);
505 int_cst_node
= make_node (INTEGER_CST
);
507 cl_option_hash_table
= htab_create_ggc (64, cl_option_hash_hash
,
508 cl_option_hash_eq
, NULL
);
510 cl_optimization_node
= make_node (OPTIMIZATION_NODE
);
511 cl_target_option_node
= make_node (TARGET_OPTION_NODE
);
513 /* Initialize the tree_contains_struct array. */
514 initialize_tree_contains_struct ();
515 lang_hooks
.init_ts ();
519 /* The name of the object as the assembler will see it (but before any
520 translations made by ASM_OUTPUT_LABELREF). Often this is the same
521 as DECL_NAME. It is an IDENTIFIER_NODE. */
523 decl_assembler_name (tree decl
)
525 if (!DECL_ASSEMBLER_NAME_SET_P (decl
))
526 lang_hooks
.set_decl_assembler_name (decl
);
527 return DECL_WITH_VIS_CHECK (decl
)->decl_with_vis
.assembler_name
;
530 /* Compare ASMNAME with the DECL_ASSEMBLER_NAME of DECL. */
533 decl_assembler_name_equal (tree decl
, const_tree asmname
)
535 tree decl_asmname
= DECL_ASSEMBLER_NAME (decl
);
536 const char *decl_str
;
537 const char *asmname_str
;
540 if (decl_asmname
== asmname
)
543 decl_str
= IDENTIFIER_POINTER (decl_asmname
);
544 asmname_str
= IDENTIFIER_POINTER (asmname
);
547 /* If the target assembler name was set by the user, things are trickier.
548 We have a leading '*' to begin with. After that, it's arguable what
549 is the correct thing to do with -fleading-underscore. Arguably, we've
550 historically been doing the wrong thing in assemble_alias by always
551 printing the leading underscore. Since we're not changing that, make
552 sure user_label_prefix follows the '*' before matching. */
553 if (decl_str
[0] == '*')
555 size_t ulp_len
= strlen (user_label_prefix
);
561 else if (strncmp (decl_str
, user_label_prefix
, ulp_len
) == 0)
562 decl_str
+= ulp_len
, test
=true;
566 if (asmname_str
[0] == '*')
568 size_t ulp_len
= strlen (user_label_prefix
);
574 else if (strncmp (asmname_str
, user_label_prefix
, ulp_len
) == 0)
575 asmname_str
+= ulp_len
, test
=true;
582 return strcmp (decl_str
, asmname_str
) == 0;
585 /* Hash asmnames ignoring the user specified marks. */
588 decl_assembler_name_hash (const_tree asmname
)
590 if (IDENTIFIER_POINTER (asmname
)[0] == '*')
592 const char *decl_str
= IDENTIFIER_POINTER (asmname
) + 1;
593 size_t ulp_len
= strlen (user_label_prefix
);
597 else if (strncmp (decl_str
, user_label_prefix
, ulp_len
) == 0)
600 return htab_hash_string (decl_str
);
603 return htab_hash_string (IDENTIFIER_POINTER (asmname
));
606 /* Compute the number of bytes occupied by a tree with code CODE.
607 This function cannot be used for nodes that have variable sizes,
608 including TREE_VEC, STRING_CST, and CALL_EXPR. */
610 tree_code_size (enum tree_code code
)
612 switch (TREE_CODE_CLASS (code
))
614 case tcc_declaration
: /* A decl node */
619 return sizeof (struct tree_field_decl
);
621 return sizeof (struct tree_parm_decl
);
623 return sizeof (struct tree_var_decl
);
625 return sizeof (struct tree_label_decl
);
627 return sizeof (struct tree_result_decl
);
629 return sizeof (struct tree_const_decl
);
631 return sizeof (struct tree_type_decl
);
633 return sizeof (struct tree_function_decl
);
634 case DEBUG_EXPR_DECL
:
635 return sizeof (struct tree_decl_with_rtl
);
637 return sizeof (struct tree_decl_non_common
);
641 case tcc_type
: /* a type node */
642 return sizeof (struct tree_type
);
644 case tcc_reference
: /* a reference */
645 case tcc_expression
: /* an expression */
646 case tcc_statement
: /* an expression with side effects */
647 case tcc_comparison
: /* a comparison expression */
648 case tcc_unary
: /* a unary arithmetic expression */
649 case tcc_binary
: /* a binary arithmetic expression */
650 return (sizeof (struct tree_exp
)
651 + (TREE_CODE_LENGTH (code
) - 1) * sizeof (tree
));
653 case tcc_constant
: /* a constant */
656 case INTEGER_CST
: return sizeof (struct tree_int_cst
);
657 case REAL_CST
: return sizeof (struct tree_real_cst
);
658 case FIXED_CST
: return sizeof (struct tree_fixed_cst
);
659 case COMPLEX_CST
: return sizeof (struct tree_complex
);
660 case VECTOR_CST
: return sizeof (struct tree_vector
);
661 case STRING_CST
: gcc_unreachable ();
663 return lang_hooks
.tree_size (code
);
666 case tcc_exceptional
: /* something random, like an identifier. */
669 case IDENTIFIER_NODE
: return lang_hooks
.identifier_size
;
670 case TREE_LIST
: return sizeof (struct tree_list
);
673 case PLACEHOLDER_EXPR
: return sizeof (struct tree_common
);
676 case OMP_CLAUSE
: gcc_unreachable ();
678 case SSA_NAME
: return sizeof (struct tree_ssa_name
);
680 case STATEMENT_LIST
: return sizeof (struct tree_statement_list
);
681 case BLOCK
: return sizeof (struct tree_block
);
682 case CONSTRUCTOR
: return sizeof (struct tree_constructor
);
683 case OPTIMIZATION_NODE
: return sizeof (struct tree_optimization_option
);
684 case TARGET_OPTION_NODE
: return sizeof (struct tree_target_option
);
687 return lang_hooks
.tree_size (code
);
695 /* Compute the number of bytes occupied by NODE. This routine only
696 looks at TREE_CODE, except for those nodes that have variable sizes. */
698 tree_size (const_tree node
)
700 const enum tree_code code
= TREE_CODE (node
);
704 return (offsetof (struct tree_binfo
, base_binfos
)
705 + VEC_embedded_size (tree
, BINFO_N_BASE_BINFOS (node
)));
708 return (sizeof (struct tree_vec
)
709 + (TREE_VEC_LENGTH (node
) - 1) * sizeof (tree
));
712 return TREE_STRING_LENGTH (node
) + offsetof (struct tree_string
, str
) + 1;
715 return (sizeof (struct tree_omp_clause
)
716 + (omp_clause_num_ops
[OMP_CLAUSE_CODE (node
)] - 1)
720 if (TREE_CODE_CLASS (code
) == tcc_vl_exp
)
721 return (sizeof (struct tree_exp
)
722 + (VL_EXP_OPERAND_LENGTH (node
) - 1) * sizeof (tree
));
724 return tree_code_size (code
);
728 /* Record interesting allocation statistics for a tree node with CODE
732 record_node_allocation_statistics (enum tree_code code ATTRIBUTE_UNUSED
,
733 size_t length ATTRIBUTE_UNUSED
)
735 #ifdef GATHER_STATISTICS
736 enum tree_code_class type
= TREE_CODE_CLASS (code
);
741 case tcc_declaration
: /* A decl node */
745 case tcc_type
: /* a type node */
749 case tcc_statement
: /* an expression with side effects */
753 case tcc_reference
: /* a reference */
757 case tcc_expression
: /* an expression */
758 case tcc_comparison
: /* a comparison expression */
759 case tcc_unary
: /* a unary arithmetic expression */
760 case tcc_binary
: /* a binary arithmetic expression */
764 case tcc_constant
: /* a constant */
768 case tcc_exceptional
: /* something random, like an identifier. */
771 case IDENTIFIER_NODE
:
784 kind
= ssa_name_kind
;
796 kind
= omp_clause_kind
;
813 tree_code_counts
[(int) code
]++;
814 tree_node_counts
[(int) kind
]++;
815 tree_node_sizes
[(int) kind
] += length
;
819 /* Allocate and return a new UID from the DECL_UID namespace. */
822 allocate_decl_uid (void)
824 return next_decl_uid
++;
827 /* Return a newly allocated node of code CODE. For decl and type
828 nodes, some other fields are initialized. The rest of the node is
829 initialized to zero. This function cannot be used for TREE_VEC or
830 OMP_CLAUSE nodes, which is enforced by asserts in tree_code_size.
832 Achoo! I got a code in the node. */
835 make_node_stat (enum tree_code code MEM_STAT_DECL
)
838 enum tree_code_class type
= TREE_CODE_CLASS (code
);
839 size_t length
= tree_code_size (code
);
841 record_node_allocation_statistics (code
, length
);
843 t
= ggc_alloc_zone_cleared_tree_node_stat (
844 (code
== IDENTIFIER_NODE
) ? &tree_id_zone
: &tree_zone
,
845 length PASS_MEM_STAT
);
846 TREE_SET_CODE (t
, code
);
851 TREE_SIDE_EFFECTS (t
) = 1;
854 case tcc_declaration
:
855 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_COMMON
))
857 if (code
== FUNCTION_DECL
)
859 DECL_ALIGN (t
) = FUNCTION_BOUNDARY
;
860 DECL_MODE (t
) = FUNCTION_MODE
;
865 DECL_SOURCE_LOCATION (t
) = input_location
;
866 if (TREE_CODE (t
) == DEBUG_EXPR_DECL
)
867 DECL_UID (t
) = --next_debug_decl_uid
;
870 DECL_UID (t
) = allocate_decl_uid ();
871 SET_DECL_PT_UID (t
, -1);
873 if (TREE_CODE (t
) == LABEL_DECL
)
874 LABEL_DECL_UID (t
) = -1;
879 TYPE_UID (t
) = next_type_uid
++;
880 TYPE_ALIGN (t
) = BITS_PER_UNIT
;
881 TYPE_USER_ALIGN (t
) = 0;
882 TYPE_MAIN_VARIANT (t
) = t
;
883 TYPE_CANONICAL (t
) = t
;
885 /* Default to no attributes for type, but let target change that. */
886 TYPE_ATTRIBUTES (t
) = NULL_TREE
;
887 targetm
.set_default_type_attributes (t
);
889 /* We have not yet computed the alias set for this type. */
890 TYPE_ALIAS_SET (t
) = -1;
894 TREE_CONSTANT (t
) = 1;
903 case PREDECREMENT_EXPR
:
904 case PREINCREMENT_EXPR
:
905 case POSTDECREMENT_EXPR
:
906 case POSTINCREMENT_EXPR
:
907 /* All of these have side-effects, no matter what their
909 TREE_SIDE_EFFECTS (t
) = 1;
918 /* Other classes need no special treatment. */
925 /* Return a new node with the same contents as NODE except that its
926 TREE_CHAIN, if it has one, is zero and it has a fresh uid. */
929 copy_node_stat (tree node MEM_STAT_DECL
)
932 enum tree_code code
= TREE_CODE (node
);
935 gcc_assert (code
!= STATEMENT_LIST
);
937 length
= tree_size (node
);
938 record_node_allocation_statistics (code
, length
);
939 t
= ggc_alloc_zone_tree_node_stat (&tree_zone
, length PASS_MEM_STAT
);
940 memcpy (t
, node
, length
);
942 if (CODE_CONTAINS_STRUCT (code
, TS_COMMON
))
944 TREE_ASM_WRITTEN (t
) = 0;
945 TREE_VISITED (t
) = 0;
946 if (code
== VAR_DECL
|| code
== PARM_DECL
|| code
== RESULT_DECL
)
947 *DECL_VAR_ANN_PTR (t
) = 0;
949 if (TREE_CODE_CLASS (code
) == tcc_declaration
)
951 if (code
== DEBUG_EXPR_DECL
)
952 DECL_UID (t
) = --next_debug_decl_uid
;
955 DECL_UID (t
) = allocate_decl_uid ();
956 if (DECL_PT_UID_SET_P (node
))
957 SET_DECL_PT_UID (t
, DECL_PT_UID (node
));
959 if ((TREE_CODE (node
) == PARM_DECL
|| TREE_CODE (node
) == VAR_DECL
)
960 && DECL_HAS_VALUE_EXPR_P (node
))
962 SET_DECL_VALUE_EXPR (t
, DECL_VALUE_EXPR (node
));
963 DECL_HAS_VALUE_EXPR_P (t
) = 1;
965 if (TREE_CODE (node
) == VAR_DECL
&& DECL_HAS_INIT_PRIORITY_P (node
))
967 SET_DECL_INIT_PRIORITY (t
, DECL_INIT_PRIORITY (node
));
968 DECL_HAS_INIT_PRIORITY_P (t
) = 1;
971 else if (TREE_CODE_CLASS (code
) == tcc_type
)
973 TYPE_UID (t
) = next_type_uid
++;
974 /* The following is so that the debug code for
975 the copy is different from the original type.
976 The two statements usually duplicate each other
977 (because they clear fields of the same union),
978 but the optimizer should catch that. */
979 TYPE_SYMTAB_POINTER (t
) = 0;
980 TYPE_SYMTAB_ADDRESS (t
) = 0;
982 /* Do not copy the values cache. */
983 if (TYPE_CACHED_VALUES_P(t
))
985 TYPE_CACHED_VALUES_P (t
) = 0;
986 TYPE_CACHED_VALUES (t
) = NULL_TREE
;
993 /* Return a copy of a chain of nodes, chained through the TREE_CHAIN field.
994 For example, this can copy a list made of TREE_LIST nodes. */
997 copy_list (tree list
)
1005 head
= prev
= copy_node (list
);
1006 next
= TREE_CHAIN (list
);
1009 TREE_CHAIN (prev
) = copy_node (next
);
1010 prev
= TREE_CHAIN (prev
);
1011 next
= TREE_CHAIN (next
);
1017 /* Create an INT_CST node with a LOW value sign extended to TYPE. */
1020 build_int_cst (tree type
, HOST_WIDE_INT low
)
1022 /* Support legacy code. */
1024 type
= integer_type_node
;
1026 return double_int_to_tree (type
, shwi_to_double_int (low
));
1029 /* Create an INT_CST node with a LOW value sign extended to TYPE. */
1032 build_int_cst_type (tree type
, HOST_WIDE_INT low
)
1036 return double_int_to_tree (type
, shwi_to_double_int (low
));
1039 /* Constructs tree in type TYPE from with value given by CST. Signedness
1040 of CST is assumed to be the same as the signedness of TYPE. */
1043 double_int_to_tree (tree type
, double_int cst
)
1045 /* Size types *are* sign extended. */
1046 bool sign_extended_type
= (!TYPE_UNSIGNED (type
)
1047 || (TREE_CODE (type
) == INTEGER_TYPE
1048 && TYPE_IS_SIZETYPE (type
)));
1050 cst
= double_int_ext (cst
, TYPE_PRECISION (type
), !sign_extended_type
);
1052 return build_int_cst_wide (type
, cst
.low
, cst
.high
);
1055 /* Returns true if CST fits into range of TYPE. Signedness of CST is assumed
1056 to be the same as the signedness of TYPE. */
1059 double_int_fits_to_tree_p (const_tree type
, double_int cst
)
1061 /* Size types *are* sign extended. */
1062 bool sign_extended_type
= (!TYPE_UNSIGNED (type
)
1063 || (TREE_CODE (type
) == INTEGER_TYPE
1064 && TYPE_IS_SIZETYPE (type
)));
1067 = double_int_ext (cst
, TYPE_PRECISION (type
), !sign_extended_type
);
1069 return double_int_equal_p (cst
, ext
);
1072 /* We force the double_int CST to the range of the type TYPE by sign or
1073 zero extending it. OVERFLOWABLE indicates if we are interested in
1074 overflow of the value, when >0 we are only interested in signed
1075 overflow, for <0 we are interested in any overflow. OVERFLOWED
1076 indicates whether overflow has already occurred. CONST_OVERFLOWED
1077 indicates whether constant overflow has already occurred. We force
1078 T's value to be within range of T's type (by setting to 0 or 1 all
1079 the bits outside the type's range). We set TREE_OVERFLOWED if,
1080 OVERFLOWED is nonzero,
1081 or OVERFLOWABLE is >0 and signed overflow occurs
1082 or OVERFLOWABLE is <0 and any overflow occurs
1083 We return a new tree node for the extended double_int. The node
1084 is shared if no overflow flags are set. */
1088 force_fit_type_double (tree type
, double_int cst
, int overflowable
,
1091 bool sign_extended_type
;
1093 /* Size types *are* sign extended. */
1094 sign_extended_type
= (!TYPE_UNSIGNED (type
)
1095 || (TREE_CODE (type
) == INTEGER_TYPE
1096 && TYPE_IS_SIZETYPE (type
)));
1098 /* If we need to set overflow flags, return a new unshared node. */
1099 if (overflowed
|| !double_int_fits_to_tree_p(type
, cst
))
1103 || (overflowable
> 0 && sign_extended_type
))
1105 tree t
= make_node (INTEGER_CST
);
1106 TREE_INT_CST (t
) = double_int_ext (cst
, TYPE_PRECISION (type
),
1107 !sign_extended_type
);
1108 TREE_TYPE (t
) = type
;
1109 TREE_OVERFLOW (t
) = 1;
1114 /* Else build a shared node. */
1115 return double_int_to_tree (type
, cst
);
1118 /* These are the hash table functions for the hash table of INTEGER_CST
1119 nodes of a sizetype. */
1121 /* Return the hash code code X, an INTEGER_CST. */
1124 int_cst_hash_hash (const void *x
)
1126 const_tree
const t
= (const_tree
) x
;
1128 return (TREE_INT_CST_HIGH (t
) ^ TREE_INT_CST_LOW (t
)
1129 ^ htab_hash_pointer (TREE_TYPE (t
)));
1132 /* Return nonzero if the value represented by *X (an INTEGER_CST tree node)
1133 is the same as that given by *Y, which is the same. */
1136 int_cst_hash_eq (const void *x
, const void *y
)
1138 const_tree
const xt
= (const_tree
) x
;
1139 const_tree
const yt
= (const_tree
) y
;
1141 return (TREE_TYPE (xt
) == TREE_TYPE (yt
)
1142 && TREE_INT_CST_HIGH (xt
) == TREE_INT_CST_HIGH (yt
)
1143 && TREE_INT_CST_LOW (xt
) == TREE_INT_CST_LOW (yt
));
1146 /* Create an INT_CST node of TYPE and value HI:LOW.
1147 The returned node is always shared. For small integers we use a
1148 per-type vector cache, for larger ones we use a single hash table. */
1151 build_int_cst_wide (tree type
, unsigned HOST_WIDE_INT low
, HOST_WIDE_INT hi
)
1159 switch (TREE_CODE (type
))
1162 gcc_assert (hi
== 0 && low
== 0);
1166 case REFERENCE_TYPE
:
1167 /* Cache NULL pointer. */
1176 /* Cache false or true. */
1184 if (TYPE_UNSIGNED (type
))
1187 limit
= INTEGER_SHARE_LIMIT
;
1188 if (!hi
&& low
< (unsigned HOST_WIDE_INT
)INTEGER_SHARE_LIMIT
)
1194 limit
= INTEGER_SHARE_LIMIT
+ 1;
1195 if (!hi
&& low
< (unsigned HOST_WIDE_INT
)INTEGER_SHARE_LIMIT
)
1197 else if (hi
== -1 && low
== -(unsigned HOST_WIDE_INT
)1)
1211 /* Look for it in the type's vector of small shared ints. */
1212 if (!TYPE_CACHED_VALUES_P (type
))
1214 TYPE_CACHED_VALUES_P (type
) = 1;
1215 TYPE_CACHED_VALUES (type
) = make_tree_vec (limit
);
1218 t
= TREE_VEC_ELT (TYPE_CACHED_VALUES (type
), ix
);
1221 /* Make sure no one is clobbering the shared constant. */
1222 gcc_assert (TREE_TYPE (t
) == type
);
1223 gcc_assert (TREE_INT_CST_LOW (t
) == low
);
1224 gcc_assert (TREE_INT_CST_HIGH (t
) == hi
);
1228 /* Create a new shared int. */
1229 t
= make_node (INTEGER_CST
);
1231 TREE_INT_CST_LOW (t
) = low
;
1232 TREE_INT_CST_HIGH (t
) = hi
;
1233 TREE_TYPE (t
) = type
;
1235 TREE_VEC_ELT (TYPE_CACHED_VALUES (type
), ix
) = t
;
1240 /* Use the cache of larger shared ints. */
1243 TREE_INT_CST_LOW (int_cst_node
) = low
;
1244 TREE_INT_CST_HIGH (int_cst_node
) = hi
;
1245 TREE_TYPE (int_cst_node
) = type
;
1247 slot
= htab_find_slot (int_cst_hash_table
, int_cst_node
, INSERT
);
1251 /* Insert this one into the hash table. */
1254 /* Make a new node for next time round. */
1255 int_cst_node
= make_node (INTEGER_CST
);
1262 /* Builds an integer constant in TYPE such that lowest BITS bits are ones
1263 and the rest are zeros. */
1266 build_low_bits_mask (tree type
, unsigned bits
)
1270 gcc_assert (bits
<= TYPE_PRECISION (type
));
1272 if (bits
== TYPE_PRECISION (type
)
1273 && !TYPE_UNSIGNED (type
))
1274 /* Sign extended all-ones mask. */
1275 mask
= double_int_minus_one
;
1277 mask
= double_int_mask (bits
);
1279 return build_int_cst_wide (type
, mask
.low
, mask
.high
);
1282 /* Checks that X is integer constant that can be expressed in (unsigned)
1283 HOST_WIDE_INT without loss of precision. */
1286 cst_and_fits_in_hwi (const_tree x
)
1288 if (TREE_CODE (x
) != INTEGER_CST
)
1291 if (TYPE_PRECISION (TREE_TYPE (x
)) > HOST_BITS_PER_WIDE_INT
)
1294 return (TREE_INT_CST_HIGH (x
) == 0
1295 || TREE_INT_CST_HIGH (x
) == -1);
1298 /* Return a new VECTOR_CST node whose type is TYPE and whose values
1299 are in a list pointed to by VALS. */
1302 build_vector (tree type
, tree vals
)
1304 tree v
= make_node (VECTOR_CST
);
1309 TREE_VECTOR_CST_ELTS (v
) = vals
;
1310 TREE_TYPE (v
) = type
;
1312 /* Iterate through elements and check for overflow. */
1313 for (link
= vals
; link
; link
= TREE_CHAIN (link
))
1315 tree value
= TREE_VALUE (link
);
1318 /* Don't crash if we get an address constant. */
1319 if (!CONSTANT_CLASS_P (value
))
1322 over
|= TREE_OVERFLOW (value
);
1325 gcc_assert (cnt
== TYPE_VECTOR_SUBPARTS (type
));
1327 TREE_OVERFLOW (v
) = over
;
1331 /* Return a new VECTOR_CST node whose type is TYPE and whose values
1332 are extracted from V, a vector of CONSTRUCTOR_ELT. */
1335 build_vector_from_ctor (tree type
, VEC(constructor_elt
,gc
) *v
)
1337 tree list
= NULL_TREE
;
1338 unsigned HOST_WIDE_INT idx
;
1341 FOR_EACH_CONSTRUCTOR_VALUE (v
, idx
, value
)
1342 list
= tree_cons (NULL_TREE
, value
, list
);
1343 for (; idx
< TYPE_VECTOR_SUBPARTS (type
); ++idx
)
1344 list
= tree_cons (NULL_TREE
,
1345 build_zero_cst (TREE_TYPE (type
)), list
);
1346 return build_vector (type
, nreverse (list
));
1349 /* Build a vector of type VECTYPE where all the elements are SCs. */
1351 build_vector_from_val (tree vectype
, tree sc
)
1353 int i
, nunits
= TYPE_VECTOR_SUBPARTS (vectype
);
1354 VEC(constructor_elt
, gc
) *v
= NULL
;
1356 if (sc
== error_mark_node
)
1359 /* Verify that the vector type is suitable for SC. Note that there
1360 is some inconsistency in the type-system with respect to restrict
1361 qualifications of pointers. Vector types always have a main-variant
1362 element type and the qualification is applied to the vector-type.
1363 So TREE_TYPE (vector-type) does not return a properly qualified
1364 vector element-type. */
1365 gcc_checking_assert (types_compatible_p (TYPE_MAIN_VARIANT (TREE_TYPE (sc
)),
1366 TREE_TYPE (vectype
)));
1368 v
= VEC_alloc (constructor_elt
, gc
, nunits
);
1369 for (i
= 0; i
< nunits
; ++i
)
1370 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, sc
);
1372 if (CONSTANT_CLASS_P (sc
))
1373 return build_vector_from_ctor (vectype
, v
);
1375 return build_constructor (vectype
, v
);
1378 /* Return a new CONSTRUCTOR node whose type is TYPE and whose values
1379 are in the VEC pointed to by VALS. */
1381 build_constructor (tree type
, VEC(constructor_elt
,gc
) *vals
)
1383 tree c
= make_node (CONSTRUCTOR
);
1385 constructor_elt
*elt
;
1386 bool constant_p
= true;
1388 TREE_TYPE (c
) = type
;
1389 CONSTRUCTOR_ELTS (c
) = vals
;
1391 FOR_EACH_VEC_ELT (constructor_elt
, vals
, i
, elt
)
1392 if (!TREE_CONSTANT (elt
->value
))
1398 TREE_CONSTANT (c
) = constant_p
;
1403 /* Build a CONSTRUCTOR node made of a single initializer, with the specified
1406 build_constructor_single (tree type
, tree index
, tree value
)
1408 VEC(constructor_elt
,gc
) *v
;
1409 constructor_elt
*elt
;
1411 v
= VEC_alloc (constructor_elt
, gc
, 1);
1412 elt
= VEC_quick_push (constructor_elt
, v
, NULL
);
1416 return build_constructor (type
, v
);
1420 /* Return a new CONSTRUCTOR node whose type is TYPE and whose values
1421 are in a list pointed to by VALS. */
1423 build_constructor_from_list (tree type
, tree vals
)
1426 VEC(constructor_elt
,gc
) *v
= NULL
;
1430 v
= VEC_alloc (constructor_elt
, gc
, list_length (vals
));
1431 for (t
= vals
; t
; t
= TREE_CHAIN (t
))
1432 CONSTRUCTOR_APPEND_ELT (v
, TREE_PURPOSE (t
), TREE_VALUE (t
));
1435 return build_constructor (type
, v
);
1438 /* Return a new FIXED_CST node whose type is TYPE and value is F. */
1441 build_fixed (tree type
, FIXED_VALUE_TYPE f
)
1444 FIXED_VALUE_TYPE
*fp
;
1446 v
= make_node (FIXED_CST
);
1447 fp
= ggc_alloc_fixed_value ();
1448 memcpy (fp
, &f
, sizeof (FIXED_VALUE_TYPE
));
1450 TREE_TYPE (v
) = type
;
1451 TREE_FIXED_CST_PTR (v
) = fp
;
1455 /* Return a new REAL_CST node whose type is TYPE and value is D. */
1458 build_real (tree type
, REAL_VALUE_TYPE d
)
1461 REAL_VALUE_TYPE
*dp
;
1464 /* ??? Used to check for overflow here via CHECK_FLOAT_TYPE.
1465 Consider doing it via real_convert now. */
1467 v
= make_node (REAL_CST
);
1468 dp
= ggc_alloc_real_value ();
1469 memcpy (dp
, &d
, sizeof (REAL_VALUE_TYPE
));
1471 TREE_TYPE (v
) = type
;
1472 TREE_REAL_CST_PTR (v
) = dp
;
1473 TREE_OVERFLOW (v
) = overflow
;
1477 /* Return a new REAL_CST node whose type is TYPE
1478 and whose value is the integer value of the INTEGER_CST node I. */
1481 real_value_from_int_cst (const_tree type
, const_tree i
)
1485 /* Clear all bits of the real value type so that we can later do
1486 bitwise comparisons to see if two values are the same. */
1487 memset (&d
, 0, sizeof d
);
1489 real_from_integer (&d
, type
? TYPE_MODE (type
) : VOIDmode
,
1490 TREE_INT_CST_LOW (i
), TREE_INT_CST_HIGH (i
),
1491 TYPE_UNSIGNED (TREE_TYPE (i
)));
1495 /* Given a tree representing an integer constant I, return a tree
1496 representing the same value as a floating-point constant of type TYPE. */
1499 build_real_from_int_cst (tree type
, const_tree i
)
1502 int overflow
= TREE_OVERFLOW (i
);
1504 v
= build_real (type
, real_value_from_int_cst (type
, i
));
1506 TREE_OVERFLOW (v
) |= overflow
;
1510 /* Return a newly constructed STRING_CST node whose value is
1511 the LEN characters at STR.
1512 The TREE_TYPE is not initialized. */
1515 build_string (int len
, const char *str
)
1520 /* Do not waste bytes provided by padding of struct tree_string. */
1521 length
= len
+ offsetof (struct tree_string
, str
) + 1;
1523 record_node_allocation_statistics (STRING_CST
, length
);
1525 s
= ggc_alloc_tree_node (length
);
1527 memset (s
, 0, sizeof (struct tree_typed
));
1528 TREE_SET_CODE (s
, STRING_CST
);
1529 TREE_CONSTANT (s
) = 1;
1530 TREE_STRING_LENGTH (s
) = len
;
1531 memcpy (s
->string
.str
, str
, len
);
1532 s
->string
.str
[len
] = '\0';
1537 /* Return a newly constructed COMPLEX_CST node whose value is
1538 specified by the real and imaginary parts REAL and IMAG.
1539 Both REAL and IMAG should be constant nodes. TYPE, if specified,
1540 will be the type of the COMPLEX_CST; otherwise a new type will be made. */
1543 build_complex (tree type
, tree real
, tree imag
)
1545 tree t
= make_node (COMPLEX_CST
);
1547 TREE_REALPART (t
) = real
;
1548 TREE_IMAGPART (t
) = imag
;
1549 TREE_TYPE (t
) = type
? type
: build_complex_type (TREE_TYPE (real
));
1550 TREE_OVERFLOW (t
) = TREE_OVERFLOW (real
) | TREE_OVERFLOW (imag
);
1554 /* Return a constant of arithmetic type TYPE which is the
1555 multiplicative identity of the set TYPE. */
1558 build_one_cst (tree type
)
1560 switch (TREE_CODE (type
))
1562 case INTEGER_TYPE
: case ENUMERAL_TYPE
: case BOOLEAN_TYPE
:
1563 case POINTER_TYPE
: case REFERENCE_TYPE
:
1565 return build_int_cst (type
, 1);
1568 return build_real (type
, dconst1
);
1570 case FIXED_POINT_TYPE
:
1571 /* We can only generate 1 for accum types. */
1572 gcc_assert (ALL_SCALAR_ACCUM_MODE_P (TYPE_MODE (type
)));
1573 return build_fixed (type
, FCONST1(TYPE_MODE (type
)));
1577 tree scalar
= build_one_cst (TREE_TYPE (type
));
1579 return build_vector_from_val (type
, scalar
);
1583 return build_complex (type
,
1584 build_one_cst (TREE_TYPE (type
)),
1585 build_zero_cst (TREE_TYPE (type
)));
1592 /* Build 0 constant of type TYPE. This is used by constructor folding
1593 and thus the constant should be represented in memory by
1597 build_zero_cst (tree type
)
1599 switch (TREE_CODE (type
))
1601 case INTEGER_TYPE
: case ENUMERAL_TYPE
: case BOOLEAN_TYPE
:
1602 case POINTER_TYPE
: case REFERENCE_TYPE
:
1604 return build_int_cst (type
, 0);
1607 return build_real (type
, dconst0
);
1609 case FIXED_POINT_TYPE
:
1610 return build_fixed (type
, FCONST0 (TYPE_MODE (type
)));
1614 tree scalar
= build_zero_cst (TREE_TYPE (type
));
1616 return build_vector_from_val (type
, scalar
);
1621 tree zero
= build_zero_cst (TREE_TYPE (type
));
1623 return build_complex (type
, zero
, zero
);
1627 if (!AGGREGATE_TYPE_P (type
))
1628 return fold_convert (type
, integer_zero_node
);
1629 return build_constructor (type
, NULL
);
1634 /* Build a BINFO with LEN language slots. */
1637 make_tree_binfo_stat (unsigned base_binfos MEM_STAT_DECL
)
1640 size_t length
= (offsetof (struct tree_binfo
, base_binfos
)
1641 + VEC_embedded_size (tree
, base_binfos
));
1643 record_node_allocation_statistics (TREE_BINFO
, length
);
1645 t
= ggc_alloc_zone_tree_node_stat (&tree_zone
, length PASS_MEM_STAT
);
1647 memset (t
, 0, offsetof (struct tree_binfo
, base_binfos
));
1649 TREE_SET_CODE (t
, TREE_BINFO
);
1651 VEC_embedded_init (tree
, BINFO_BASE_BINFOS (t
), base_binfos
);
1656 /* Create a CASE_LABEL_EXPR tree node and return it. */
1659 build_case_label (tree low_value
, tree high_value
, tree label_decl
)
1661 tree t
= make_node (CASE_LABEL_EXPR
);
1663 TREE_TYPE (t
) = void_type_node
;
1664 SET_EXPR_LOCATION (t
, DECL_SOURCE_LOCATION (label_decl
));
1666 CASE_LOW (t
) = low_value
;
1667 CASE_HIGH (t
) = high_value
;
1668 CASE_LABEL (t
) = label_decl
;
1669 CASE_CHAIN (t
) = NULL_TREE
;
1674 /* Build a newly constructed TREE_VEC node of length LEN. */
1677 make_tree_vec_stat (int len MEM_STAT_DECL
)
1680 int length
= (len
- 1) * sizeof (tree
) + sizeof (struct tree_vec
);
1682 record_node_allocation_statistics (TREE_VEC
, length
);
1684 t
= ggc_alloc_zone_cleared_tree_node_stat (&tree_zone
, length PASS_MEM_STAT
);
1686 TREE_SET_CODE (t
, TREE_VEC
);
1687 TREE_VEC_LENGTH (t
) = len
;
1692 /* Return 1 if EXPR is the integer constant zero or a complex constant
1696 integer_zerop (const_tree expr
)
1700 return ((TREE_CODE (expr
) == INTEGER_CST
1701 && TREE_INT_CST_LOW (expr
) == 0
1702 && TREE_INT_CST_HIGH (expr
) == 0)
1703 || (TREE_CODE (expr
) == COMPLEX_CST
1704 && integer_zerop (TREE_REALPART (expr
))
1705 && integer_zerop (TREE_IMAGPART (expr
))));
1708 /* Return 1 if EXPR is the integer constant one or the corresponding
1709 complex constant. */
1712 integer_onep (const_tree expr
)
1716 return ((TREE_CODE (expr
) == INTEGER_CST
1717 && TREE_INT_CST_LOW (expr
) == 1
1718 && TREE_INT_CST_HIGH (expr
) == 0)
1719 || (TREE_CODE (expr
) == COMPLEX_CST
1720 && integer_onep (TREE_REALPART (expr
))
1721 && integer_zerop (TREE_IMAGPART (expr
))));
1724 /* Return 1 if EXPR is an integer containing all 1's in as much precision as
1725 it contains. Likewise for the corresponding complex constant. */
1728 integer_all_onesp (const_tree expr
)
1735 if (TREE_CODE (expr
) == COMPLEX_CST
1736 && integer_all_onesp (TREE_REALPART (expr
))
1737 && integer_zerop (TREE_IMAGPART (expr
)))
1740 else if (TREE_CODE (expr
) != INTEGER_CST
)
1743 uns
= TYPE_UNSIGNED (TREE_TYPE (expr
));
1744 if (TREE_INT_CST_LOW (expr
) == ~(unsigned HOST_WIDE_INT
) 0
1745 && TREE_INT_CST_HIGH (expr
) == -1)
1750 /* Note that using TYPE_PRECISION here is wrong. We care about the
1751 actual bits, not the (arbitrary) range of the type. */
1752 prec
= GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (expr
)));
1753 if (prec
>= HOST_BITS_PER_WIDE_INT
)
1755 HOST_WIDE_INT high_value
;
1758 shift_amount
= prec
- HOST_BITS_PER_WIDE_INT
;
1760 /* Can not handle precisions greater than twice the host int size. */
1761 gcc_assert (shift_amount
<= HOST_BITS_PER_WIDE_INT
);
1762 if (shift_amount
== HOST_BITS_PER_WIDE_INT
)
1763 /* Shifting by the host word size is undefined according to the ANSI
1764 standard, so we must handle this as a special case. */
1767 high_value
= ((HOST_WIDE_INT
) 1 << shift_amount
) - 1;
1769 return (TREE_INT_CST_LOW (expr
) == ~(unsigned HOST_WIDE_INT
) 0
1770 && TREE_INT_CST_HIGH (expr
) == high_value
);
1773 return TREE_INT_CST_LOW (expr
) == ((unsigned HOST_WIDE_INT
) 1 << prec
) - 1;
1776 /* Return 1 if EXPR is an integer constant that is a power of 2 (i.e., has only
1780 integer_pow2p (const_tree expr
)
1783 HOST_WIDE_INT high
, low
;
1787 if (TREE_CODE (expr
) == COMPLEX_CST
1788 && integer_pow2p (TREE_REALPART (expr
))
1789 && integer_zerop (TREE_IMAGPART (expr
)))
1792 if (TREE_CODE (expr
) != INTEGER_CST
)
1795 prec
= TYPE_PRECISION (TREE_TYPE (expr
));
1796 high
= TREE_INT_CST_HIGH (expr
);
1797 low
= TREE_INT_CST_LOW (expr
);
1799 /* First clear all bits that are beyond the type's precision in case
1800 we've been sign extended. */
1802 if (prec
== 2 * HOST_BITS_PER_WIDE_INT
)
1804 else if (prec
> HOST_BITS_PER_WIDE_INT
)
1805 high
&= ~((HOST_WIDE_INT
) (-1) << (prec
- HOST_BITS_PER_WIDE_INT
));
1809 if (prec
< HOST_BITS_PER_WIDE_INT
)
1810 low
&= ~((HOST_WIDE_INT
) (-1) << prec
);
1813 if (high
== 0 && low
== 0)
1816 return ((high
== 0 && (low
& (low
- 1)) == 0)
1817 || (low
== 0 && (high
& (high
- 1)) == 0));
1820 /* Return 1 if EXPR is an integer constant other than zero or a
1821 complex constant other than zero. */
1824 integer_nonzerop (const_tree expr
)
1828 return ((TREE_CODE (expr
) == INTEGER_CST
1829 && (TREE_INT_CST_LOW (expr
) != 0
1830 || TREE_INT_CST_HIGH (expr
) != 0))
1831 || (TREE_CODE (expr
) == COMPLEX_CST
1832 && (integer_nonzerop (TREE_REALPART (expr
))
1833 || integer_nonzerop (TREE_IMAGPART (expr
)))));
1836 /* Return 1 if EXPR is the fixed-point constant zero. */
1839 fixed_zerop (const_tree expr
)
1841 return (TREE_CODE (expr
) == FIXED_CST
1842 && double_int_zero_p (TREE_FIXED_CST (expr
).data
));
1845 /* Return the power of two represented by a tree node known to be a
1849 tree_log2 (const_tree expr
)
1852 HOST_WIDE_INT high
, low
;
1856 if (TREE_CODE (expr
) == COMPLEX_CST
)
1857 return tree_log2 (TREE_REALPART (expr
));
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 return (high
!= 0 ? HOST_BITS_PER_WIDE_INT
+ exact_log2 (high
)
1878 : exact_log2 (low
));
1881 /* Similar, but return the largest integer Y such that 2 ** Y is less
1882 than or equal to EXPR. */
1885 tree_floor_log2 (const_tree expr
)
1888 HOST_WIDE_INT high
, low
;
1892 if (TREE_CODE (expr
) == COMPLEX_CST
)
1893 return tree_log2 (TREE_REALPART (expr
));
1895 prec
= TYPE_PRECISION (TREE_TYPE (expr
));
1896 high
= TREE_INT_CST_HIGH (expr
);
1897 low
= TREE_INT_CST_LOW (expr
);
1899 /* First clear all bits that are beyond the type's precision in case
1900 we've been sign extended. Ignore if type's precision hasn't been set
1901 since what we are doing is setting it. */
1903 if (prec
== 2 * HOST_BITS_PER_WIDE_INT
|| prec
== 0)
1905 else if (prec
> HOST_BITS_PER_WIDE_INT
)
1906 high
&= ~((HOST_WIDE_INT
) (-1) << (prec
- HOST_BITS_PER_WIDE_INT
));
1910 if (prec
< HOST_BITS_PER_WIDE_INT
)
1911 low
&= ~((HOST_WIDE_INT
) (-1) << prec
);
1914 return (high
!= 0 ? HOST_BITS_PER_WIDE_INT
+ floor_log2 (high
)
1915 : floor_log2 (low
));
1918 /* Return 1 if EXPR is the real constant zero. Trailing zeroes matter for
1919 decimal float constants, so don't return 1 for them. */
1922 real_zerop (const_tree expr
)
1926 return ((TREE_CODE (expr
) == REAL_CST
1927 && REAL_VALUES_EQUAL (TREE_REAL_CST (expr
), dconst0
)
1928 && !(DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (expr
)))))
1929 || (TREE_CODE (expr
) == COMPLEX_CST
1930 && real_zerop (TREE_REALPART (expr
))
1931 && real_zerop (TREE_IMAGPART (expr
))));
1934 /* Return 1 if EXPR is the real constant one in real or complex form.
1935 Trailing zeroes matter for decimal float constants, so don't return
1939 real_onep (const_tree expr
)
1943 return ((TREE_CODE (expr
) == REAL_CST
1944 && REAL_VALUES_EQUAL (TREE_REAL_CST (expr
), dconst1
)
1945 && !(DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (expr
)))))
1946 || (TREE_CODE (expr
) == COMPLEX_CST
1947 && real_onep (TREE_REALPART (expr
))
1948 && real_zerop (TREE_IMAGPART (expr
))));
1951 /* Return 1 if EXPR is the real constant two. Trailing zeroes matter
1952 for decimal float constants, so don't return 1 for them. */
1955 real_twop (const_tree expr
)
1959 return ((TREE_CODE (expr
) == REAL_CST
1960 && REAL_VALUES_EQUAL (TREE_REAL_CST (expr
), dconst2
)
1961 && !(DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (expr
)))))
1962 || (TREE_CODE (expr
) == COMPLEX_CST
1963 && real_twop (TREE_REALPART (expr
))
1964 && real_zerop (TREE_IMAGPART (expr
))));
1967 /* Return 1 if EXPR is the real constant minus one. Trailing zeroes
1968 matter for decimal float constants, so don't return 1 for them. */
1971 real_minus_onep (const_tree expr
)
1975 return ((TREE_CODE (expr
) == REAL_CST
1976 && REAL_VALUES_EQUAL (TREE_REAL_CST (expr
), dconstm1
)
1977 && !(DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (expr
)))))
1978 || (TREE_CODE (expr
) == COMPLEX_CST
1979 && real_minus_onep (TREE_REALPART (expr
))
1980 && real_zerop (TREE_IMAGPART (expr
))));
1983 /* Nonzero if EXP is a constant or a cast of a constant. */
1986 really_constant_p (const_tree exp
)
1988 /* This is not quite the same as STRIP_NOPS. It does more. */
1989 while (CONVERT_EXPR_P (exp
)
1990 || TREE_CODE (exp
) == NON_LVALUE_EXPR
)
1991 exp
= TREE_OPERAND (exp
, 0);
1992 return TREE_CONSTANT (exp
);
1995 /* Return first list element whose TREE_VALUE is ELEM.
1996 Return 0 if ELEM is not in LIST. */
1999 value_member (tree elem
, tree list
)
2003 if (elem
== TREE_VALUE (list
))
2005 list
= TREE_CHAIN (list
);
2010 /* Return first list element whose TREE_PURPOSE is ELEM.
2011 Return 0 if ELEM is not in LIST. */
2014 purpose_member (const_tree elem
, tree list
)
2018 if (elem
== TREE_PURPOSE (list
))
2020 list
= TREE_CHAIN (list
);
2025 /* Return true if ELEM is in V. */
2028 vec_member (const_tree elem
, VEC(tree
,gc
) *v
)
2032 FOR_EACH_VEC_ELT (tree
, v
, ix
, t
)
2038 /* Returns element number IDX (zero-origin) of chain CHAIN, or
2042 chain_index (int idx
, tree chain
)
2044 for (; chain
&& idx
> 0; --idx
)
2045 chain
= TREE_CHAIN (chain
);
2049 /* Return nonzero if ELEM is part of the chain CHAIN. */
2052 chain_member (const_tree elem
, const_tree chain
)
2058 chain
= DECL_CHAIN (chain
);
2064 /* Return the length of a chain of nodes chained through TREE_CHAIN.
2065 We expect a null pointer to mark the end of the chain.
2066 This is the Lisp primitive `length'. */
2069 list_length (const_tree t
)
2072 #ifdef ENABLE_TREE_CHECKING
2080 #ifdef ENABLE_TREE_CHECKING
2083 gcc_assert (p
!= q
);
2091 /* Returns the number of FIELD_DECLs in TYPE. */
2094 fields_length (const_tree type
)
2096 tree t
= TYPE_FIELDS (type
);
2099 for (; t
; t
= DECL_CHAIN (t
))
2100 if (TREE_CODE (t
) == FIELD_DECL
)
2106 /* Returns the first FIELD_DECL in the TYPE_FIELDS of the RECORD_TYPE or
2107 UNION_TYPE TYPE, or NULL_TREE if none. */
2110 first_field (const_tree type
)
2112 tree t
= TYPE_FIELDS (type
);
2113 while (t
&& TREE_CODE (t
) != FIELD_DECL
)
2118 /* Concatenate two chains of nodes (chained through TREE_CHAIN)
2119 by modifying the last node in chain 1 to point to chain 2.
2120 This is the Lisp primitive `nconc'. */
2123 chainon (tree op1
, tree op2
)
2132 for (t1
= op1
; TREE_CHAIN (t1
); t1
= TREE_CHAIN (t1
))
2134 TREE_CHAIN (t1
) = op2
;
2136 #ifdef ENABLE_TREE_CHECKING
2139 for (t2
= op2
; t2
; t2
= TREE_CHAIN (t2
))
2140 gcc_assert (t2
!= t1
);
2147 /* Return the last node in a chain of nodes (chained through TREE_CHAIN). */
2150 tree_last (tree chain
)
2154 while ((next
= TREE_CHAIN (chain
)))
2159 /* Reverse the order of elements in the chain T,
2160 and return the new head of the chain (old last element). */
2165 tree prev
= 0, decl
, next
;
2166 for (decl
= t
; decl
; decl
= next
)
2168 /* We shouldn't be using this function to reverse BLOCK chains; we
2169 have blocks_nreverse for that. */
2170 gcc_checking_assert (TREE_CODE (decl
) != BLOCK
);
2171 next
= TREE_CHAIN (decl
);
2172 TREE_CHAIN (decl
) = prev
;
2178 /* Return a newly created TREE_LIST node whose
2179 purpose and value fields are PARM and VALUE. */
2182 build_tree_list_stat (tree parm
, tree value MEM_STAT_DECL
)
2184 tree t
= make_node_stat (TREE_LIST PASS_MEM_STAT
);
2185 TREE_PURPOSE (t
) = parm
;
2186 TREE_VALUE (t
) = value
;
2190 /* Build a chain of TREE_LIST nodes from a vector. */
2193 build_tree_list_vec_stat (const VEC(tree
,gc
) *vec MEM_STAT_DECL
)
2195 tree ret
= NULL_TREE
;
2199 FOR_EACH_VEC_ELT (tree
, vec
, i
, t
)
2201 *pp
= build_tree_list_stat (NULL
, t PASS_MEM_STAT
);
2202 pp
= &TREE_CHAIN (*pp
);
2207 /* Return a newly created TREE_LIST node whose
2208 purpose and value fields are PURPOSE and VALUE
2209 and whose TREE_CHAIN is CHAIN. */
2212 tree_cons_stat (tree purpose
, tree value
, tree chain MEM_STAT_DECL
)
2216 node
= ggc_alloc_zone_tree_node_stat (&tree_zone
, sizeof (struct tree_list
)
2218 memset (node
, 0, sizeof (struct tree_common
));
2220 record_node_allocation_statistics (TREE_LIST
, sizeof (struct tree_list
));
2222 TREE_SET_CODE (node
, TREE_LIST
);
2223 TREE_CHAIN (node
) = chain
;
2224 TREE_PURPOSE (node
) = purpose
;
2225 TREE_VALUE (node
) = value
;
2229 /* Return the values of the elements of a CONSTRUCTOR as a vector of
2233 ctor_to_vec (tree ctor
)
2235 VEC(tree
, gc
) *vec
= VEC_alloc (tree
, gc
, CONSTRUCTOR_NELTS (ctor
));
2239 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (ctor
), ix
, val
)
2240 VEC_quick_push (tree
, vec
, val
);
2245 /* Return the size nominally occupied by an object of type TYPE
2246 when it resides in memory. The value is measured in units of bytes,
2247 and its data type is that normally used for type sizes
2248 (which is the first type created by make_signed_type or
2249 make_unsigned_type). */
2252 size_in_bytes (const_tree type
)
2256 if (type
== error_mark_node
)
2257 return integer_zero_node
;
2259 type
= TYPE_MAIN_VARIANT (type
);
2260 t
= TYPE_SIZE_UNIT (type
);
2264 lang_hooks
.types
.incomplete_type_error (NULL_TREE
, type
);
2265 return size_zero_node
;
2271 /* Return the size of TYPE (in bytes) as a wide integer
2272 or return -1 if the size can vary or is larger than an integer. */
2275 int_size_in_bytes (const_tree type
)
2279 if (type
== error_mark_node
)
2282 type
= TYPE_MAIN_VARIANT (type
);
2283 t
= TYPE_SIZE_UNIT (type
);
2285 || TREE_CODE (t
) != INTEGER_CST
2286 || TREE_INT_CST_HIGH (t
) != 0
2287 /* If the result would appear negative, it's too big to represent. */
2288 || (HOST_WIDE_INT
) TREE_INT_CST_LOW (t
) < 0)
2291 return TREE_INT_CST_LOW (t
);
2294 /* Return the maximum size of TYPE (in bytes) as a wide integer
2295 or return -1 if the size can vary or is larger than an integer. */
2298 max_int_size_in_bytes (const_tree type
)
2300 HOST_WIDE_INT size
= -1;
2303 /* If this is an array type, check for a possible MAX_SIZE attached. */
2305 if (TREE_CODE (type
) == ARRAY_TYPE
)
2307 size_tree
= TYPE_ARRAY_MAX_SIZE (type
);
2309 if (size_tree
&& host_integerp (size_tree
, 1))
2310 size
= tree_low_cst (size_tree
, 1);
2313 /* If we still haven't been able to get a size, see if the language
2314 can compute a maximum size. */
2318 size_tree
= lang_hooks
.types
.max_size (type
);
2320 if (size_tree
&& host_integerp (size_tree
, 1))
2321 size
= tree_low_cst (size_tree
, 1);
2327 /* Returns a tree for the size of EXP in bytes. */
2330 tree_expr_size (const_tree exp
)
2333 && DECL_SIZE_UNIT (exp
) != 0)
2334 return DECL_SIZE_UNIT (exp
);
2336 return size_in_bytes (TREE_TYPE (exp
));
2339 /* Return the bit position of FIELD, in bits from the start of the record.
2340 This is a tree of type bitsizetype. */
2343 bit_position (const_tree field
)
2345 return bit_from_pos (DECL_FIELD_OFFSET (field
),
2346 DECL_FIELD_BIT_OFFSET (field
));
2349 /* Likewise, but return as an integer. It must be representable in
2350 that way (since it could be a signed value, we don't have the
2351 option of returning -1 like int_size_in_byte can. */
2354 int_bit_position (const_tree field
)
2356 return tree_low_cst (bit_position (field
), 0);
2359 /* Return the byte position of FIELD, in bytes from the start of the record.
2360 This is a tree of type sizetype. */
2363 byte_position (const_tree field
)
2365 return byte_from_pos (DECL_FIELD_OFFSET (field
),
2366 DECL_FIELD_BIT_OFFSET (field
));
2369 /* Likewise, but return as an integer. It must be representable in
2370 that way (since it could be a signed value, we don't have the
2371 option of returning -1 like int_size_in_byte can. */
2374 int_byte_position (const_tree field
)
2376 return tree_low_cst (byte_position (field
), 0);
2379 /* Return the strictest alignment, in bits, that T is known to have. */
2382 expr_align (const_tree t
)
2384 unsigned int align0
, align1
;
2386 switch (TREE_CODE (t
))
2388 CASE_CONVERT
: case NON_LVALUE_EXPR
:
2389 /* If we have conversions, we know that the alignment of the
2390 object must meet each of the alignments of the types. */
2391 align0
= expr_align (TREE_OPERAND (t
, 0));
2392 align1
= TYPE_ALIGN (TREE_TYPE (t
));
2393 return MAX (align0
, align1
);
2395 case SAVE_EXPR
: case COMPOUND_EXPR
: case MODIFY_EXPR
:
2396 case INIT_EXPR
: case TARGET_EXPR
: case WITH_CLEANUP_EXPR
:
2397 case CLEANUP_POINT_EXPR
:
2398 /* These don't change the alignment of an object. */
2399 return expr_align (TREE_OPERAND (t
, 0));
2402 /* The best we can do is say that the alignment is the least aligned
2404 align0
= expr_align (TREE_OPERAND (t
, 1));
2405 align1
= expr_align (TREE_OPERAND (t
, 2));
2406 return MIN (align0
, align1
);
2408 /* FIXME: LABEL_DECL and CONST_DECL never have DECL_ALIGN set
2409 meaningfully, it's always 1. */
2410 case LABEL_DECL
: case CONST_DECL
:
2411 case VAR_DECL
: case PARM_DECL
: case RESULT_DECL
:
2413 gcc_assert (DECL_ALIGN (t
) != 0);
2414 return DECL_ALIGN (t
);
2420 /* Otherwise take the alignment from that of the type. */
2421 return TYPE_ALIGN (TREE_TYPE (t
));
2424 /* Return, as a tree node, the number of elements for TYPE (which is an
2425 ARRAY_TYPE) minus one. This counts only elements of the top array. */
2428 array_type_nelts (const_tree type
)
2430 tree index_type
, min
, max
;
2432 /* If they did it with unspecified bounds, then we should have already
2433 given an error about it before we got here. */
2434 if (! TYPE_DOMAIN (type
))
2435 return error_mark_node
;
2437 index_type
= TYPE_DOMAIN (type
);
2438 min
= TYPE_MIN_VALUE (index_type
);
2439 max
= TYPE_MAX_VALUE (index_type
);
2441 /* TYPE_MAX_VALUE may not be set if the array has unknown length. */
2443 return error_mark_node
;
2445 return (integer_zerop (min
)
2447 : fold_build2 (MINUS_EXPR
, TREE_TYPE (max
), max
, min
));
2450 /* If arg is static -- a reference to an object in static storage -- then
2451 return the object. This is not the same as the C meaning of `static'.
2452 If arg isn't static, return NULL. */
2457 switch (TREE_CODE (arg
))
2460 /* Nested functions are static, even though taking their address will
2461 involve a trampoline as we unnest the nested function and create
2462 the trampoline on the tree level. */
2466 return ((TREE_STATIC (arg
) || DECL_EXTERNAL (arg
))
2467 && ! DECL_THREAD_LOCAL_P (arg
)
2468 && ! DECL_DLLIMPORT_P (arg
)
2472 return ((TREE_STATIC (arg
) || DECL_EXTERNAL (arg
))
2476 return TREE_STATIC (arg
) ? arg
: NULL
;
2483 /* If the thing being referenced is not a field, then it is
2484 something language specific. */
2485 gcc_assert (TREE_CODE (TREE_OPERAND (arg
, 1)) == FIELD_DECL
);
2487 /* If we are referencing a bitfield, we can't evaluate an
2488 ADDR_EXPR at compile time and so it isn't a constant. */
2489 if (DECL_BIT_FIELD (TREE_OPERAND (arg
, 1)))
2492 return staticp (TREE_OPERAND (arg
, 0));
2498 return TREE_CONSTANT (TREE_OPERAND (arg
, 0)) ? arg
: NULL
;
2501 case ARRAY_RANGE_REF
:
2502 if (TREE_CODE (TYPE_SIZE (TREE_TYPE (arg
))) == INTEGER_CST
2503 && TREE_CODE (TREE_OPERAND (arg
, 1)) == INTEGER_CST
)
2504 return staticp (TREE_OPERAND (arg
, 0));
2508 case COMPOUND_LITERAL_EXPR
:
2509 return TREE_STATIC (COMPOUND_LITERAL_EXPR_DECL (arg
)) ? arg
: NULL
;
2519 /* Return whether OP is a DECL whose address is function-invariant. */
2522 decl_address_invariant_p (const_tree op
)
2524 /* The conditions below are slightly less strict than the one in
2527 switch (TREE_CODE (op
))
2536 if ((TREE_STATIC (op
) || DECL_EXTERNAL (op
))
2537 || DECL_THREAD_LOCAL_P (op
)
2538 || DECL_CONTEXT (op
) == current_function_decl
2539 || decl_function_context (op
) == current_function_decl
)
2544 if ((TREE_STATIC (op
) || DECL_EXTERNAL (op
))
2545 || decl_function_context (op
) == current_function_decl
)
2556 /* Return whether OP is a DECL whose address is interprocedural-invariant. */
2559 decl_address_ip_invariant_p (const_tree op
)
2561 /* The conditions below are slightly less strict than the one in
2564 switch (TREE_CODE (op
))
2572 if (((TREE_STATIC (op
) || DECL_EXTERNAL (op
))
2573 && !DECL_DLLIMPORT_P (op
))
2574 || DECL_THREAD_LOCAL_P (op
))
2579 if ((TREE_STATIC (op
) || DECL_EXTERNAL (op
)))
2591 /* Return true if T is function-invariant (internal function, does
2592 not handle arithmetic; that's handled in skip_simple_arithmetic and
2593 tree_invariant_p). */
2595 static bool tree_invariant_p (tree t
);
2598 tree_invariant_p_1 (tree t
)
2602 if (TREE_CONSTANT (t
)
2603 || (TREE_READONLY (t
) && !TREE_SIDE_EFFECTS (t
)))
2606 switch (TREE_CODE (t
))
2612 op
= TREE_OPERAND (t
, 0);
2613 while (handled_component_p (op
))
2615 switch (TREE_CODE (op
))
2618 case ARRAY_RANGE_REF
:
2619 if (!tree_invariant_p (TREE_OPERAND (op
, 1))
2620 || TREE_OPERAND (op
, 2) != NULL_TREE
2621 || TREE_OPERAND (op
, 3) != NULL_TREE
)
2626 if (TREE_OPERAND (op
, 2) != NULL_TREE
)
2632 op
= TREE_OPERAND (op
, 0);
2635 return CONSTANT_CLASS_P (op
) || decl_address_invariant_p (op
);
2644 /* Return true if T is function-invariant. */
2647 tree_invariant_p (tree t
)
2649 tree inner
= skip_simple_arithmetic (t
);
2650 return tree_invariant_p_1 (inner
);
2653 /* Wrap a SAVE_EXPR around EXPR, if appropriate.
2654 Do this to any expression which may be used in more than one place,
2655 but must be evaluated only once.
2657 Normally, expand_expr would reevaluate the expression each time.
2658 Calling save_expr produces something that is evaluated and recorded
2659 the first time expand_expr is called on it. Subsequent calls to
2660 expand_expr just reuse the recorded value.
2662 The call to expand_expr that generates code that actually computes
2663 the value is the first call *at compile time*. Subsequent calls
2664 *at compile time* generate code to use the saved value.
2665 This produces correct result provided that *at run time* control
2666 always flows through the insns made by the first expand_expr
2667 before reaching the other places where the save_expr was evaluated.
2668 You, the caller of save_expr, must make sure this is so.
2670 Constants, and certain read-only nodes, are returned with no
2671 SAVE_EXPR because that is safe. Expressions containing placeholders
2672 are not touched; see tree.def for an explanation of what these
2676 save_expr (tree expr
)
2678 tree t
= fold (expr
);
2681 /* If the tree evaluates to a constant, then we don't want to hide that
2682 fact (i.e. this allows further folding, and direct checks for constants).
2683 However, a read-only object that has side effects cannot be bypassed.
2684 Since it is no problem to reevaluate literals, we just return the
2686 inner
= skip_simple_arithmetic (t
);
2687 if (TREE_CODE (inner
) == ERROR_MARK
)
2690 if (tree_invariant_p_1 (inner
))
2693 /* If INNER contains a PLACEHOLDER_EXPR, we must evaluate it each time, since
2694 it means that the size or offset of some field of an object depends on
2695 the value within another field.
2697 Note that it must not be the case that T contains both a PLACEHOLDER_EXPR
2698 and some variable since it would then need to be both evaluated once and
2699 evaluated more than once. Front-ends must assure this case cannot
2700 happen by surrounding any such subexpressions in their own SAVE_EXPR
2701 and forcing evaluation at the proper time. */
2702 if (contains_placeholder_p (inner
))
2705 t
= build1 (SAVE_EXPR
, TREE_TYPE (expr
), t
);
2706 SET_EXPR_LOCATION (t
, EXPR_LOCATION (expr
));
2708 /* This expression might be placed ahead of a jump to ensure that the
2709 value was computed on both sides of the jump. So make sure it isn't
2710 eliminated as dead. */
2711 TREE_SIDE_EFFECTS (t
) = 1;
2715 /* Look inside EXPR and into any simple arithmetic operations. Return
2716 the innermost non-arithmetic node. */
2719 skip_simple_arithmetic (tree expr
)
2723 /* We don't care about whether this can be used as an lvalue in this
2725 while (TREE_CODE (expr
) == NON_LVALUE_EXPR
)
2726 expr
= TREE_OPERAND (expr
, 0);
2728 /* If we have simple operations applied to a SAVE_EXPR or to a SAVE_EXPR and
2729 a constant, it will be more efficient to not make another SAVE_EXPR since
2730 it will allow better simplification and GCSE will be able to merge the
2731 computations if they actually occur. */
2735 if (UNARY_CLASS_P (inner
))
2736 inner
= TREE_OPERAND (inner
, 0);
2737 else if (BINARY_CLASS_P (inner
))
2739 if (tree_invariant_p (TREE_OPERAND (inner
, 1)))
2740 inner
= TREE_OPERAND (inner
, 0);
2741 else if (tree_invariant_p (TREE_OPERAND (inner
, 0)))
2742 inner
= TREE_OPERAND (inner
, 1);
2754 /* Return which tree structure is used by T. */
2756 enum tree_node_structure_enum
2757 tree_node_structure (const_tree t
)
2759 const enum tree_code code
= TREE_CODE (t
);
2760 return tree_node_structure_for_code (code
);
2763 /* Set various status flags when building a CALL_EXPR object T. */
2766 process_call_operands (tree t
)
2768 bool side_effects
= TREE_SIDE_EFFECTS (t
);
2769 bool read_only
= false;
2770 int i
= call_expr_flags (t
);
2772 /* Calls have side-effects, except those to const or pure functions. */
2773 if ((i
& ECF_LOOPING_CONST_OR_PURE
) || !(i
& (ECF_CONST
| ECF_PURE
)))
2774 side_effects
= true;
2775 /* Propagate TREE_READONLY of arguments for const functions. */
2779 if (!side_effects
|| read_only
)
2780 for (i
= 1; i
< TREE_OPERAND_LENGTH (t
); i
++)
2782 tree op
= TREE_OPERAND (t
, i
);
2783 if (op
&& TREE_SIDE_EFFECTS (op
))
2784 side_effects
= true;
2785 if (op
&& !TREE_READONLY (op
) && !CONSTANT_CLASS_P (op
))
2789 TREE_SIDE_EFFECTS (t
) = side_effects
;
2790 TREE_READONLY (t
) = read_only
;
2793 /* Return true if EXP contains a PLACEHOLDER_EXPR, i.e. if it represents a
2794 size or offset that depends on a field within a record. */
2797 contains_placeholder_p (const_tree exp
)
2799 enum tree_code code
;
2804 code
= TREE_CODE (exp
);
2805 if (code
== PLACEHOLDER_EXPR
)
2808 switch (TREE_CODE_CLASS (code
))
2811 /* Don't look at any PLACEHOLDER_EXPRs that might be in index or bit
2812 position computations since they will be converted into a
2813 WITH_RECORD_EXPR involving the reference, which will assume
2814 here will be valid. */
2815 return CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp
, 0));
2817 case tcc_exceptional
:
2818 if (code
== TREE_LIST
)
2819 return (CONTAINS_PLACEHOLDER_P (TREE_VALUE (exp
))
2820 || CONTAINS_PLACEHOLDER_P (TREE_CHAIN (exp
)));
2825 case tcc_comparison
:
2826 case tcc_expression
:
2830 /* Ignoring the first operand isn't quite right, but works best. */
2831 return CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp
, 1));
2834 return (CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp
, 0))
2835 || CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp
, 1))
2836 || CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp
, 2)));
2839 /* The save_expr function never wraps anything containing
2840 a PLACEHOLDER_EXPR. */
2847 switch (TREE_CODE_LENGTH (code
))
2850 return CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp
, 0));
2852 return (CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp
, 0))
2853 || CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp
, 1)));
2864 const_call_expr_arg_iterator iter
;
2865 FOR_EACH_CONST_CALL_EXPR_ARG (arg
, iter
, exp
)
2866 if (CONTAINS_PLACEHOLDER_P (arg
))
2880 /* Return true if any part of the structure of TYPE involves a PLACEHOLDER_EXPR
2881 directly. This includes size, bounds, qualifiers (for QUAL_UNION_TYPE) and
2885 type_contains_placeholder_1 (const_tree type
)
2887 /* If the size contains a placeholder or the parent type (component type in
2888 the case of arrays) type involves a placeholder, this type does. */
2889 if (CONTAINS_PLACEHOLDER_P (TYPE_SIZE (type
))
2890 || CONTAINS_PLACEHOLDER_P (TYPE_SIZE_UNIT (type
))
2891 || (!POINTER_TYPE_P (type
)
2893 && type_contains_placeholder_p (TREE_TYPE (type
))))
2896 /* Now do type-specific checks. Note that the last part of the check above
2897 greatly limits what we have to do below. */
2898 switch (TREE_CODE (type
))
2906 case REFERENCE_TYPE
:
2914 case FIXED_POINT_TYPE
:
2915 /* Here we just check the bounds. */
2916 return (CONTAINS_PLACEHOLDER_P (TYPE_MIN_VALUE (type
))
2917 || CONTAINS_PLACEHOLDER_P (TYPE_MAX_VALUE (type
)));
2920 /* We have already checked the component type above, so just check the
2922 return type_contains_placeholder_p (TYPE_DOMAIN (type
));
2926 case QUAL_UNION_TYPE
:
2930 for (field
= TYPE_FIELDS (type
); field
; field
= DECL_CHAIN (field
))
2931 if (TREE_CODE (field
) == FIELD_DECL
2932 && (CONTAINS_PLACEHOLDER_P (DECL_FIELD_OFFSET (field
))
2933 || (TREE_CODE (type
) == QUAL_UNION_TYPE
2934 && CONTAINS_PLACEHOLDER_P (DECL_QUALIFIER (field
)))
2935 || type_contains_placeholder_p (TREE_TYPE (field
))))
2946 /* Wrapper around above function used to cache its result. */
2949 type_contains_placeholder_p (tree type
)
2953 /* If the contains_placeholder_bits field has been initialized,
2954 then we know the answer. */
2955 if (TYPE_CONTAINS_PLACEHOLDER_INTERNAL (type
) > 0)
2956 return TYPE_CONTAINS_PLACEHOLDER_INTERNAL (type
) - 1;
2958 /* Indicate that we've seen this type node, and the answer is false.
2959 This is what we want to return if we run into recursion via fields. */
2960 TYPE_CONTAINS_PLACEHOLDER_INTERNAL (type
) = 1;
2962 /* Compute the real value. */
2963 result
= type_contains_placeholder_1 (type
);
2965 /* Store the real value. */
2966 TYPE_CONTAINS_PLACEHOLDER_INTERNAL (type
) = result
+ 1;
2971 /* Push tree EXP onto vector QUEUE if it is not already present. */
2974 push_without_duplicates (tree exp
, VEC (tree
, heap
) **queue
)
2979 FOR_EACH_VEC_ELT (tree
, *queue
, i
, iter
)
2980 if (simple_cst_equal (iter
, exp
) == 1)
2984 VEC_safe_push (tree
, heap
, *queue
, exp
);
2987 /* Given a tree EXP, find all occurences of references to fields
2988 in a PLACEHOLDER_EXPR and place them in vector REFS without
2989 duplicates. Also record VAR_DECLs and CONST_DECLs. Note that
2990 we assume here that EXP contains only arithmetic expressions
2991 or CALL_EXPRs with PLACEHOLDER_EXPRs occurring only in their
2995 find_placeholder_in_expr (tree exp
, VEC (tree
, heap
) **refs
)
2997 enum tree_code code
= TREE_CODE (exp
);
3001 /* We handle TREE_LIST and COMPONENT_REF separately. */
3002 if (code
== TREE_LIST
)
3004 FIND_PLACEHOLDER_IN_EXPR (TREE_CHAIN (exp
), refs
);
3005 FIND_PLACEHOLDER_IN_EXPR (TREE_VALUE (exp
), refs
);
3007 else if (code
== COMPONENT_REF
)
3009 for (inner
= TREE_OPERAND (exp
, 0);
3010 REFERENCE_CLASS_P (inner
);
3011 inner
= TREE_OPERAND (inner
, 0))
3014 if (TREE_CODE (inner
) == PLACEHOLDER_EXPR
)
3015 push_without_duplicates (exp
, refs
);
3017 FIND_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp
, 0), refs
);
3020 switch (TREE_CODE_CLASS (code
))
3025 case tcc_declaration
:
3026 /* Variables allocated to static storage can stay. */
3027 if (!TREE_STATIC (exp
))
3028 push_without_duplicates (exp
, refs
);
3031 case tcc_expression
:
3032 /* This is the pattern built in ada/make_aligning_type. */
3033 if (code
== ADDR_EXPR
3034 && TREE_CODE (TREE_OPERAND (exp
, 0)) == PLACEHOLDER_EXPR
)
3036 push_without_duplicates (exp
, refs
);
3040 /* Fall through... */
3042 case tcc_exceptional
:
3045 case tcc_comparison
:
3047 for (i
= 0; i
< TREE_CODE_LENGTH (code
); i
++)
3048 FIND_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp
, i
), refs
);
3052 for (i
= 1; i
< TREE_OPERAND_LENGTH (exp
); i
++)
3053 FIND_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp
, i
), refs
);
3061 /* Given a tree EXP, a FIELD_DECL F, and a replacement value R,
3062 return a tree with all occurrences of references to F in a
3063 PLACEHOLDER_EXPR replaced by R. Also handle VAR_DECLs and
3064 CONST_DECLs. Note that we assume here that EXP contains only
3065 arithmetic expressions or CALL_EXPRs with PLACEHOLDER_EXPRs
3066 occurring only in their argument list. */
3069 substitute_in_expr (tree exp
, tree f
, tree r
)
3071 enum tree_code code
= TREE_CODE (exp
);
3072 tree op0
, op1
, op2
, op3
;
3075 /* We handle TREE_LIST and COMPONENT_REF separately. */
3076 if (code
== TREE_LIST
)
3078 op0
= SUBSTITUTE_IN_EXPR (TREE_CHAIN (exp
), f
, r
);
3079 op1
= SUBSTITUTE_IN_EXPR (TREE_VALUE (exp
), f
, r
);
3080 if (op0
== TREE_CHAIN (exp
) && op1
== TREE_VALUE (exp
))
3083 return tree_cons (TREE_PURPOSE (exp
), op1
, op0
);
3085 else if (code
== COMPONENT_REF
)
3089 /* If this expression is getting a value from a PLACEHOLDER_EXPR
3090 and it is the right field, replace it with R. */
3091 for (inner
= TREE_OPERAND (exp
, 0);
3092 REFERENCE_CLASS_P (inner
);
3093 inner
= TREE_OPERAND (inner
, 0))
3097 op1
= TREE_OPERAND (exp
, 1);
3099 if (TREE_CODE (inner
) == PLACEHOLDER_EXPR
&& op1
== f
)
3102 /* If this expression hasn't been completed let, leave it alone. */
3103 if (TREE_CODE (inner
) == PLACEHOLDER_EXPR
&& !TREE_TYPE (inner
))
3106 op0
= SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp
, 0), f
, r
);
3107 if (op0
== TREE_OPERAND (exp
, 0))
3111 = fold_build3 (COMPONENT_REF
, TREE_TYPE (exp
), op0
, op1
, NULL_TREE
);
3114 switch (TREE_CODE_CLASS (code
))
3119 case tcc_declaration
:
3125 case tcc_expression
:
3129 /* Fall through... */
3131 case tcc_exceptional
:
3134 case tcc_comparison
:
3136 switch (TREE_CODE_LENGTH (code
))
3142 op0
= SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp
, 0), f
, r
);
3143 if (op0
== TREE_OPERAND (exp
, 0))
3146 new_tree
= fold_build1 (code
, TREE_TYPE (exp
), op0
);
3150 op0
= SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp
, 0), f
, r
);
3151 op1
= SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp
, 1), f
, r
);
3153 if (op0
== TREE_OPERAND (exp
, 0) && op1
== TREE_OPERAND (exp
, 1))
3156 new_tree
= fold_build2 (code
, TREE_TYPE (exp
), op0
, op1
);
3160 op0
= SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp
, 0), f
, r
);
3161 op1
= SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp
, 1), f
, r
);
3162 op2
= SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp
, 2), f
, r
);
3164 if (op0
== TREE_OPERAND (exp
, 0) && op1
== TREE_OPERAND (exp
, 1)
3165 && op2
== TREE_OPERAND (exp
, 2))
3168 new_tree
= fold_build3 (code
, TREE_TYPE (exp
), op0
, op1
, op2
);
3172 op0
= SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp
, 0), f
, r
);
3173 op1
= SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp
, 1), f
, r
);
3174 op2
= SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp
, 2), f
, r
);
3175 op3
= SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp
, 3), f
, r
);
3177 if (op0
== TREE_OPERAND (exp
, 0) && op1
== TREE_OPERAND (exp
, 1)
3178 && op2
== TREE_OPERAND (exp
, 2)
3179 && op3
== TREE_OPERAND (exp
, 3))
3183 = fold (build4 (code
, TREE_TYPE (exp
), op0
, op1
, op2
, op3
));
3195 new_tree
= NULL_TREE
;
3197 /* If we are trying to replace F with a constant, inline back
3198 functions which do nothing else than computing a value from
3199 the arguments they are passed. This makes it possible to
3200 fold partially or entirely the replacement expression. */
3201 if (CONSTANT_CLASS_P (r
) && code
== CALL_EXPR
)
3203 tree t
= maybe_inline_call_in_expr (exp
);
3205 return SUBSTITUTE_IN_EXPR (t
, f
, r
);
3208 for (i
= 1; i
< TREE_OPERAND_LENGTH (exp
); i
++)
3210 tree op
= TREE_OPERAND (exp
, i
);
3211 tree new_op
= SUBSTITUTE_IN_EXPR (op
, f
, r
);
3215 new_tree
= copy_node (exp
);
3216 TREE_OPERAND (new_tree
, i
) = new_op
;
3222 new_tree
= fold (new_tree
);
3223 if (TREE_CODE (new_tree
) == CALL_EXPR
)
3224 process_call_operands (new_tree
);
3235 TREE_READONLY (new_tree
) |= TREE_READONLY (exp
);
3237 if (code
== INDIRECT_REF
|| code
== ARRAY_REF
|| code
== ARRAY_RANGE_REF
)
3238 TREE_THIS_NOTRAP (new_tree
) |= TREE_THIS_NOTRAP (exp
);
3243 /* Similar, but look for a PLACEHOLDER_EXPR in EXP and find a replacement
3244 for it within OBJ, a tree that is an object or a chain of references. */
3247 substitute_placeholder_in_expr (tree exp
, tree obj
)
3249 enum tree_code code
= TREE_CODE (exp
);
3250 tree op0
, op1
, op2
, op3
;
3253 /* If this is a PLACEHOLDER_EXPR, see if we find a corresponding type
3254 in the chain of OBJ. */
3255 if (code
== PLACEHOLDER_EXPR
)
3257 tree need_type
= TYPE_MAIN_VARIANT (TREE_TYPE (exp
));
3260 for (elt
= obj
; elt
!= 0;
3261 elt
= ((TREE_CODE (elt
) == COMPOUND_EXPR
3262 || TREE_CODE (elt
) == COND_EXPR
)
3263 ? TREE_OPERAND (elt
, 1)
3264 : (REFERENCE_CLASS_P (elt
)
3265 || UNARY_CLASS_P (elt
)
3266 || BINARY_CLASS_P (elt
)
3267 || VL_EXP_CLASS_P (elt
)
3268 || EXPRESSION_CLASS_P (elt
))
3269 ? TREE_OPERAND (elt
, 0) : 0))
3270 if (TYPE_MAIN_VARIANT (TREE_TYPE (elt
)) == need_type
)
3273 for (elt
= obj
; elt
!= 0;
3274 elt
= ((TREE_CODE (elt
) == COMPOUND_EXPR
3275 || TREE_CODE (elt
) == COND_EXPR
)
3276 ? TREE_OPERAND (elt
, 1)
3277 : (REFERENCE_CLASS_P (elt
)
3278 || UNARY_CLASS_P (elt
)
3279 || BINARY_CLASS_P (elt
)
3280 || VL_EXP_CLASS_P (elt
)
3281 || EXPRESSION_CLASS_P (elt
))
3282 ? TREE_OPERAND (elt
, 0) : 0))
3283 if (POINTER_TYPE_P (TREE_TYPE (elt
))
3284 && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (elt
)))
3286 return fold_build1 (INDIRECT_REF
, need_type
, elt
);
3288 /* If we didn't find it, return the original PLACEHOLDER_EXPR. If it
3289 survives until RTL generation, there will be an error. */
3293 /* TREE_LIST is special because we need to look at TREE_VALUE
3294 and TREE_CHAIN, not TREE_OPERANDS. */
3295 else if (code
== TREE_LIST
)
3297 op0
= SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_CHAIN (exp
), obj
);
3298 op1
= SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_VALUE (exp
), obj
);
3299 if (op0
== TREE_CHAIN (exp
) && op1
== TREE_VALUE (exp
))
3302 return tree_cons (TREE_PURPOSE (exp
), op1
, op0
);
3305 switch (TREE_CODE_CLASS (code
))
3308 case tcc_declaration
:
3311 case tcc_exceptional
:
3314 case tcc_comparison
:
3315 case tcc_expression
:
3318 switch (TREE_CODE_LENGTH (code
))
3324 op0
= SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp
, 0), obj
);
3325 if (op0
== TREE_OPERAND (exp
, 0))
3328 new_tree
= fold_build1 (code
, TREE_TYPE (exp
), op0
);
3332 op0
= SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp
, 0), obj
);
3333 op1
= SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp
, 1), obj
);
3335 if (op0
== TREE_OPERAND (exp
, 0) && op1
== TREE_OPERAND (exp
, 1))
3338 new_tree
= fold_build2 (code
, TREE_TYPE (exp
), op0
, op1
);
3342 op0
= SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp
, 0), obj
);
3343 op1
= SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp
, 1), obj
);
3344 op2
= SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp
, 2), obj
);
3346 if (op0
== TREE_OPERAND (exp
, 0) && op1
== TREE_OPERAND (exp
, 1)
3347 && op2
== TREE_OPERAND (exp
, 2))
3350 new_tree
= fold_build3 (code
, TREE_TYPE (exp
), op0
, op1
, op2
);
3354 op0
= SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp
, 0), obj
);
3355 op1
= SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp
, 1), obj
);
3356 op2
= SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp
, 2), obj
);
3357 op3
= SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp
, 3), obj
);
3359 if (op0
== TREE_OPERAND (exp
, 0) && op1
== TREE_OPERAND (exp
, 1)
3360 && op2
== TREE_OPERAND (exp
, 2)
3361 && op3
== TREE_OPERAND (exp
, 3))
3365 = fold (build4 (code
, TREE_TYPE (exp
), op0
, op1
, op2
, op3
));
3377 new_tree
= NULL_TREE
;
3379 for (i
= 1; i
< TREE_OPERAND_LENGTH (exp
); i
++)
3381 tree op
= TREE_OPERAND (exp
, i
);
3382 tree new_op
= SUBSTITUTE_PLACEHOLDER_IN_EXPR (op
, obj
);
3386 new_tree
= copy_node (exp
);
3387 TREE_OPERAND (new_tree
, i
) = new_op
;
3393 new_tree
= fold (new_tree
);
3394 if (TREE_CODE (new_tree
) == CALL_EXPR
)
3395 process_call_operands (new_tree
);
3406 TREE_READONLY (new_tree
) |= TREE_READONLY (exp
);
3408 if (code
== INDIRECT_REF
|| code
== ARRAY_REF
|| code
== ARRAY_RANGE_REF
)
3409 TREE_THIS_NOTRAP (new_tree
) |= TREE_THIS_NOTRAP (exp
);
3414 /* Stabilize a reference so that we can use it any number of times
3415 without causing its operands to be evaluated more than once.
3416 Returns the stabilized reference. This works by means of save_expr,
3417 so see the caveats in the comments about save_expr.
3419 Also allows conversion expressions whose operands are references.
3420 Any other kind of expression is returned unchanged. */
3423 stabilize_reference (tree ref
)
3426 enum tree_code code
= TREE_CODE (ref
);
3433 /* No action is needed in this case. */
3438 case FIX_TRUNC_EXPR
:
3439 result
= build_nt (code
, stabilize_reference (TREE_OPERAND (ref
, 0)));
3443 result
= build_nt (INDIRECT_REF
,
3444 stabilize_reference_1 (TREE_OPERAND (ref
, 0)));
3448 result
= build_nt (COMPONENT_REF
,
3449 stabilize_reference (TREE_OPERAND (ref
, 0)),
3450 TREE_OPERAND (ref
, 1), NULL_TREE
);
3454 result
= build_nt (BIT_FIELD_REF
,
3455 stabilize_reference (TREE_OPERAND (ref
, 0)),
3456 stabilize_reference_1 (TREE_OPERAND (ref
, 1)),
3457 stabilize_reference_1 (TREE_OPERAND (ref
, 2)));
3461 result
= build_nt (ARRAY_REF
,
3462 stabilize_reference (TREE_OPERAND (ref
, 0)),
3463 stabilize_reference_1 (TREE_OPERAND (ref
, 1)),
3464 TREE_OPERAND (ref
, 2), TREE_OPERAND (ref
, 3));
3467 case ARRAY_RANGE_REF
:
3468 result
= build_nt (ARRAY_RANGE_REF
,
3469 stabilize_reference (TREE_OPERAND (ref
, 0)),
3470 stabilize_reference_1 (TREE_OPERAND (ref
, 1)),
3471 TREE_OPERAND (ref
, 2), TREE_OPERAND (ref
, 3));
3475 /* We cannot wrap the first expression in a SAVE_EXPR, as then
3476 it wouldn't be ignored. This matters when dealing with
3478 return stabilize_reference_1 (ref
);
3480 /* If arg isn't a kind of lvalue we recognize, make no change.
3481 Caller should recognize the error for an invalid lvalue. */
3486 return error_mark_node
;
3489 TREE_TYPE (result
) = TREE_TYPE (ref
);
3490 TREE_READONLY (result
) = TREE_READONLY (ref
);
3491 TREE_SIDE_EFFECTS (result
) = TREE_SIDE_EFFECTS (ref
);
3492 TREE_THIS_VOLATILE (result
) = TREE_THIS_VOLATILE (ref
);
3497 /* Subroutine of stabilize_reference; this is called for subtrees of
3498 references. Any expression with side-effects must be put in a SAVE_EXPR
3499 to ensure that it is only evaluated once.
3501 We don't put SAVE_EXPR nodes around everything, because assigning very
3502 simple expressions to temporaries causes us to miss good opportunities
3503 for optimizations. Among other things, the opportunity to fold in the
3504 addition of a constant into an addressing mode often gets lost, e.g.
3505 "y[i+1] += x;". In general, we take the approach that we should not make
3506 an assignment unless we are forced into it - i.e., that any non-side effect
3507 operator should be allowed, and that cse should take care of coalescing
3508 multiple utterances of the same expression should that prove fruitful. */
3511 stabilize_reference_1 (tree e
)
3514 enum tree_code code
= TREE_CODE (e
);
3516 /* We cannot ignore const expressions because it might be a reference
3517 to a const array but whose index contains side-effects. But we can
3518 ignore things that are actual constant or that already have been
3519 handled by this function. */
3521 if (tree_invariant_p (e
))
3524 switch (TREE_CODE_CLASS (code
))
3526 case tcc_exceptional
:
3528 case tcc_declaration
:
3529 case tcc_comparison
:
3531 case tcc_expression
:
3534 /* If the expression has side-effects, then encase it in a SAVE_EXPR
3535 so that it will only be evaluated once. */
3536 /* The reference (r) and comparison (<) classes could be handled as
3537 below, but it is generally faster to only evaluate them once. */
3538 if (TREE_SIDE_EFFECTS (e
))
3539 return save_expr (e
);
3543 /* Constants need no processing. In fact, we should never reach
3548 /* Division is slow and tends to be compiled with jumps,
3549 especially the division by powers of 2 that is often
3550 found inside of an array reference. So do it just once. */
3551 if (code
== TRUNC_DIV_EXPR
|| code
== TRUNC_MOD_EXPR
3552 || code
== FLOOR_DIV_EXPR
|| code
== FLOOR_MOD_EXPR
3553 || code
== CEIL_DIV_EXPR
|| code
== CEIL_MOD_EXPR
3554 || code
== ROUND_DIV_EXPR
|| code
== ROUND_MOD_EXPR
)
3555 return save_expr (e
);
3556 /* Recursively stabilize each operand. */
3557 result
= build_nt (code
, stabilize_reference_1 (TREE_OPERAND (e
, 0)),
3558 stabilize_reference_1 (TREE_OPERAND (e
, 1)));
3562 /* Recursively stabilize each operand. */
3563 result
= build_nt (code
, stabilize_reference_1 (TREE_OPERAND (e
, 0)));
3570 TREE_TYPE (result
) = TREE_TYPE (e
);
3571 TREE_READONLY (result
) = TREE_READONLY (e
);
3572 TREE_SIDE_EFFECTS (result
) = TREE_SIDE_EFFECTS (e
);
3573 TREE_THIS_VOLATILE (result
) = TREE_THIS_VOLATILE (e
);
3578 /* Low-level constructors for expressions. */
3580 /* A helper function for build1 and constant folders. Set TREE_CONSTANT,
3581 and TREE_SIDE_EFFECTS for an ADDR_EXPR. */
3584 recompute_tree_invariant_for_addr_expr (tree t
)
3587 bool tc
= true, se
= false;
3589 /* We started out assuming this address is both invariant and constant, but
3590 does not have side effects. Now go down any handled components and see if
3591 any of them involve offsets that are either non-constant or non-invariant.
3592 Also check for side-effects.
3594 ??? Note that this code makes no attempt to deal with the case where
3595 taking the address of something causes a copy due to misalignment. */
3597 #define UPDATE_FLAGS(NODE) \
3598 do { tree _node = (NODE); \
3599 if (_node && !TREE_CONSTANT (_node)) tc = false; \
3600 if (_node && TREE_SIDE_EFFECTS (_node)) se = true; } while (0)
3602 for (node
= TREE_OPERAND (t
, 0); handled_component_p (node
);
3603 node
= TREE_OPERAND (node
, 0))
3605 /* If the first operand doesn't have an ARRAY_TYPE, this is a bogus
3606 array reference (probably made temporarily by the G++ front end),
3607 so ignore all the operands. */
3608 if ((TREE_CODE (node
) == ARRAY_REF
3609 || TREE_CODE (node
) == ARRAY_RANGE_REF
)
3610 && TREE_CODE (TREE_TYPE (TREE_OPERAND (node
, 0))) == ARRAY_TYPE
)
3612 UPDATE_FLAGS (TREE_OPERAND (node
, 1));
3613 if (TREE_OPERAND (node
, 2))
3614 UPDATE_FLAGS (TREE_OPERAND (node
, 2));
3615 if (TREE_OPERAND (node
, 3))
3616 UPDATE_FLAGS (TREE_OPERAND (node
, 3));
3618 /* Likewise, just because this is a COMPONENT_REF doesn't mean we have a
3619 FIELD_DECL, apparently. The G++ front end can put something else
3620 there, at least temporarily. */
3621 else if (TREE_CODE (node
) == COMPONENT_REF
3622 && TREE_CODE (TREE_OPERAND (node
, 1)) == FIELD_DECL
)
3624 if (TREE_OPERAND (node
, 2))
3625 UPDATE_FLAGS (TREE_OPERAND (node
, 2));
3627 else if (TREE_CODE (node
) == BIT_FIELD_REF
)
3628 UPDATE_FLAGS (TREE_OPERAND (node
, 2));
3631 node
= lang_hooks
.expr_to_decl (node
, &tc
, &se
);
3633 /* Now see what's inside. If it's an INDIRECT_REF, copy our properties from
3634 the address, since &(*a)->b is a form of addition. If it's a constant, the
3635 address is constant too. If it's a decl, its address is constant if the
3636 decl is static. Everything else is not constant and, furthermore,
3637 taking the address of a volatile variable is not volatile. */
3638 if (TREE_CODE (node
) == INDIRECT_REF
3639 || TREE_CODE (node
) == MEM_REF
)
3640 UPDATE_FLAGS (TREE_OPERAND (node
, 0));
3641 else if (CONSTANT_CLASS_P (node
))
3643 else if (DECL_P (node
))
3644 tc
&= (staticp (node
) != NULL_TREE
);
3648 se
|= TREE_SIDE_EFFECTS (node
);
3652 TREE_CONSTANT (t
) = tc
;
3653 TREE_SIDE_EFFECTS (t
) = se
;
3657 /* Build an expression of code CODE, data type TYPE, and operands as
3658 specified. Expressions and reference nodes can be created this way.
3659 Constants, decls, types and misc nodes cannot be.
3661 We define 5 non-variadic functions, from 0 to 4 arguments. This is
3662 enough for all extant tree codes. */
3665 build0_stat (enum tree_code code
, tree tt MEM_STAT_DECL
)
3669 gcc_assert (TREE_CODE_LENGTH (code
) == 0);
3671 t
= make_node_stat (code PASS_MEM_STAT
);
3678 build1_stat (enum tree_code code
, tree type
, tree node MEM_STAT_DECL
)
3680 int length
= sizeof (struct tree_exp
);
3683 record_node_allocation_statistics (code
, length
);
3685 gcc_assert (TREE_CODE_LENGTH (code
) == 1);
3687 t
= ggc_alloc_zone_tree_node_stat (&tree_zone
, length PASS_MEM_STAT
);
3689 memset (t
, 0, sizeof (struct tree_common
));
3691 TREE_SET_CODE (t
, code
);
3693 TREE_TYPE (t
) = type
;
3694 SET_EXPR_LOCATION (t
, UNKNOWN_LOCATION
);
3695 TREE_OPERAND (t
, 0) = node
;
3696 TREE_BLOCK (t
) = NULL_TREE
;
3697 if (node
&& !TYPE_P (node
))
3699 TREE_SIDE_EFFECTS (t
) = TREE_SIDE_EFFECTS (node
);
3700 TREE_READONLY (t
) = TREE_READONLY (node
);
3703 if (TREE_CODE_CLASS (code
) == tcc_statement
)
3704 TREE_SIDE_EFFECTS (t
) = 1;
3708 /* All of these have side-effects, no matter what their
3710 TREE_SIDE_EFFECTS (t
) = 1;
3711 TREE_READONLY (t
) = 0;
3715 /* Whether a dereference is readonly has nothing to do with whether
3716 its operand is readonly. */
3717 TREE_READONLY (t
) = 0;
3722 recompute_tree_invariant_for_addr_expr (t
);
3726 if ((TREE_CODE_CLASS (code
) == tcc_unary
|| code
== VIEW_CONVERT_EXPR
)
3727 && node
&& !TYPE_P (node
)
3728 && TREE_CONSTANT (node
))
3729 TREE_CONSTANT (t
) = 1;
3730 if (TREE_CODE_CLASS (code
) == tcc_reference
3731 && node
&& TREE_THIS_VOLATILE (node
))
3732 TREE_THIS_VOLATILE (t
) = 1;
3739 #define PROCESS_ARG(N) \
3741 TREE_OPERAND (t, N) = arg##N; \
3742 if (arg##N &&!TYPE_P (arg##N)) \
3744 if (TREE_SIDE_EFFECTS (arg##N)) \
3746 if (!TREE_READONLY (arg##N) \
3747 && !CONSTANT_CLASS_P (arg##N)) \
3748 (void) (read_only = 0); \
3749 if (!TREE_CONSTANT (arg##N)) \
3750 (void) (constant = 0); \
3755 build2_stat (enum tree_code code
, tree tt
, tree arg0
, tree arg1 MEM_STAT_DECL
)
3757 bool constant
, read_only
, side_effects
;
3760 gcc_assert (TREE_CODE_LENGTH (code
) == 2);
3762 if ((code
== MINUS_EXPR
|| code
== PLUS_EXPR
|| code
== MULT_EXPR
)
3763 && arg0
&& arg1
&& tt
&& POINTER_TYPE_P (tt
)
3764 /* When sizetype precision doesn't match that of pointers
3765 we need to be able to build explicit extensions or truncations
3766 of the offset argument. */
3767 && TYPE_PRECISION (sizetype
) == TYPE_PRECISION (tt
))
3768 gcc_assert (TREE_CODE (arg0
) == INTEGER_CST
3769 && TREE_CODE (arg1
) == INTEGER_CST
);
3771 if (code
== POINTER_PLUS_EXPR
&& arg0
&& arg1
&& tt
)
3772 gcc_assert (POINTER_TYPE_P (tt
) && POINTER_TYPE_P (TREE_TYPE (arg0
))
3773 && INTEGRAL_TYPE_P (TREE_TYPE (arg1
))
3774 && useless_type_conversion_p (sizetype
, TREE_TYPE (arg1
)));
3776 t
= make_node_stat (code PASS_MEM_STAT
);
3779 /* Below, we automatically set TREE_SIDE_EFFECTS and TREE_READONLY for the
3780 result based on those same flags for the arguments. But if the
3781 arguments aren't really even `tree' expressions, we shouldn't be trying
3784 /* Expressions without side effects may be constant if their
3785 arguments are as well. */
3786 constant
= (TREE_CODE_CLASS (code
) == tcc_comparison
3787 || TREE_CODE_CLASS (code
) == tcc_binary
);
3789 side_effects
= TREE_SIDE_EFFECTS (t
);
3794 TREE_READONLY (t
) = read_only
;
3795 TREE_CONSTANT (t
) = constant
;
3796 TREE_SIDE_EFFECTS (t
) = side_effects
;
3797 TREE_THIS_VOLATILE (t
)
3798 = (TREE_CODE_CLASS (code
) == tcc_reference
3799 && arg0
&& TREE_THIS_VOLATILE (arg0
));
3806 build3_stat (enum tree_code code
, tree tt
, tree arg0
, tree arg1
,
3807 tree arg2 MEM_STAT_DECL
)
3809 bool constant
, read_only
, side_effects
;
3812 gcc_assert (TREE_CODE_LENGTH (code
) == 3);
3813 gcc_assert (TREE_CODE_CLASS (code
) != tcc_vl_exp
);
3815 t
= make_node_stat (code PASS_MEM_STAT
);
3820 /* As a special exception, if COND_EXPR has NULL branches, we
3821 assume that it is a gimple statement and always consider
3822 it to have side effects. */
3823 if (code
== COND_EXPR
3824 && tt
== void_type_node
3825 && arg1
== NULL_TREE
3826 && arg2
== NULL_TREE
)
3827 side_effects
= true;
3829 side_effects
= TREE_SIDE_EFFECTS (t
);
3835 if (code
== COND_EXPR
)
3836 TREE_READONLY (t
) = read_only
;
3838 TREE_SIDE_EFFECTS (t
) = side_effects
;
3839 TREE_THIS_VOLATILE (t
)
3840 = (TREE_CODE_CLASS (code
) == tcc_reference
3841 && arg0
&& TREE_THIS_VOLATILE (arg0
));
3847 build4_stat (enum tree_code code
, tree tt
, tree arg0
, tree arg1
,
3848 tree arg2
, tree arg3 MEM_STAT_DECL
)
3850 bool constant
, read_only
, side_effects
;
3853 gcc_assert (TREE_CODE_LENGTH (code
) == 4);
3855 t
= make_node_stat (code PASS_MEM_STAT
);
3858 side_effects
= TREE_SIDE_EFFECTS (t
);
3865 TREE_SIDE_EFFECTS (t
) = side_effects
;
3866 TREE_THIS_VOLATILE (t
)
3867 = (TREE_CODE_CLASS (code
) == tcc_reference
3868 && arg0
&& TREE_THIS_VOLATILE (arg0
));
3874 build5_stat (enum tree_code code
, tree tt
, tree arg0
, tree arg1
,
3875 tree arg2
, tree arg3
, tree arg4 MEM_STAT_DECL
)
3877 bool constant
, read_only
, side_effects
;
3880 gcc_assert (TREE_CODE_LENGTH (code
) == 5);
3882 t
= make_node_stat (code PASS_MEM_STAT
);
3885 side_effects
= TREE_SIDE_EFFECTS (t
);
3893 TREE_SIDE_EFFECTS (t
) = side_effects
;
3894 TREE_THIS_VOLATILE (t
)
3895 = (TREE_CODE_CLASS (code
) == tcc_reference
3896 && arg0
&& TREE_THIS_VOLATILE (arg0
));
3902 build6_stat (enum tree_code code
, tree tt
, tree arg0
, tree arg1
,
3903 tree arg2
, tree arg3
, tree arg4
, tree arg5 MEM_STAT_DECL
)
3905 bool constant
, read_only
, side_effects
;
3908 gcc_assert (code
== TARGET_MEM_REF
);
3910 t
= make_node_stat (code PASS_MEM_STAT
);
3913 side_effects
= TREE_SIDE_EFFECTS (t
);
3920 if (code
== TARGET_MEM_REF
)
3924 TREE_SIDE_EFFECTS (t
) = side_effects
;
3925 TREE_THIS_VOLATILE (t
)
3926 = (code
== TARGET_MEM_REF
3927 && arg5
&& TREE_THIS_VOLATILE (arg5
));
3932 /* Build a simple MEM_REF tree with the sematics of a plain INDIRECT_REF
3933 on the pointer PTR. */
3936 build_simple_mem_ref_loc (location_t loc
, tree ptr
)
3938 HOST_WIDE_INT offset
= 0;
3939 tree ptype
= TREE_TYPE (ptr
);
3941 /* For convenience allow addresses that collapse to a simple base
3943 if (TREE_CODE (ptr
) == ADDR_EXPR
3944 && (handled_component_p (TREE_OPERAND (ptr
, 0))
3945 || TREE_CODE (TREE_OPERAND (ptr
, 0)) == MEM_REF
))
3947 ptr
= get_addr_base_and_unit_offset (TREE_OPERAND (ptr
, 0), &offset
);
3949 ptr
= build_fold_addr_expr (ptr
);
3950 gcc_assert (is_gimple_reg (ptr
) || is_gimple_min_invariant (ptr
));
3952 tem
= build2 (MEM_REF
, TREE_TYPE (ptype
),
3953 ptr
, build_int_cst (ptype
, offset
));
3954 SET_EXPR_LOCATION (tem
, loc
);
3958 /* Return the constant offset of a MEM_REF or TARGET_MEM_REF tree T. */
3961 mem_ref_offset (const_tree t
)
3963 tree toff
= TREE_OPERAND (t
, 1);
3964 return double_int_sext (tree_to_double_int (toff
),
3965 TYPE_PRECISION (TREE_TYPE (toff
)));
3968 /* Return the pointer-type relevant for TBAA purposes from the
3969 gimple memory reference tree T. This is the type to be used for
3970 the offset operand of MEM_REF or TARGET_MEM_REF replacements of T. */
3973 reference_alias_ptr_type (const_tree t
)
3975 const_tree base
= t
;
3976 while (handled_component_p (base
))
3977 base
= TREE_OPERAND (base
, 0);
3978 if (TREE_CODE (base
) == MEM_REF
)
3979 return TREE_TYPE (TREE_OPERAND (base
, 1));
3980 else if (TREE_CODE (base
) == TARGET_MEM_REF
)
3981 return TREE_TYPE (TMR_OFFSET (base
));
3983 return build_pointer_type (TYPE_MAIN_VARIANT (TREE_TYPE (base
)));
3986 /* Return an invariant ADDR_EXPR of type TYPE taking the address of BASE
3987 offsetted by OFFSET units. */
3990 build_invariant_address (tree type
, tree base
, HOST_WIDE_INT offset
)
3992 tree ref
= fold_build2 (MEM_REF
, TREE_TYPE (type
),
3993 build_fold_addr_expr (base
),
3994 build_int_cst (ptr_type_node
, offset
));
3995 tree addr
= build1 (ADDR_EXPR
, type
, ref
);
3996 recompute_tree_invariant_for_addr_expr (addr
);
4000 /* Similar except don't specify the TREE_TYPE
4001 and leave the TREE_SIDE_EFFECTS as 0.
4002 It is permissible for arguments to be null,
4003 or even garbage if their values do not matter. */
4006 build_nt (enum tree_code code
, ...)
4013 gcc_assert (TREE_CODE_CLASS (code
) != tcc_vl_exp
);
4017 t
= make_node (code
);
4018 length
= TREE_CODE_LENGTH (code
);
4020 for (i
= 0; i
< length
; i
++)
4021 TREE_OPERAND (t
, i
) = va_arg (p
, tree
);
4027 /* Similar to build_nt, but for creating a CALL_EXPR object with a
4031 build_nt_call_vec (tree fn
, VEC(tree
,gc
) *args
)
4036 ret
= build_vl_exp (CALL_EXPR
, VEC_length (tree
, args
) + 3);
4037 CALL_EXPR_FN (ret
) = fn
;
4038 CALL_EXPR_STATIC_CHAIN (ret
) = NULL_TREE
;
4039 FOR_EACH_VEC_ELT (tree
, args
, ix
, t
)
4040 CALL_EXPR_ARG (ret
, ix
) = t
;
4044 /* Create a DECL_... node of code CODE, name NAME and data type TYPE.
4045 We do NOT enter this node in any sort of symbol table.
4047 LOC is the location of the decl.
4049 layout_decl is used to set up the decl's storage layout.
4050 Other slots are initialized to 0 or null pointers. */
4053 build_decl_stat (location_t loc
, enum tree_code code
, tree name
,
4054 tree type MEM_STAT_DECL
)
4058 t
= make_node_stat (code PASS_MEM_STAT
);
4059 DECL_SOURCE_LOCATION (t
) = loc
;
4061 /* if (type == error_mark_node)
4062 type = integer_type_node; */
4063 /* That is not done, deliberately, so that having error_mark_node
4064 as the type can suppress useless errors in the use of this variable. */
4066 DECL_NAME (t
) = name
;
4067 TREE_TYPE (t
) = type
;
4069 if (code
== VAR_DECL
|| code
== PARM_DECL
|| code
== RESULT_DECL
)
4075 /* Builds and returns function declaration with NAME and TYPE. */
4078 build_fn_decl (const char *name
, tree type
)
4080 tree id
= get_identifier (name
);
4081 tree decl
= build_decl (input_location
, FUNCTION_DECL
, id
, type
);
4083 DECL_EXTERNAL (decl
) = 1;
4084 TREE_PUBLIC (decl
) = 1;
4085 DECL_ARTIFICIAL (decl
) = 1;
4086 TREE_NOTHROW (decl
) = 1;
4091 VEC(tree
,gc
) *all_translation_units
;
4093 /* Builds a new translation-unit decl with name NAME, queues it in the
4094 global list of translation-unit decls and returns it. */
4097 build_translation_unit_decl (tree name
)
4099 tree tu
= build_decl (UNKNOWN_LOCATION
, TRANSLATION_UNIT_DECL
,
4101 TRANSLATION_UNIT_LANGUAGE (tu
) = lang_hooks
.name
;
4102 VEC_safe_push (tree
, gc
, all_translation_units
, tu
);
4107 /* BLOCK nodes are used to represent the structure of binding contours
4108 and declarations, once those contours have been exited and their contents
4109 compiled. This information is used for outputting debugging info. */
4112 build_block (tree vars
, tree subblocks
, tree supercontext
, tree chain
)
4114 tree block
= make_node (BLOCK
);
4116 BLOCK_VARS (block
) = vars
;
4117 BLOCK_SUBBLOCKS (block
) = subblocks
;
4118 BLOCK_SUPERCONTEXT (block
) = supercontext
;
4119 BLOCK_CHAIN (block
) = chain
;
4124 /* Like SET_EXPR_LOCATION, but make sure the tree can have a location.
4126 LOC is the location to use in tree T. */
4129 protected_set_expr_location (tree t
, location_t loc
)
4131 if (t
&& CAN_HAVE_LOCATION_P (t
))
4132 SET_EXPR_LOCATION (t
, loc
);
4135 /* Return a declaration like DDECL except that its DECL_ATTRIBUTES
4139 build_decl_attribute_variant (tree ddecl
, tree attribute
)
4141 DECL_ATTRIBUTES (ddecl
) = attribute
;
4145 /* Borrowed from hashtab.c iterative_hash implementation. */
4146 #define mix(a,b,c) \
4148 a -= b; a -= c; a ^= (c>>13); \
4149 b -= c; b -= a; b ^= (a<< 8); \
4150 c -= a; c -= b; c ^= ((b&0xffffffff)>>13); \
4151 a -= b; a -= c; a ^= ((c&0xffffffff)>>12); \
4152 b -= c; b -= a; b = (b ^ (a<<16)) & 0xffffffff; \
4153 c -= a; c -= b; c = (c ^ (b>> 5)) & 0xffffffff; \
4154 a -= b; a -= c; a = (a ^ (c>> 3)) & 0xffffffff; \
4155 b -= c; b -= a; b = (b ^ (a<<10)) & 0xffffffff; \
4156 c -= a; c -= b; c = (c ^ (b>>15)) & 0xffffffff; \
4160 /* Produce good hash value combining VAL and VAL2. */
4162 iterative_hash_hashval_t (hashval_t val
, hashval_t val2
)
4164 /* the golden ratio; an arbitrary value. */
4165 hashval_t a
= 0x9e3779b9;
4171 /* Produce good hash value combining VAL and VAL2. */
4173 iterative_hash_host_wide_int (HOST_WIDE_INT val
, hashval_t val2
)
4175 if (sizeof (HOST_WIDE_INT
) == sizeof (hashval_t
))
4176 return iterative_hash_hashval_t (val
, val2
);
4179 hashval_t a
= (hashval_t
) val
;
4180 /* Avoid warnings about shifting of more than the width of the type on
4181 hosts that won't execute this path. */
4183 hashval_t b
= (hashval_t
) (val
>> (sizeof (hashval_t
) * 8 + zero
));
4185 if (sizeof (HOST_WIDE_INT
) > 2 * sizeof (hashval_t
))
4187 hashval_t a
= (hashval_t
) (val
>> (sizeof (hashval_t
) * 16 + zero
));
4188 hashval_t b
= (hashval_t
) (val
>> (sizeof (hashval_t
) * 24 + zero
));
4195 /* Return a type like TTYPE except that its TYPE_ATTRIBUTE
4196 is ATTRIBUTE and its qualifiers are QUALS.
4198 Record such modified types already made so we don't make duplicates. */
4201 build_type_attribute_qual_variant (tree ttype
, tree attribute
, int quals
)
4203 if (! attribute_list_equal (TYPE_ATTRIBUTES (ttype
), attribute
))
4205 hashval_t hashcode
= 0;
4207 enum tree_code code
= TREE_CODE (ttype
);
4209 /* Building a distinct copy of a tagged type is inappropriate; it
4210 causes breakage in code that expects there to be a one-to-one
4211 relationship between a struct and its fields.
4212 build_duplicate_type is another solution (as used in
4213 handle_transparent_union_attribute), but that doesn't play well
4214 with the stronger C++ type identity model. */
4215 if (TREE_CODE (ttype
) == RECORD_TYPE
4216 || TREE_CODE (ttype
) == UNION_TYPE
4217 || TREE_CODE (ttype
) == QUAL_UNION_TYPE
4218 || TREE_CODE (ttype
) == ENUMERAL_TYPE
)
4220 warning (OPT_Wattributes
,
4221 "ignoring attributes applied to %qT after definition",
4222 TYPE_MAIN_VARIANT (ttype
));
4223 return build_qualified_type (ttype
, quals
);
4226 ttype
= build_qualified_type (ttype
, TYPE_UNQUALIFIED
);
4227 ntype
= build_distinct_type_copy (ttype
);
4229 TYPE_ATTRIBUTES (ntype
) = attribute
;
4231 hashcode
= iterative_hash_object (code
, hashcode
);
4232 if (TREE_TYPE (ntype
))
4233 hashcode
= iterative_hash_object (TYPE_HASH (TREE_TYPE (ntype
)),
4235 hashcode
= attribute_hash_list (attribute
, hashcode
);
4237 switch (TREE_CODE (ntype
))
4240 hashcode
= type_hash_list (TYPE_ARG_TYPES (ntype
), hashcode
);
4243 if (TYPE_DOMAIN (ntype
))
4244 hashcode
= iterative_hash_object (TYPE_HASH (TYPE_DOMAIN (ntype
)),
4248 hashcode
= iterative_hash_object
4249 (TREE_INT_CST_LOW (TYPE_MAX_VALUE (ntype
)), hashcode
);
4250 hashcode
= iterative_hash_object
4251 (TREE_INT_CST_HIGH (TYPE_MAX_VALUE (ntype
)), hashcode
);
4254 case FIXED_POINT_TYPE
:
4256 unsigned int precision
= TYPE_PRECISION (ntype
);
4257 hashcode
= iterative_hash_object (precision
, hashcode
);
4264 ntype
= type_hash_canon (hashcode
, ntype
);
4266 /* If the target-dependent attributes make NTYPE different from
4267 its canonical type, we will need to use structural equality
4268 checks for this type. */
4269 if (TYPE_STRUCTURAL_EQUALITY_P (ttype
)
4270 || !comp_type_attributes (ntype
, ttype
))
4271 SET_TYPE_STRUCTURAL_EQUALITY (ntype
);
4272 else if (TYPE_CANONICAL (ntype
) == ntype
)
4273 TYPE_CANONICAL (ntype
) = TYPE_CANONICAL (ttype
);
4275 ttype
= build_qualified_type (ntype
, quals
);
4277 else if (TYPE_QUALS (ttype
) != quals
)
4278 ttype
= build_qualified_type (ttype
, quals
);
4283 /* Compare two attributes for their value identity. Return true if the
4284 attribute values are known to be equal; otherwise return false.
4288 attribute_value_equal (const_tree attr1
, const_tree attr2
)
4290 if (TREE_VALUE (attr1
) == TREE_VALUE (attr2
))
4293 if (TREE_VALUE (attr1
) != NULL_TREE
4294 && TREE_CODE (TREE_VALUE (attr1
)) == TREE_LIST
4295 && TREE_VALUE (attr2
) != NULL
4296 && TREE_CODE (TREE_VALUE (attr2
)) == TREE_LIST
)
4297 return (simple_cst_list_equal (TREE_VALUE (attr1
),
4298 TREE_VALUE (attr2
)) == 1);
4300 return (simple_cst_equal (TREE_VALUE (attr1
), TREE_VALUE (attr2
)) == 1);
4303 /* Return 0 if the attributes for two types are incompatible, 1 if they
4304 are compatible, and 2 if they are nearly compatible (which causes a
4305 warning to be generated). */
4307 comp_type_attributes (const_tree type1
, const_tree type2
)
4309 const_tree a1
= TYPE_ATTRIBUTES (type1
);
4310 const_tree a2
= TYPE_ATTRIBUTES (type2
);
4315 for (a
= a1
; a
!= NULL_TREE
; a
= TREE_CHAIN (a
))
4317 const struct attribute_spec
*as
;
4320 as
= lookup_attribute_spec (TREE_PURPOSE (a
));
4321 if (!as
|| as
->affects_type_identity
== false)
4324 attr
= lookup_attribute (as
->name
, CONST_CAST_TREE (a2
));
4325 if (!attr
|| !attribute_value_equal (a
, attr
))
4330 for (a
= a2
; a
!= NULL_TREE
; a
= TREE_CHAIN (a
))
4332 const struct attribute_spec
*as
;
4334 as
= lookup_attribute_spec (TREE_PURPOSE (a
));
4335 if (!as
|| as
->affects_type_identity
== false)
4338 if (!lookup_attribute (as
->name
, CONST_CAST_TREE (a1
)))
4340 /* We don't need to compare trees again, as we did this
4341 already in first loop. */
4343 /* All types - affecting identity - are equal, so
4344 there is no need to call target hook for comparison. */
4348 /* As some type combinations - like default calling-convention - might
4349 be compatible, we have to call the target hook to get the final result. */
4350 return targetm
.comp_type_attributes (type1
, type2
);
4353 /* Return a type like TTYPE except that its TYPE_ATTRIBUTE
4356 Record such modified types already made so we don't make duplicates. */
4359 build_type_attribute_variant (tree ttype
, tree attribute
)
4361 return build_type_attribute_qual_variant (ttype
, attribute
,
4362 TYPE_QUALS (ttype
));
4366 /* Reset the expression *EXPR_P, a size or position.
4368 ??? We could reset all non-constant sizes or positions. But it's cheap
4369 enough to not do so and refrain from adding workarounds to dwarf2out.c.
4371 We need to reset self-referential sizes or positions because they cannot
4372 be gimplified and thus can contain a CALL_EXPR after the gimplification
4373 is finished, which will run afoul of LTO streaming. And they need to be
4374 reset to something essentially dummy but not constant, so as to preserve
4375 the properties of the object they are attached to. */
4378 free_lang_data_in_one_sizepos (tree
*expr_p
)
4380 tree expr
= *expr_p
;
4381 if (CONTAINS_PLACEHOLDER_P (expr
))
4382 *expr_p
= build0 (PLACEHOLDER_EXPR
, TREE_TYPE (expr
));
4386 /* Reset all the fields in a binfo node BINFO. We only keep
4387 BINFO_VIRTUALS, which is used by gimple_fold_obj_type_ref. */
4390 free_lang_data_in_binfo (tree binfo
)
4395 gcc_assert (TREE_CODE (binfo
) == TREE_BINFO
);
4397 BINFO_VTABLE (binfo
) = NULL_TREE
;
4398 BINFO_BASE_ACCESSES (binfo
) = NULL
;
4399 BINFO_INHERITANCE_CHAIN (binfo
) = NULL_TREE
;
4400 BINFO_SUBVTT_INDEX (binfo
) = NULL_TREE
;
4402 FOR_EACH_VEC_ELT (tree
, BINFO_BASE_BINFOS (binfo
), i
, t
)
4403 free_lang_data_in_binfo (t
);
4407 /* Reset all language specific information still present in TYPE. */
4410 free_lang_data_in_type (tree type
)
4412 gcc_assert (TYPE_P (type
));
4414 /* Give the FE a chance to remove its own data first. */
4415 lang_hooks
.free_lang_data (type
);
4417 TREE_LANG_FLAG_0 (type
) = 0;
4418 TREE_LANG_FLAG_1 (type
) = 0;
4419 TREE_LANG_FLAG_2 (type
) = 0;
4420 TREE_LANG_FLAG_3 (type
) = 0;
4421 TREE_LANG_FLAG_4 (type
) = 0;
4422 TREE_LANG_FLAG_5 (type
) = 0;
4423 TREE_LANG_FLAG_6 (type
) = 0;
4425 if (TREE_CODE (type
) == FUNCTION_TYPE
)
4427 /* Remove the const and volatile qualifiers from arguments. The
4428 C++ front end removes them, but the C front end does not,
4429 leading to false ODR violation errors when merging two
4430 instances of the same function signature compiled by
4431 different front ends. */
4434 for (p
= TYPE_ARG_TYPES (type
); p
; p
= TREE_CHAIN (p
))
4436 tree arg_type
= TREE_VALUE (p
);
4438 if (TYPE_READONLY (arg_type
) || TYPE_VOLATILE (arg_type
))
4440 int quals
= TYPE_QUALS (arg_type
)
4442 & ~TYPE_QUAL_VOLATILE
;
4443 TREE_VALUE (p
) = build_qualified_type (arg_type
, quals
);
4444 free_lang_data_in_type (TREE_VALUE (p
));
4449 /* Remove members that are not actually FIELD_DECLs from the field
4450 list of an aggregate. These occur in C++. */
4451 if (RECORD_OR_UNION_TYPE_P (type
))
4455 /* Note that TYPE_FIELDS can be shared across distinct
4456 TREE_TYPEs. Therefore, if the first field of TYPE_FIELDS is
4457 to be removed, we cannot set its TREE_CHAIN to NULL.
4458 Otherwise, we would not be able to find all the other fields
4459 in the other instances of this TREE_TYPE.
4461 This was causing an ICE in testsuite/g++.dg/lto/20080915.C. */
4463 member
= TYPE_FIELDS (type
);
4466 if (TREE_CODE (member
) == FIELD_DECL
)
4469 TREE_CHAIN (prev
) = member
;
4471 TYPE_FIELDS (type
) = member
;
4475 member
= TREE_CHAIN (member
);
4479 TREE_CHAIN (prev
) = NULL_TREE
;
4481 TYPE_FIELDS (type
) = NULL_TREE
;
4483 TYPE_METHODS (type
) = NULL_TREE
;
4484 if (TYPE_BINFO (type
))
4485 free_lang_data_in_binfo (TYPE_BINFO (type
));
4489 /* For non-aggregate types, clear out the language slot (which
4490 overloads TYPE_BINFO). */
4491 TYPE_LANG_SLOT_1 (type
) = NULL_TREE
;
4493 if (INTEGRAL_TYPE_P (type
)
4494 || SCALAR_FLOAT_TYPE_P (type
)
4495 || FIXED_POINT_TYPE_P (type
))
4497 free_lang_data_in_one_sizepos (&TYPE_MIN_VALUE (type
));
4498 free_lang_data_in_one_sizepos (&TYPE_MAX_VALUE (type
));
4502 free_lang_data_in_one_sizepos (&TYPE_SIZE (type
));
4503 free_lang_data_in_one_sizepos (&TYPE_SIZE_UNIT (type
));
4505 if (debug_info_level
< DINFO_LEVEL_TERSE
4506 || (TYPE_CONTEXT (type
)
4507 && TREE_CODE (TYPE_CONTEXT (type
)) != FUNCTION_DECL
4508 && TREE_CODE (TYPE_CONTEXT (type
)) != NAMESPACE_DECL
))
4509 TYPE_CONTEXT (type
) = NULL_TREE
;
4511 if (debug_info_level
< DINFO_LEVEL_TERSE
)
4512 TYPE_STUB_DECL (type
) = NULL_TREE
;
4516 /* Return true if DECL may need an assembler name to be set. */
4519 need_assembler_name_p (tree decl
)
4521 /* Only FUNCTION_DECLs and VAR_DECLs are considered. */
4522 if (TREE_CODE (decl
) != FUNCTION_DECL
4523 && TREE_CODE (decl
) != VAR_DECL
)
4526 /* If DECL already has its assembler name set, it does not need a
4528 if (!HAS_DECL_ASSEMBLER_NAME_P (decl
)
4529 || DECL_ASSEMBLER_NAME_SET_P (decl
))
4532 /* Abstract decls do not need an assembler name. */
4533 if (DECL_ABSTRACT (decl
))
4536 /* For VAR_DECLs, only static, public and external symbols need an
4538 if (TREE_CODE (decl
) == VAR_DECL
4539 && !TREE_STATIC (decl
)
4540 && !TREE_PUBLIC (decl
)
4541 && !DECL_EXTERNAL (decl
))
4544 if (TREE_CODE (decl
) == FUNCTION_DECL
)
4546 /* Do not set assembler name on builtins. Allow RTL expansion to
4547 decide whether to expand inline or via a regular call. */
4548 if (DECL_BUILT_IN (decl
)
4549 && DECL_BUILT_IN_CLASS (decl
) != BUILT_IN_FRONTEND
)
4552 /* Functions represented in the callgraph need an assembler name. */
4553 if (cgraph_get_node (decl
) != NULL
)
4556 /* Unused and not public functions don't need an assembler name. */
4557 if (!TREE_USED (decl
) && !TREE_PUBLIC (decl
))
4565 /* Reset all language specific information still present in symbol
4569 free_lang_data_in_decl (tree decl
)
4571 gcc_assert (DECL_P (decl
));
4573 /* Give the FE a chance to remove its own data first. */
4574 lang_hooks
.free_lang_data (decl
);
4576 TREE_LANG_FLAG_0 (decl
) = 0;
4577 TREE_LANG_FLAG_1 (decl
) = 0;
4578 TREE_LANG_FLAG_2 (decl
) = 0;
4579 TREE_LANG_FLAG_3 (decl
) = 0;
4580 TREE_LANG_FLAG_4 (decl
) = 0;
4581 TREE_LANG_FLAG_5 (decl
) = 0;
4582 TREE_LANG_FLAG_6 (decl
) = 0;
4584 free_lang_data_in_one_sizepos (&DECL_SIZE (decl
));
4585 free_lang_data_in_one_sizepos (&DECL_SIZE_UNIT (decl
));
4586 if (TREE_CODE (decl
) == FIELD_DECL
)
4587 free_lang_data_in_one_sizepos (&DECL_FIELD_OFFSET (decl
));
4589 /* DECL_FCONTEXT is only used for debug info generation. */
4590 if (TREE_CODE (decl
) == FIELD_DECL
4591 && debug_info_level
< DINFO_LEVEL_TERSE
)
4592 DECL_FCONTEXT (decl
) = NULL_TREE
;
4594 if (TREE_CODE (decl
) == FUNCTION_DECL
)
4596 if (gimple_has_body_p (decl
))
4600 /* If DECL has a gimple body, then the context for its
4601 arguments must be DECL. Otherwise, it doesn't really
4602 matter, as we will not be emitting any code for DECL. In
4603 general, there may be other instances of DECL created by
4604 the front end and since PARM_DECLs are generally shared,
4605 their DECL_CONTEXT changes as the replicas of DECL are
4606 created. The only time where DECL_CONTEXT is important
4607 is for the FUNCTION_DECLs that have a gimple body (since
4608 the PARM_DECL will be used in the function's body). */
4609 for (t
= DECL_ARGUMENTS (decl
); t
; t
= TREE_CHAIN (t
))
4610 DECL_CONTEXT (t
) = decl
;
4613 /* DECL_SAVED_TREE holds the GENERIC representation for DECL.
4614 At this point, it is not needed anymore. */
4615 DECL_SAVED_TREE (decl
) = NULL_TREE
;
4617 /* Clear the abstract origin if it refers to a method. Otherwise
4618 dwarf2out.c will ICE as we clear TYPE_METHODS and thus the
4619 origin will not be output correctly. */
4620 if (DECL_ABSTRACT_ORIGIN (decl
)
4621 && DECL_CONTEXT (DECL_ABSTRACT_ORIGIN (decl
))
4622 && RECORD_OR_UNION_TYPE_P
4623 (DECL_CONTEXT (DECL_ABSTRACT_ORIGIN (decl
))))
4624 DECL_ABSTRACT_ORIGIN (decl
) = NULL_TREE
;
4626 /* Sometimes the C++ frontend doesn't manage to transform a temporary
4627 DECL_VINDEX referring to itself into a vtable slot number as it
4628 should. Happens with functions that are copied and then forgotten
4629 about. Just clear it, it won't matter anymore. */
4630 if (DECL_VINDEX (decl
) && !host_integerp (DECL_VINDEX (decl
), 0))
4631 DECL_VINDEX (decl
) = NULL_TREE
;
4633 else if (TREE_CODE (decl
) == VAR_DECL
)
4635 if ((DECL_EXTERNAL (decl
)
4636 && (!TREE_STATIC (decl
) || !TREE_READONLY (decl
)))
4637 || (decl_function_context (decl
) && !TREE_STATIC (decl
)))
4638 DECL_INITIAL (decl
) = NULL_TREE
;
4640 else if (TREE_CODE (decl
) == TYPE_DECL
)
4641 DECL_INITIAL (decl
) = NULL_TREE
;
4642 else if (TREE_CODE (decl
) == TRANSLATION_UNIT_DECL
4643 && DECL_INITIAL (decl
)
4644 && TREE_CODE (DECL_INITIAL (decl
)) == BLOCK
)
4646 /* Strip builtins from the translation-unit BLOCK. We still have
4647 targets without builtin_decl support and also builtins are
4648 shared nodes and thus we can't use TREE_CHAIN in multiple
4650 tree
*nextp
= &BLOCK_VARS (DECL_INITIAL (decl
));
4654 if (TREE_CODE (var
) == FUNCTION_DECL
4655 && DECL_BUILT_IN (var
))
4656 *nextp
= TREE_CHAIN (var
);
4658 nextp
= &TREE_CHAIN (var
);
4664 /* Data used when collecting DECLs and TYPEs for language data removal. */
4666 struct free_lang_data_d
4668 /* Worklist to avoid excessive recursion. */
4669 VEC(tree
,heap
) *worklist
;
4671 /* Set of traversed objects. Used to avoid duplicate visits. */
4672 struct pointer_set_t
*pset
;
4674 /* Array of symbols to process with free_lang_data_in_decl. */
4675 VEC(tree
,heap
) *decls
;
4677 /* Array of types to process with free_lang_data_in_type. */
4678 VEC(tree
,heap
) *types
;
4682 /* Save all language fields needed to generate proper debug information
4683 for DECL. This saves most fields cleared out by free_lang_data_in_decl. */
4686 save_debug_info_for_decl (tree t
)
4688 /*struct saved_debug_info_d *sdi;*/
4690 gcc_assert (debug_info_level
> DINFO_LEVEL_TERSE
&& t
&& DECL_P (t
));
4692 /* FIXME. Partial implementation for saving debug info removed. */
4696 /* Save all language fields needed to generate proper debug information
4697 for TYPE. This saves most fields cleared out by free_lang_data_in_type. */
4700 save_debug_info_for_type (tree t
)
4702 /*struct saved_debug_info_d *sdi;*/
4704 gcc_assert (debug_info_level
> DINFO_LEVEL_TERSE
&& t
&& TYPE_P (t
));
4706 /* FIXME. Partial implementation for saving debug info removed. */
4710 /* Add type or decl T to one of the list of tree nodes that need their
4711 language data removed. The lists are held inside FLD. */
4714 add_tree_to_fld_list (tree t
, struct free_lang_data_d
*fld
)
4718 VEC_safe_push (tree
, heap
, fld
->decls
, t
);
4719 if (debug_info_level
> DINFO_LEVEL_TERSE
)
4720 save_debug_info_for_decl (t
);
4722 else if (TYPE_P (t
))
4724 VEC_safe_push (tree
, heap
, fld
->types
, t
);
4725 if (debug_info_level
> DINFO_LEVEL_TERSE
)
4726 save_debug_info_for_type (t
);
4732 /* Push tree node T into FLD->WORKLIST. */
4735 fld_worklist_push (tree t
, struct free_lang_data_d
*fld
)
4737 if (t
&& !is_lang_specific (t
) && !pointer_set_contains (fld
->pset
, t
))
4738 VEC_safe_push (tree
, heap
, fld
->worklist
, (t
));
4742 /* Operand callback helper for free_lang_data_in_node. *TP is the
4743 subtree operand being considered. */
4746 find_decls_types_r (tree
*tp
, int *ws
, void *data
)
4749 struct free_lang_data_d
*fld
= (struct free_lang_data_d
*) data
;
4751 if (TREE_CODE (t
) == TREE_LIST
)
4754 /* Language specific nodes will be removed, so there is no need
4755 to gather anything under them. */
4756 if (is_lang_specific (t
))
4764 /* Note that walk_tree does not traverse every possible field in
4765 decls, so we have to do our own traversals here. */
4766 add_tree_to_fld_list (t
, fld
);
4768 fld_worklist_push (DECL_NAME (t
), fld
);
4769 fld_worklist_push (DECL_CONTEXT (t
), fld
);
4770 fld_worklist_push (DECL_SIZE (t
), fld
);
4771 fld_worklist_push (DECL_SIZE_UNIT (t
), fld
);
4773 /* We are going to remove everything under DECL_INITIAL for
4774 TYPE_DECLs. No point walking them. */
4775 if (TREE_CODE (t
) != TYPE_DECL
)
4776 fld_worklist_push (DECL_INITIAL (t
), fld
);
4778 fld_worklist_push (DECL_ATTRIBUTES (t
), fld
);
4779 fld_worklist_push (DECL_ABSTRACT_ORIGIN (t
), fld
);
4781 if (TREE_CODE (t
) == FUNCTION_DECL
)
4783 fld_worklist_push (DECL_ARGUMENTS (t
), fld
);
4784 fld_worklist_push (DECL_RESULT (t
), fld
);
4786 else if (TREE_CODE (t
) == TYPE_DECL
)
4788 fld_worklist_push (DECL_ARGUMENT_FLD (t
), fld
);
4789 fld_worklist_push (DECL_VINDEX (t
), fld
);
4791 else if (TREE_CODE (t
) == FIELD_DECL
)
4793 fld_worklist_push (DECL_FIELD_OFFSET (t
), fld
);
4794 fld_worklist_push (DECL_BIT_FIELD_TYPE (t
), fld
);
4795 fld_worklist_push (DECL_QUALIFIER (t
), fld
);
4796 fld_worklist_push (DECL_FIELD_BIT_OFFSET (t
), fld
);
4797 fld_worklist_push (DECL_FCONTEXT (t
), fld
);
4799 else if (TREE_CODE (t
) == VAR_DECL
)
4801 fld_worklist_push (DECL_SECTION_NAME (t
), fld
);
4802 fld_worklist_push (DECL_COMDAT_GROUP (t
), fld
);
4805 if ((TREE_CODE (t
) == VAR_DECL
|| TREE_CODE (t
) == PARM_DECL
)
4806 && DECL_HAS_VALUE_EXPR_P (t
))
4807 fld_worklist_push (DECL_VALUE_EXPR (t
), fld
);
4809 if (TREE_CODE (t
) != FIELD_DECL
4810 && TREE_CODE (t
) != TYPE_DECL
)
4811 fld_worklist_push (TREE_CHAIN (t
), fld
);
4814 else if (TYPE_P (t
))
4816 /* Note that walk_tree does not traverse every possible field in
4817 types, so we have to do our own traversals here. */
4818 add_tree_to_fld_list (t
, fld
);
4820 if (!RECORD_OR_UNION_TYPE_P (t
))
4821 fld_worklist_push (TYPE_CACHED_VALUES (t
), fld
);
4822 fld_worklist_push (TYPE_SIZE (t
), fld
);
4823 fld_worklist_push (TYPE_SIZE_UNIT (t
), fld
);
4824 fld_worklist_push (TYPE_ATTRIBUTES (t
), fld
);
4825 fld_worklist_push (TYPE_POINTER_TO (t
), fld
);
4826 fld_worklist_push (TYPE_REFERENCE_TO (t
), fld
);
4827 fld_worklist_push (TYPE_NAME (t
), fld
);
4828 /* Do not walk TYPE_NEXT_PTR_TO or TYPE_NEXT_REF_TO. We do not stream
4829 them and thus do not and want not to reach unused pointer types
4831 if (!POINTER_TYPE_P (t
))
4832 fld_worklist_push (TYPE_MINVAL (t
), fld
);
4833 if (!RECORD_OR_UNION_TYPE_P (t
))
4834 fld_worklist_push (TYPE_MAXVAL (t
), fld
);
4835 fld_worklist_push (TYPE_MAIN_VARIANT (t
), fld
);
4836 /* Do not walk TYPE_NEXT_VARIANT. We do not stream it and thus
4837 do not and want not to reach unused variants this way. */
4838 fld_worklist_push (TYPE_CONTEXT (t
), fld
);
4839 /* Do not walk TYPE_CANONICAL. We do not stream it and thus do not
4840 and want not to reach unused types this way. */
4842 if (RECORD_OR_UNION_TYPE_P (t
) && TYPE_BINFO (t
))
4846 for (i
= 0; VEC_iterate (tree
, BINFO_BASE_BINFOS (TYPE_BINFO (t
)),
4848 fld_worklist_push (TREE_TYPE (tem
), fld
);
4849 tem
= BINFO_VIRTUALS (TYPE_BINFO (t
));
4851 /* The Java FE overloads BINFO_VIRTUALS for its own purpose. */
4852 && TREE_CODE (tem
) == TREE_LIST
)
4855 fld_worklist_push (TREE_VALUE (tem
), fld
);
4856 tem
= TREE_CHAIN (tem
);
4860 if (RECORD_OR_UNION_TYPE_P (t
))
4863 /* Push all TYPE_FIELDS - there can be interleaving interesting
4864 and non-interesting things. */
4865 tem
= TYPE_FIELDS (t
);
4868 if (TREE_CODE (tem
) == FIELD_DECL
)
4869 fld_worklist_push (tem
, fld
);
4870 tem
= TREE_CHAIN (tem
);
4874 fld_worklist_push (TREE_CHAIN (t
), fld
);
4877 else if (TREE_CODE (t
) == BLOCK
)
4880 for (tem
= BLOCK_VARS (t
); tem
; tem
= TREE_CHAIN (tem
))
4881 fld_worklist_push (tem
, fld
);
4882 for (tem
= BLOCK_SUBBLOCKS (t
); tem
; tem
= BLOCK_CHAIN (tem
))
4883 fld_worklist_push (tem
, fld
);
4884 fld_worklist_push (BLOCK_ABSTRACT_ORIGIN (t
), fld
);
4887 if (TREE_CODE (t
) != IDENTIFIER_NODE
)
4888 fld_worklist_push (TREE_TYPE (t
), fld
);
4894 /* Find decls and types in T. */
4897 find_decls_types (tree t
, struct free_lang_data_d
*fld
)
4901 if (!pointer_set_contains (fld
->pset
, t
))
4902 walk_tree (&t
, find_decls_types_r
, fld
, fld
->pset
);
4903 if (VEC_empty (tree
, fld
->worklist
))
4905 t
= VEC_pop (tree
, fld
->worklist
);
4909 /* Translate all the types in LIST with the corresponding runtime
4913 get_eh_types_for_runtime (tree list
)
4917 if (list
== NULL_TREE
)
4920 head
= build_tree_list (0, lookup_type_for_runtime (TREE_VALUE (list
)));
4922 list
= TREE_CHAIN (list
);
4925 tree n
= build_tree_list (0, lookup_type_for_runtime (TREE_VALUE (list
)));
4926 TREE_CHAIN (prev
) = n
;
4927 prev
= TREE_CHAIN (prev
);
4928 list
= TREE_CHAIN (list
);
4935 /* Find decls and types referenced in EH region R and store them in
4936 FLD->DECLS and FLD->TYPES. */
4939 find_decls_types_in_eh_region (eh_region r
, struct free_lang_data_d
*fld
)
4950 /* The types referenced in each catch must first be changed to the
4951 EH types used at runtime. This removes references to FE types
4953 for (c
= r
->u
.eh_try
.first_catch
; c
; c
= c
->next_catch
)
4955 c
->type_list
= get_eh_types_for_runtime (c
->type_list
);
4956 walk_tree (&c
->type_list
, find_decls_types_r
, fld
, fld
->pset
);
4961 case ERT_ALLOWED_EXCEPTIONS
:
4962 r
->u
.allowed
.type_list
4963 = get_eh_types_for_runtime (r
->u
.allowed
.type_list
);
4964 walk_tree (&r
->u
.allowed
.type_list
, find_decls_types_r
, fld
, fld
->pset
);
4967 case ERT_MUST_NOT_THROW
:
4968 walk_tree (&r
->u
.must_not_throw
.failure_decl
,
4969 find_decls_types_r
, fld
, fld
->pset
);
4975 /* Find decls and types referenced in cgraph node N and store them in
4976 FLD->DECLS and FLD->TYPES. Unlike pass_referenced_vars, this will
4977 look for *every* kind of DECL and TYPE node reachable from N,
4978 including those embedded inside types and decls (i.e,, TYPE_DECLs,
4979 NAMESPACE_DECLs, etc). */
4982 find_decls_types_in_node (struct cgraph_node
*n
, struct free_lang_data_d
*fld
)
4985 struct function
*fn
;
4989 find_decls_types (n
->decl
, fld
);
4991 if (!gimple_has_body_p (n
->decl
))
4994 gcc_assert (current_function_decl
== NULL_TREE
&& cfun
== NULL
);
4996 fn
= DECL_STRUCT_FUNCTION (n
->decl
);
4998 /* Traverse locals. */
4999 FOR_EACH_LOCAL_DECL (fn
, ix
, t
)
5000 find_decls_types (t
, fld
);
5002 /* Traverse EH regions in FN. */
5005 FOR_ALL_EH_REGION_FN (r
, fn
)
5006 find_decls_types_in_eh_region (r
, fld
);
5009 /* Traverse every statement in FN. */
5010 FOR_EACH_BB_FN (bb
, fn
)
5012 gimple_stmt_iterator si
;
5015 for (si
= gsi_start_phis (bb
); !gsi_end_p (si
); gsi_next (&si
))
5017 gimple phi
= gsi_stmt (si
);
5019 for (i
= 0; i
< gimple_phi_num_args (phi
); i
++)
5021 tree
*arg_p
= gimple_phi_arg_def_ptr (phi
, i
);
5022 find_decls_types (*arg_p
, fld
);
5026 for (si
= gsi_start_bb (bb
); !gsi_end_p (si
); gsi_next (&si
))
5028 gimple stmt
= gsi_stmt (si
);
5030 for (i
= 0; i
< gimple_num_ops (stmt
); i
++)
5032 tree arg
= gimple_op (stmt
, i
);
5033 find_decls_types (arg
, fld
);
5040 /* Find decls and types referenced in varpool node N and store them in
5041 FLD->DECLS and FLD->TYPES. Unlike pass_referenced_vars, this will
5042 look for *every* kind of DECL and TYPE node reachable from N,
5043 including those embedded inside types and decls (i.e,, TYPE_DECLs,
5044 NAMESPACE_DECLs, etc). */
5047 find_decls_types_in_var (struct varpool_node
*v
, struct free_lang_data_d
*fld
)
5049 find_decls_types (v
->decl
, fld
);
5052 /* If T needs an assembler name, have one created for it. */
5055 assign_assembler_name_if_neeeded (tree t
)
5057 if (need_assembler_name_p (t
))
5059 /* When setting DECL_ASSEMBLER_NAME, the C++ mangler may emit
5060 diagnostics that use input_location to show locus
5061 information. The problem here is that, at this point,
5062 input_location is generally anchored to the end of the file
5063 (since the parser is long gone), so we don't have a good
5064 position to pin it to.
5066 To alleviate this problem, this uses the location of T's
5067 declaration. Examples of this are
5068 testsuite/g++.dg/template/cond2.C and
5069 testsuite/g++.dg/template/pr35240.C. */
5070 location_t saved_location
= input_location
;
5071 input_location
= DECL_SOURCE_LOCATION (t
);
5073 decl_assembler_name (t
);
5075 input_location
= saved_location
;
5080 /* Free language specific information for every operand and expression
5081 in every node of the call graph. This process operates in three stages:
5083 1- Every callgraph node and varpool node is traversed looking for
5084 decls and types embedded in them. This is a more exhaustive
5085 search than that done by find_referenced_vars, because it will
5086 also collect individual fields, decls embedded in types, etc.
5088 2- All the decls found are sent to free_lang_data_in_decl.
5090 3- All the types found are sent to free_lang_data_in_type.
5092 The ordering between decls and types is important because
5093 free_lang_data_in_decl sets assembler names, which includes
5094 mangling. So types cannot be freed up until assembler names have
5098 free_lang_data_in_cgraph (void)
5100 struct cgraph_node
*n
;
5101 struct varpool_node
*v
;
5102 struct free_lang_data_d fld
;
5107 /* Initialize sets and arrays to store referenced decls and types. */
5108 fld
.pset
= pointer_set_create ();
5109 fld
.worklist
= NULL
;
5110 fld
.decls
= VEC_alloc (tree
, heap
, 100);
5111 fld
.types
= VEC_alloc (tree
, heap
, 100);
5113 /* Find decls and types in the body of every function in the callgraph. */
5114 for (n
= cgraph_nodes
; n
; n
= n
->next
)
5115 find_decls_types_in_node (n
, &fld
);
5117 FOR_EACH_VEC_ELT (alias_pair
, alias_pairs
, i
, p
)
5118 find_decls_types (p
->decl
, &fld
);
5120 /* Find decls and types in every varpool symbol. */
5121 for (v
= varpool_nodes
; v
; v
= v
->next
)
5122 find_decls_types_in_var (v
, &fld
);
5124 /* Set the assembler name on every decl found. We need to do this
5125 now because free_lang_data_in_decl will invalidate data needed
5126 for mangling. This breaks mangling on interdependent decls. */
5127 FOR_EACH_VEC_ELT (tree
, fld
.decls
, i
, t
)
5128 assign_assembler_name_if_neeeded (t
);
5130 /* Traverse every decl found freeing its language data. */
5131 FOR_EACH_VEC_ELT (tree
, fld
.decls
, i
, t
)
5132 free_lang_data_in_decl (t
);
5134 /* Traverse every type found freeing its language data. */
5135 FOR_EACH_VEC_ELT (tree
, fld
.types
, i
, t
)
5136 free_lang_data_in_type (t
);
5138 pointer_set_destroy (fld
.pset
);
5139 VEC_free (tree
, heap
, fld
.worklist
);
5140 VEC_free (tree
, heap
, fld
.decls
);
5141 VEC_free (tree
, heap
, fld
.types
);
5145 /* Free resources that are used by FE but are not needed once they are done. */
5148 free_lang_data (void)
5152 /* If we are the LTO frontend we have freed lang-specific data already. */
5154 || !flag_generate_lto
)
5157 /* Allocate and assign alias sets to the standard integer types
5158 while the slots are still in the way the frontends generated them. */
5159 for (i
= 0; i
< itk_none
; ++i
)
5160 if (integer_types
[i
])
5161 TYPE_ALIAS_SET (integer_types
[i
]) = get_alias_set (integer_types
[i
]);
5163 /* Traverse the IL resetting language specific information for
5164 operands, expressions, etc. */
5165 free_lang_data_in_cgraph ();
5167 /* Create gimple variants for common types. */
5168 ptrdiff_type_node
= integer_type_node
;
5169 fileptr_type_node
= ptr_type_node
;
5170 if (TREE_CODE (boolean_type_node
) != BOOLEAN_TYPE
5171 || (TYPE_MODE (boolean_type_node
)
5172 != mode_for_size (BOOL_TYPE_SIZE
, MODE_INT
, 0))
5173 || TYPE_PRECISION (boolean_type_node
) != 1
5174 || !TYPE_UNSIGNED (boolean_type_node
))
5176 boolean_type_node
= make_unsigned_type (BOOL_TYPE_SIZE
);
5177 TREE_SET_CODE (boolean_type_node
, BOOLEAN_TYPE
);
5178 TYPE_MAX_VALUE (boolean_type_node
) = build_int_cst (boolean_type_node
, 1);
5179 TYPE_PRECISION (boolean_type_node
) = 1;
5180 boolean_false_node
= TYPE_MIN_VALUE (boolean_type_node
);
5181 boolean_true_node
= TYPE_MAX_VALUE (boolean_type_node
);
5184 /* Unify char_type_node with its properly signed variant. */
5185 if (TYPE_UNSIGNED (char_type_node
))
5186 unsigned_char_type_node
= char_type_node
;
5188 signed_char_type_node
= char_type_node
;
5190 /* Reset some langhooks. Do not reset types_compatible_p, it may
5191 still be used indirectly via the get_alias_set langhook. */
5192 lang_hooks
.callgraph
.analyze_expr
= NULL
;
5193 lang_hooks
.dwarf_name
= lhd_dwarf_name
;
5194 lang_hooks
.decl_printable_name
= gimple_decl_printable_name
;
5195 /* We do not want the default decl_assembler_name implementation,
5196 rather if we have fixed everything we want a wrapper around it
5197 asserting that all non-local symbols already got their assembler
5198 name and only produce assembler names for local symbols. Or rather
5199 make sure we never call decl_assembler_name on local symbols and
5200 devise a separate, middle-end private scheme for it. */
5202 /* Reset diagnostic machinery. */
5203 diagnostic_starter (global_dc
) = default_tree_diagnostic_starter
;
5204 diagnostic_finalizer (global_dc
) = default_diagnostic_finalizer
;
5205 diagnostic_format_decoder (global_dc
) = default_tree_printer
;
5211 struct simple_ipa_opt_pass pass_ipa_free_lang_data
=
5215 "*free_lang_data", /* name */
5217 free_lang_data
, /* execute */
5220 0, /* static_pass_number */
5221 TV_IPA_FREE_LANG_DATA
, /* tv_id */
5222 0, /* properties_required */
5223 0, /* properties_provided */
5224 0, /* properties_destroyed */
5225 0, /* todo_flags_start */
5226 TODO_ggc_collect
/* todo_flags_finish */
5230 /* Return nonzero if IDENT is a valid name for attribute ATTR,
5233 We try both `text' and `__text__', ATTR may be either one. */
5234 /* ??? It might be a reasonable simplification to require ATTR to be only
5235 `text'. One might then also require attribute lists to be stored in
5236 their canonicalized form. */
5239 is_attribute_with_length_p (const char *attr
, int attr_len
, const_tree ident
)
5244 if (TREE_CODE (ident
) != IDENTIFIER_NODE
)
5247 p
= IDENTIFIER_POINTER (ident
);
5248 ident_len
= IDENTIFIER_LENGTH (ident
);
5250 if (ident_len
== attr_len
5251 && strcmp (attr
, p
) == 0)
5254 /* If ATTR is `__text__', IDENT must be `text'; and vice versa. */
5257 gcc_assert (attr
[1] == '_');
5258 gcc_assert (attr
[attr_len
- 2] == '_');
5259 gcc_assert (attr
[attr_len
- 1] == '_');
5260 if (ident_len
== attr_len
- 4
5261 && strncmp (attr
+ 2, p
, attr_len
- 4) == 0)
5266 if (ident_len
== attr_len
+ 4
5267 && p
[0] == '_' && p
[1] == '_'
5268 && p
[ident_len
- 2] == '_' && p
[ident_len
- 1] == '_'
5269 && strncmp (attr
, p
+ 2, attr_len
) == 0)
5276 /* Return nonzero if IDENT is a valid name for attribute ATTR,
5279 We try both `text' and `__text__', ATTR may be either one. */
5282 is_attribute_p (const char *attr
, const_tree ident
)
5284 return is_attribute_with_length_p (attr
, strlen (attr
), ident
);
5287 /* Given an attribute name and a list of attributes, return a pointer to the
5288 attribute's list element if the attribute is part of the list, or NULL_TREE
5289 if not found. If the attribute appears more than once, this only
5290 returns the first occurrence; the TREE_CHAIN of the return value should
5291 be passed back in if further occurrences are wanted. */
5294 lookup_attribute (const char *attr_name
, tree list
)
5297 size_t attr_len
= strlen (attr_name
);
5299 for (l
= list
; l
; l
= TREE_CHAIN (l
))
5301 gcc_assert (TREE_CODE (TREE_PURPOSE (l
)) == IDENTIFIER_NODE
);
5302 if (is_attribute_with_length_p (attr_name
, attr_len
, TREE_PURPOSE (l
)))
5308 /* Remove any instances of attribute ATTR_NAME in LIST and return the
5312 remove_attribute (const char *attr_name
, tree list
)
5315 size_t attr_len
= strlen (attr_name
);
5317 for (p
= &list
; *p
; )
5320 gcc_assert (TREE_CODE (TREE_PURPOSE (l
)) == IDENTIFIER_NODE
);
5321 if (is_attribute_with_length_p (attr_name
, attr_len
, TREE_PURPOSE (l
)))
5322 *p
= TREE_CHAIN (l
);
5324 p
= &TREE_CHAIN (l
);
5330 /* Return an attribute list that is the union of a1 and a2. */
5333 merge_attributes (tree a1
, tree a2
)
5337 /* Either one unset? Take the set one. */
5339 if ((attributes
= a1
) == 0)
5342 /* One that completely contains the other? Take it. */
5344 else if (a2
!= 0 && ! attribute_list_contained (a1
, a2
))
5346 if (attribute_list_contained (a2
, a1
))
5350 /* Pick the longest list, and hang on the other list. */
5352 if (list_length (a1
) < list_length (a2
))
5353 attributes
= a2
, a2
= a1
;
5355 for (; a2
!= 0; a2
= TREE_CHAIN (a2
))
5358 for (a
= lookup_attribute (IDENTIFIER_POINTER (TREE_PURPOSE (a2
)),
5360 a
!= NULL_TREE
&& !attribute_value_equal (a
, a2
);
5361 a
= lookup_attribute (IDENTIFIER_POINTER (TREE_PURPOSE (a2
)),
5366 a1
= copy_node (a2
);
5367 TREE_CHAIN (a1
) = attributes
;
5376 /* Given types T1 and T2, merge their attributes and return
5380 merge_type_attributes (tree t1
, tree t2
)
5382 return merge_attributes (TYPE_ATTRIBUTES (t1
),
5383 TYPE_ATTRIBUTES (t2
));
5386 /* Given decls OLDDECL and NEWDECL, merge their attributes and return
5390 merge_decl_attributes (tree olddecl
, tree newdecl
)
5392 return merge_attributes (DECL_ATTRIBUTES (olddecl
),
5393 DECL_ATTRIBUTES (newdecl
));
5396 #if TARGET_DLLIMPORT_DECL_ATTRIBUTES
5398 /* Specialization of merge_decl_attributes for various Windows targets.
5400 This handles the following situation:
5402 __declspec (dllimport) int foo;
5405 The second instance of `foo' nullifies the dllimport. */
5408 merge_dllimport_decl_attributes (tree old
, tree new_tree
)
5411 int delete_dllimport_p
= 1;
5413 /* What we need to do here is remove from `old' dllimport if it doesn't
5414 appear in `new'. dllimport behaves like extern: if a declaration is
5415 marked dllimport and a definition appears later, then the object
5416 is not dllimport'd. We also remove a `new' dllimport if the old list
5417 contains dllexport: dllexport always overrides dllimport, regardless
5418 of the order of declaration. */
5419 if (!VAR_OR_FUNCTION_DECL_P (new_tree
))
5420 delete_dllimport_p
= 0;
5421 else if (DECL_DLLIMPORT_P (new_tree
)
5422 && lookup_attribute ("dllexport", DECL_ATTRIBUTES (old
)))
5424 DECL_DLLIMPORT_P (new_tree
) = 0;
5425 warning (OPT_Wattributes
, "%q+D already declared with dllexport attribute: "
5426 "dllimport ignored", new_tree
);
5428 else if (DECL_DLLIMPORT_P (old
) && !DECL_DLLIMPORT_P (new_tree
))
5430 /* Warn about overriding a symbol that has already been used, e.g.:
5431 extern int __attribute__ ((dllimport)) foo;
5432 int* bar () {return &foo;}
5435 if (TREE_USED (old
))
5437 warning (0, "%q+D redeclared without dllimport attribute "
5438 "after being referenced with dll linkage", new_tree
);
5439 /* If we have used a variable's address with dllimport linkage,
5440 keep the old DECL_DLLIMPORT_P flag: the ADDR_EXPR using the
5441 decl may already have had TREE_CONSTANT computed.
5442 We still remove the attribute so that assembler code refers
5443 to '&foo rather than '_imp__foo'. */
5444 if (TREE_CODE (old
) == VAR_DECL
&& TREE_ADDRESSABLE (old
))
5445 DECL_DLLIMPORT_P (new_tree
) = 1;
5448 /* Let an inline definition silently override the external reference,
5449 but otherwise warn about attribute inconsistency. */
5450 else if (TREE_CODE (new_tree
) == VAR_DECL
5451 || !DECL_DECLARED_INLINE_P (new_tree
))
5452 warning (OPT_Wattributes
, "%q+D redeclared without dllimport attribute: "
5453 "previous dllimport ignored", new_tree
);
5456 delete_dllimport_p
= 0;
5458 a
= merge_attributes (DECL_ATTRIBUTES (old
), DECL_ATTRIBUTES (new_tree
));
5460 if (delete_dllimport_p
)
5463 const size_t attr_len
= strlen ("dllimport");
5465 /* Scan the list for dllimport and delete it. */
5466 for (prev
= NULL_TREE
, t
= a
; t
; prev
= t
, t
= TREE_CHAIN (t
))
5468 if (is_attribute_with_length_p ("dllimport", attr_len
,
5471 if (prev
== NULL_TREE
)
5474 TREE_CHAIN (prev
) = TREE_CHAIN (t
);
5483 /* Handle a "dllimport" or "dllexport" attribute; arguments as in
5484 struct attribute_spec.handler. */
5487 handle_dll_attribute (tree
* pnode
, tree name
, tree args
, int flags
,
5493 /* These attributes may apply to structure and union types being created,
5494 but otherwise should pass to the declaration involved. */
5497 if (flags
& ((int) ATTR_FLAG_DECL_NEXT
| (int) ATTR_FLAG_FUNCTION_NEXT
5498 | (int) ATTR_FLAG_ARRAY_NEXT
))
5500 *no_add_attrs
= true;
5501 return tree_cons (name
, args
, NULL_TREE
);
5503 if (TREE_CODE (node
) == RECORD_TYPE
5504 || TREE_CODE (node
) == UNION_TYPE
)
5506 node
= TYPE_NAME (node
);
5512 warning (OPT_Wattributes
, "%qE attribute ignored",
5514 *no_add_attrs
= true;
5519 if (TREE_CODE (node
) != FUNCTION_DECL
5520 && TREE_CODE (node
) != VAR_DECL
5521 && TREE_CODE (node
) != TYPE_DECL
)
5523 *no_add_attrs
= true;
5524 warning (OPT_Wattributes
, "%qE attribute ignored",
5529 if (TREE_CODE (node
) == TYPE_DECL
5530 && TREE_CODE (TREE_TYPE (node
)) != RECORD_TYPE
5531 && TREE_CODE (TREE_TYPE (node
)) != UNION_TYPE
)
5533 *no_add_attrs
= true;
5534 warning (OPT_Wattributes
, "%qE attribute ignored",
5539 is_dllimport
= is_attribute_p ("dllimport", name
);
5541 /* Report error on dllimport ambiguities seen now before they cause
5545 /* Honor any target-specific overrides. */
5546 if (!targetm
.valid_dllimport_attribute_p (node
))
5547 *no_add_attrs
= true;
5549 else if (TREE_CODE (node
) == FUNCTION_DECL
5550 && DECL_DECLARED_INLINE_P (node
))
5552 warning (OPT_Wattributes
, "inline function %q+D declared as "
5553 " dllimport: attribute ignored", node
);
5554 *no_add_attrs
= true;
5556 /* Like MS, treat definition of dllimported variables and
5557 non-inlined functions on declaration as syntax errors. */
5558 else if (TREE_CODE (node
) == FUNCTION_DECL
&& DECL_INITIAL (node
))
5560 error ("function %q+D definition is marked dllimport", node
);
5561 *no_add_attrs
= true;
5564 else if (TREE_CODE (node
) == VAR_DECL
)
5566 if (DECL_INITIAL (node
))
5568 error ("variable %q+D definition is marked dllimport",
5570 *no_add_attrs
= true;
5573 /* `extern' needn't be specified with dllimport.
5574 Specify `extern' now and hope for the best. Sigh. */
5575 DECL_EXTERNAL (node
) = 1;
5576 /* Also, implicitly give dllimport'd variables declared within
5577 a function global scope, unless declared static. */
5578 if (current_function_decl
!= NULL_TREE
&& !TREE_STATIC (node
))
5579 TREE_PUBLIC (node
) = 1;
5582 if (*no_add_attrs
== false)
5583 DECL_DLLIMPORT_P (node
) = 1;
5585 else if (TREE_CODE (node
) == FUNCTION_DECL
5586 && DECL_DECLARED_INLINE_P (node
)
5587 && flag_keep_inline_dllexport
)
5588 /* An exported function, even if inline, must be emitted. */
5589 DECL_EXTERNAL (node
) = 0;
5591 /* Report error if symbol is not accessible at global scope. */
5592 if (!TREE_PUBLIC (node
)
5593 && (TREE_CODE (node
) == VAR_DECL
5594 || TREE_CODE (node
) == FUNCTION_DECL
))
5596 error ("external linkage required for symbol %q+D because of "
5597 "%qE attribute", node
, name
);
5598 *no_add_attrs
= true;
5601 /* A dllexport'd entity must have default visibility so that other
5602 program units (shared libraries or the main executable) can see
5603 it. A dllimport'd entity must have default visibility so that
5604 the linker knows that undefined references within this program
5605 unit can be resolved by the dynamic linker. */
5608 if (DECL_VISIBILITY_SPECIFIED (node
)
5609 && DECL_VISIBILITY (node
) != VISIBILITY_DEFAULT
)
5610 error ("%qE implies default visibility, but %qD has already "
5611 "been declared with a different visibility",
5613 DECL_VISIBILITY (node
) = VISIBILITY_DEFAULT
;
5614 DECL_VISIBILITY_SPECIFIED (node
) = 1;
5620 #endif /* TARGET_DLLIMPORT_DECL_ATTRIBUTES */
5622 /* Set the type qualifiers for TYPE to TYPE_QUALS, which is a bitmask
5623 of the various TYPE_QUAL values. */
5626 set_type_quals (tree type
, int type_quals
)
5628 TYPE_READONLY (type
) = (type_quals
& TYPE_QUAL_CONST
) != 0;
5629 TYPE_VOLATILE (type
) = (type_quals
& TYPE_QUAL_VOLATILE
) != 0;
5630 TYPE_RESTRICT (type
) = (type_quals
& TYPE_QUAL_RESTRICT
) != 0;
5631 TYPE_ADDR_SPACE (type
) = DECODE_QUAL_ADDR_SPACE (type_quals
);
5634 /* Returns true iff CAND is equivalent to BASE with TYPE_QUALS. */
5637 check_qualified_type (const_tree cand
, const_tree base
, int type_quals
)
5639 return (TYPE_QUALS (cand
) == type_quals
5640 && TYPE_NAME (cand
) == TYPE_NAME (base
)
5641 /* Apparently this is needed for Objective-C. */
5642 && TYPE_CONTEXT (cand
) == TYPE_CONTEXT (base
)
5643 /* Check alignment. */
5644 && TYPE_ALIGN (cand
) == TYPE_ALIGN (base
)
5645 && attribute_list_equal (TYPE_ATTRIBUTES (cand
),
5646 TYPE_ATTRIBUTES (base
)));
5649 /* Returns true iff CAND is equivalent to BASE with ALIGN. */
5652 check_aligned_type (const_tree cand
, const_tree base
, unsigned int align
)
5654 return (TYPE_QUALS (cand
) == TYPE_QUALS (base
)
5655 && TYPE_NAME (cand
) == TYPE_NAME (base
)
5656 /* Apparently this is needed for Objective-C. */
5657 && TYPE_CONTEXT (cand
) == TYPE_CONTEXT (base
)
5658 /* Check alignment. */
5659 && TYPE_ALIGN (cand
) == align
5660 && attribute_list_equal (TYPE_ATTRIBUTES (cand
),
5661 TYPE_ATTRIBUTES (base
)));
5664 /* Return a version of the TYPE, qualified as indicated by the
5665 TYPE_QUALS, if one exists. If no qualified version exists yet,
5666 return NULL_TREE. */
5669 get_qualified_type (tree type
, int type_quals
)
5673 if (TYPE_QUALS (type
) == type_quals
)
5676 /* Search the chain of variants to see if there is already one there just
5677 like the one we need to have. If so, use that existing one. We must
5678 preserve the TYPE_NAME, since there is code that depends on this. */
5679 for (t
= TYPE_MAIN_VARIANT (type
); t
; t
= TYPE_NEXT_VARIANT (t
))
5680 if (check_qualified_type (t
, type
, type_quals
))
5686 /* Like get_qualified_type, but creates the type if it does not
5687 exist. This function never returns NULL_TREE. */
5690 build_qualified_type (tree type
, int type_quals
)
5694 /* See if we already have the appropriate qualified variant. */
5695 t
= get_qualified_type (type
, type_quals
);
5697 /* If not, build it. */
5700 t
= build_variant_type_copy (type
);
5701 set_type_quals (t
, type_quals
);
5703 if (TYPE_STRUCTURAL_EQUALITY_P (type
))
5704 /* Propagate structural equality. */
5705 SET_TYPE_STRUCTURAL_EQUALITY (t
);
5706 else if (TYPE_CANONICAL (type
) != type
)
5707 /* Build the underlying canonical type, since it is different
5709 TYPE_CANONICAL (t
) = build_qualified_type (TYPE_CANONICAL (type
),
5712 /* T is its own canonical type. */
5713 TYPE_CANONICAL (t
) = t
;
5720 /* Create a variant of type T with alignment ALIGN. */
5723 build_aligned_type (tree type
, unsigned int align
)
5727 if (TYPE_PACKED (type
)
5728 || TYPE_ALIGN (type
) == align
)
5731 for (t
= TYPE_MAIN_VARIANT (type
); t
; t
= TYPE_NEXT_VARIANT (t
))
5732 if (check_aligned_type (t
, type
, align
))
5735 t
= build_variant_type_copy (type
);
5736 TYPE_ALIGN (t
) = align
;
5741 /* Create a new distinct copy of TYPE. The new type is made its own
5742 MAIN_VARIANT. If TYPE requires structural equality checks, the
5743 resulting type requires structural equality checks; otherwise, its
5744 TYPE_CANONICAL points to itself. */
5747 build_distinct_type_copy (tree type
)
5749 tree t
= copy_node (type
);
5751 TYPE_POINTER_TO (t
) = 0;
5752 TYPE_REFERENCE_TO (t
) = 0;
5754 /* Set the canonical type either to a new equivalence class, or
5755 propagate the need for structural equality checks. */
5756 if (TYPE_STRUCTURAL_EQUALITY_P (type
))
5757 SET_TYPE_STRUCTURAL_EQUALITY (t
);
5759 TYPE_CANONICAL (t
) = t
;
5761 /* Make it its own variant. */
5762 TYPE_MAIN_VARIANT (t
) = t
;
5763 TYPE_NEXT_VARIANT (t
) = 0;
5765 /* Note that it is now possible for TYPE_MIN_VALUE to be a value
5766 whose TREE_TYPE is not t. This can also happen in the Ada
5767 frontend when using subtypes. */
5772 /* Create a new variant of TYPE, equivalent but distinct. This is so
5773 the caller can modify it. TYPE_CANONICAL for the return type will
5774 be equivalent to TYPE_CANONICAL of TYPE, indicating that the types
5775 are considered equal by the language itself (or that both types
5776 require structural equality checks). */
5779 build_variant_type_copy (tree type
)
5781 tree t
, m
= TYPE_MAIN_VARIANT (type
);
5783 t
= build_distinct_type_copy (type
);
5785 /* Since we're building a variant, assume that it is a non-semantic
5786 variant. This also propagates TYPE_STRUCTURAL_EQUALITY_P. */
5787 TYPE_CANONICAL (t
) = TYPE_CANONICAL (type
);
5789 /* Add the new type to the chain of variants of TYPE. */
5790 TYPE_NEXT_VARIANT (t
) = TYPE_NEXT_VARIANT (m
);
5791 TYPE_NEXT_VARIANT (m
) = t
;
5792 TYPE_MAIN_VARIANT (t
) = m
;
5797 /* Return true if the from tree in both tree maps are equal. */
5800 tree_map_base_eq (const void *va
, const void *vb
)
5802 const struct tree_map_base
*const a
= (const struct tree_map_base
*) va
,
5803 *const b
= (const struct tree_map_base
*) vb
;
5804 return (a
->from
== b
->from
);
5807 /* Hash a from tree in a tree_base_map. */
5810 tree_map_base_hash (const void *item
)
5812 return htab_hash_pointer (((const struct tree_map_base
*)item
)->from
);
5815 /* Return true if this tree map structure is marked for garbage collection
5816 purposes. We simply return true if the from tree is marked, so that this
5817 structure goes away when the from tree goes away. */
5820 tree_map_base_marked_p (const void *p
)
5822 return ggc_marked_p (((const struct tree_map_base
*) p
)->from
);
5825 /* Hash a from tree in a tree_map. */
5828 tree_map_hash (const void *item
)
5830 return (((const struct tree_map
*) item
)->hash
);
5833 /* Hash a from tree in a tree_decl_map. */
5836 tree_decl_map_hash (const void *item
)
5838 return DECL_UID (((const struct tree_decl_map
*) item
)->base
.from
);
5841 /* Return the initialization priority for DECL. */
5844 decl_init_priority_lookup (tree decl
)
5846 struct tree_priority_map
*h
;
5847 struct tree_map_base in
;
5849 gcc_assert (VAR_OR_FUNCTION_DECL_P (decl
));
5851 h
= (struct tree_priority_map
*) htab_find (init_priority_for_decl
, &in
);
5852 return h
? h
->init
: DEFAULT_INIT_PRIORITY
;
5855 /* Return the finalization priority for DECL. */
5858 decl_fini_priority_lookup (tree decl
)
5860 struct tree_priority_map
*h
;
5861 struct tree_map_base in
;
5863 gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
);
5865 h
= (struct tree_priority_map
*) htab_find (init_priority_for_decl
, &in
);
5866 return h
? h
->fini
: DEFAULT_INIT_PRIORITY
;
5869 /* Return the initialization and finalization priority information for
5870 DECL. If there is no previous priority information, a freshly
5871 allocated structure is returned. */
5873 static struct tree_priority_map
*
5874 decl_priority_info (tree decl
)
5876 struct tree_priority_map in
;
5877 struct tree_priority_map
*h
;
5880 in
.base
.from
= decl
;
5881 loc
= htab_find_slot (init_priority_for_decl
, &in
, INSERT
);
5882 h
= (struct tree_priority_map
*) *loc
;
5885 h
= ggc_alloc_cleared_tree_priority_map ();
5887 h
->base
.from
= decl
;
5888 h
->init
= DEFAULT_INIT_PRIORITY
;
5889 h
->fini
= DEFAULT_INIT_PRIORITY
;
5895 /* Set the initialization priority for DECL to PRIORITY. */
5898 decl_init_priority_insert (tree decl
, priority_type priority
)
5900 struct tree_priority_map
*h
;
5902 gcc_assert (VAR_OR_FUNCTION_DECL_P (decl
));
5903 if (priority
== DEFAULT_INIT_PRIORITY
)
5905 h
= decl_priority_info (decl
);
5909 /* Set the finalization priority for DECL to PRIORITY. */
5912 decl_fini_priority_insert (tree decl
, priority_type priority
)
5914 struct tree_priority_map
*h
;
5916 gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
);
5917 if (priority
== DEFAULT_INIT_PRIORITY
)
5919 h
= decl_priority_info (decl
);
5923 /* Print out the statistics for the DECL_DEBUG_EXPR hash table. */
5926 print_debug_expr_statistics (void)
5928 fprintf (stderr
, "DECL_DEBUG_EXPR hash: size %ld, %ld elements, %f collisions\n",
5929 (long) htab_size (debug_expr_for_decl
),
5930 (long) htab_elements (debug_expr_for_decl
),
5931 htab_collisions (debug_expr_for_decl
));
5934 /* Print out the statistics for the DECL_VALUE_EXPR hash table. */
5937 print_value_expr_statistics (void)
5939 fprintf (stderr
, "DECL_VALUE_EXPR hash: size %ld, %ld elements, %f collisions\n",
5940 (long) htab_size (value_expr_for_decl
),
5941 (long) htab_elements (value_expr_for_decl
),
5942 htab_collisions (value_expr_for_decl
));
5945 /* Lookup a debug expression for FROM, and return it if we find one. */
5948 decl_debug_expr_lookup (tree from
)
5950 struct tree_decl_map
*h
, in
;
5951 in
.base
.from
= from
;
5953 h
= (struct tree_decl_map
*)
5954 htab_find_with_hash (debug_expr_for_decl
, &in
, DECL_UID (from
));
5960 /* Insert a mapping FROM->TO in the debug expression hashtable. */
5963 decl_debug_expr_insert (tree from
, tree to
)
5965 struct tree_decl_map
*h
;
5968 h
= ggc_alloc_tree_decl_map ();
5969 h
->base
.from
= from
;
5971 loc
= htab_find_slot_with_hash (debug_expr_for_decl
, h
, DECL_UID (from
),
5973 *(struct tree_decl_map
**) loc
= h
;
5976 /* Lookup a value expression for FROM, and return it if we find one. */
5979 decl_value_expr_lookup (tree from
)
5981 struct tree_decl_map
*h
, in
;
5982 in
.base
.from
= from
;
5984 h
= (struct tree_decl_map
*)
5985 htab_find_with_hash (value_expr_for_decl
, &in
, DECL_UID (from
));
5991 /* Insert a mapping FROM->TO in the value expression hashtable. */
5994 decl_value_expr_insert (tree from
, tree to
)
5996 struct tree_decl_map
*h
;
5999 h
= ggc_alloc_tree_decl_map ();
6000 h
->base
.from
= from
;
6002 loc
= htab_find_slot_with_hash (value_expr_for_decl
, h
, DECL_UID (from
),
6004 *(struct tree_decl_map
**) loc
= h
;
6007 /* Hashing of types so that we don't make duplicates.
6008 The entry point is `type_hash_canon'. */
6010 /* Compute a hash code for a list of types (chain of TREE_LIST nodes
6011 with types in the TREE_VALUE slots), by adding the hash codes
6012 of the individual types. */
6015 type_hash_list (const_tree list
, hashval_t hashcode
)
6019 for (tail
= list
; tail
; tail
= TREE_CHAIN (tail
))
6020 if (TREE_VALUE (tail
) != error_mark_node
)
6021 hashcode
= iterative_hash_object (TYPE_HASH (TREE_VALUE (tail
)),
6027 /* These are the Hashtable callback functions. */
6029 /* Returns true iff the types are equivalent. */
6032 type_hash_eq (const void *va
, const void *vb
)
6034 const struct type_hash
*const a
= (const struct type_hash
*) va
,
6035 *const b
= (const struct type_hash
*) vb
;
6037 /* First test the things that are the same for all types. */
6038 if (a
->hash
!= b
->hash
6039 || TREE_CODE (a
->type
) != TREE_CODE (b
->type
)
6040 || TREE_TYPE (a
->type
) != TREE_TYPE (b
->type
)
6041 || !attribute_list_equal (TYPE_ATTRIBUTES (a
->type
),
6042 TYPE_ATTRIBUTES (b
->type
))
6043 || (TREE_CODE (a
->type
) != COMPLEX_TYPE
6044 && TYPE_NAME (a
->type
) != TYPE_NAME (b
->type
)))
6047 /* Be careful about comparing arrays before and after the element type
6048 has been completed; don't compare TYPE_ALIGN unless both types are
6050 if (COMPLETE_TYPE_P (a
->type
) && COMPLETE_TYPE_P (b
->type
)
6051 && (TYPE_ALIGN (a
->type
) != TYPE_ALIGN (b
->type
)
6052 || TYPE_MODE (a
->type
) != TYPE_MODE (b
->type
)))
6055 switch (TREE_CODE (a
->type
))
6060 case REFERENCE_TYPE
:
6064 return TYPE_VECTOR_SUBPARTS (a
->type
) == TYPE_VECTOR_SUBPARTS (b
->type
);
6067 if (TYPE_VALUES (a
->type
) != TYPE_VALUES (b
->type
)
6068 && !(TYPE_VALUES (a
->type
)
6069 && TREE_CODE (TYPE_VALUES (a
->type
)) == TREE_LIST
6070 && TYPE_VALUES (b
->type
)
6071 && TREE_CODE (TYPE_VALUES (b
->type
)) == TREE_LIST
6072 && type_list_equal (TYPE_VALUES (a
->type
),
6073 TYPE_VALUES (b
->type
))))
6076 /* ... fall through ... */
6081 return ((TYPE_MAX_VALUE (a
->type
) == TYPE_MAX_VALUE (b
->type
)
6082 || tree_int_cst_equal (TYPE_MAX_VALUE (a
->type
),
6083 TYPE_MAX_VALUE (b
->type
)))
6084 && (TYPE_MIN_VALUE (a
->type
) == TYPE_MIN_VALUE (b
->type
)
6085 || tree_int_cst_equal (TYPE_MIN_VALUE (a
->type
),
6086 TYPE_MIN_VALUE (b
->type
))));
6088 case FIXED_POINT_TYPE
:
6089 return TYPE_SATURATING (a
->type
) == TYPE_SATURATING (b
->type
);
6092 return TYPE_OFFSET_BASETYPE (a
->type
) == TYPE_OFFSET_BASETYPE (b
->type
);
6095 if (TYPE_METHOD_BASETYPE (a
->type
) == TYPE_METHOD_BASETYPE (b
->type
)
6096 && (TYPE_ARG_TYPES (a
->type
) == TYPE_ARG_TYPES (b
->type
)
6097 || (TYPE_ARG_TYPES (a
->type
)
6098 && TREE_CODE (TYPE_ARG_TYPES (a
->type
)) == TREE_LIST
6099 && TYPE_ARG_TYPES (b
->type
)
6100 && TREE_CODE (TYPE_ARG_TYPES (b
->type
)) == TREE_LIST
6101 && type_list_equal (TYPE_ARG_TYPES (a
->type
),
6102 TYPE_ARG_TYPES (b
->type
)))))
6106 return TYPE_DOMAIN (a
->type
) == TYPE_DOMAIN (b
->type
);
6110 case QUAL_UNION_TYPE
:
6111 return (TYPE_FIELDS (a
->type
) == TYPE_FIELDS (b
->type
)
6112 || (TYPE_FIELDS (a
->type
)
6113 && TREE_CODE (TYPE_FIELDS (a
->type
)) == TREE_LIST
6114 && TYPE_FIELDS (b
->type
)
6115 && TREE_CODE (TYPE_FIELDS (b
->type
)) == TREE_LIST
6116 && type_list_equal (TYPE_FIELDS (a
->type
),
6117 TYPE_FIELDS (b
->type
))));
6120 if (TYPE_ARG_TYPES (a
->type
) == TYPE_ARG_TYPES (b
->type
)
6121 || (TYPE_ARG_TYPES (a
->type
)
6122 && TREE_CODE (TYPE_ARG_TYPES (a
->type
)) == TREE_LIST
6123 && TYPE_ARG_TYPES (b
->type
)
6124 && TREE_CODE (TYPE_ARG_TYPES (b
->type
)) == TREE_LIST
6125 && type_list_equal (TYPE_ARG_TYPES (a
->type
),
6126 TYPE_ARG_TYPES (b
->type
))))
6134 if (lang_hooks
.types
.type_hash_eq
!= NULL
)
6135 return lang_hooks
.types
.type_hash_eq (a
->type
, b
->type
);
6140 /* Return the cached hash value. */
6143 type_hash_hash (const void *item
)
6145 return ((const struct type_hash
*) item
)->hash
;
6148 /* Look in the type hash table for a type isomorphic to TYPE.
6149 If one is found, return it. Otherwise return 0. */
6152 type_hash_lookup (hashval_t hashcode
, tree type
)
6154 struct type_hash
*h
, in
;
6156 /* The TYPE_ALIGN field of a type is set by layout_type(), so we
6157 must call that routine before comparing TYPE_ALIGNs. */
6163 h
= (struct type_hash
*) htab_find_with_hash (type_hash_table
, &in
,
6170 /* Add an entry to the type-hash-table
6171 for a type TYPE whose hash code is HASHCODE. */
6174 type_hash_add (hashval_t hashcode
, tree type
)
6176 struct type_hash
*h
;
6179 h
= ggc_alloc_type_hash ();
6182 loc
= htab_find_slot_with_hash (type_hash_table
, h
, hashcode
, INSERT
);
6186 /* Given TYPE, and HASHCODE its hash code, return the canonical
6187 object for an identical type if one already exists.
6188 Otherwise, return TYPE, and record it as the canonical object.
6190 To use this function, first create a type of the sort you want.
6191 Then compute its hash code from the fields of the type that
6192 make it different from other similar types.
6193 Then call this function and use the value. */
6196 type_hash_canon (unsigned int hashcode
, tree type
)
6200 /* The hash table only contains main variants, so ensure that's what we're
6202 gcc_assert (TYPE_MAIN_VARIANT (type
) == type
);
6204 /* See if the type is in the hash table already. If so, return it.
6205 Otherwise, add the type. */
6206 t1
= type_hash_lookup (hashcode
, type
);
6209 #ifdef GATHER_STATISTICS
6210 tree_code_counts
[(int) TREE_CODE (type
)]--;
6211 tree_node_counts
[(int) t_kind
]--;
6212 tree_node_sizes
[(int) t_kind
] -= sizeof (struct tree_type
);
6218 type_hash_add (hashcode
, type
);
6223 /* See if the data pointed to by the type hash table is marked. We consider
6224 it marked if the type is marked or if a debug type number or symbol
6225 table entry has been made for the type. */
6228 type_hash_marked_p (const void *p
)
6230 const_tree
const type
= ((const struct type_hash
*) p
)->type
;
6232 return ggc_marked_p (type
);
6236 print_type_hash_statistics (void)
6238 fprintf (stderr
, "Type hash: size %ld, %ld elements, %f collisions\n",
6239 (long) htab_size (type_hash_table
),
6240 (long) htab_elements (type_hash_table
),
6241 htab_collisions (type_hash_table
));
6244 /* Compute a hash code for a list of attributes (chain of TREE_LIST nodes
6245 with names in the TREE_PURPOSE slots and args in the TREE_VALUE slots),
6246 by adding the hash codes of the individual attributes. */
6249 attribute_hash_list (const_tree list
, hashval_t hashcode
)
6253 for (tail
= list
; tail
; tail
= TREE_CHAIN (tail
))
6254 /* ??? Do we want to add in TREE_VALUE too? */
6255 hashcode
= iterative_hash_object
6256 (IDENTIFIER_HASH_VALUE (TREE_PURPOSE (tail
)), hashcode
);
6260 /* Given two lists of attributes, return true if list l2 is
6261 equivalent to l1. */
6264 attribute_list_equal (const_tree l1
, const_tree l2
)
6266 return attribute_list_contained (l1
, l2
)
6267 && attribute_list_contained (l2
, l1
);
6270 /* Given two lists of attributes, return true if list L2 is
6271 completely contained within L1. */
6272 /* ??? This would be faster if attribute names were stored in a canonicalized
6273 form. Otherwise, if L1 uses `foo' and L2 uses `__foo__', the long method
6274 must be used to show these elements are equivalent (which they are). */
6275 /* ??? It's not clear that attributes with arguments will always be handled
6279 attribute_list_contained (const_tree l1
, const_tree l2
)
6283 /* First check the obvious, maybe the lists are identical. */
6287 /* Maybe the lists are similar. */
6288 for (t1
= l1
, t2
= l2
;
6290 && TREE_PURPOSE (t1
) == TREE_PURPOSE (t2
)
6291 && TREE_VALUE (t1
) == TREE_VALUE (t2
);
6292 t1
= TREE_CHAIN (t1
), t2
= TREE_CHAIN (t2
));
6294 /* Maybe the lists are equal. */
6295 if (t1
== 0 && t2
== 0)
6298 for (; t2
!= 0; t2
= TREE_CHAIN (t2
))
6301 /* This CONST_CAST is okay because lookup_attribute does not
6302 modify its argument and the return value is assigned to a
6304 for (attr
= lookup_attribute (IDENTIFIER_POINTER (TREE_PURPOSE (t2
)),
6305 CONST_CAST_TREE(l1
));
6306 attr
!= NULL_TREE
&& !attribute_value_equal (t2
, attr
);
6307 attr
= lookup_attribute (IDENTIFIER_POINTER (TREE_PURPOSE (t2
)),
6311 if (attr
== NULL_TREE
)
6318 /* Given two lists of types
6319 (chains of TREE_LIST nodes with types in the TREE_VALUE slots)
6320 return 1 if the lists contain the same types in the same order.
6321 Also, the TREE_PURPOSEs must match. */
6324 type_list_equal (const_tree l1
, const_tree l2
)
6328 for (t1
= l1
, t2
= l2
; t1
&& t2
; t1
= TREE_CHAIN (t1
), t2
= TREE_CHAIN (t2
))
6329 if (TREE_VALUE (t1
) != TREE_VALUE (t2
)
6330 || (TREE_PURPOSE (t1
) != TREE_PURPOSE (t2
)
6331 && ! (1 == simple_cst_equal (TREE_PURPOSE (t1
), TREE_PURPOSE (t2
))
6332 && (TREE_TYPE (TREE_PURPOSE (t1
))
6333 == TREE_TYPE (TREE_PURPOSE (t2
))))))
6339 /* Returns the number of arguments to the FUNCTION_TYPE or METHOD_TYPE
6340 given by TYPE. If the argument list accepts variable arguments,
6341 then this function counts only the ordinary arguments. */
6344 type_num_arguments (const_tree type
)
6349 for (t
= TYPE_ARG_TYPES (type
); t
; t
= TREE_CHAIN (t
))
6350 /* If the function does not take a variable number of arguments,
6351 the last element in the list will have type `void'. */
6352 if (VOID_TYPE_P (TREE_VALUE (t
)))
6360 /* Nonzero if integer constants T1 and T2
6361 represent the same constant value. */
6364 tree_int_cst_equal (const_tree t1
, const_tree t2
)
6369 if (t1
== 0 || t2
== 0)
6372 if (TREE_CODE (t1
) == INTEGER_CST
6373 && TREE_CODE (t2
) == INTEGER_CST
6374 && TREE_INT_CST_LOW (t1
) == TREE_INT_CST_LOW (t2
)
6375 && TREE_INT_CST_HIGH (t1
) == TREE_INT_CST_HIGH (t2
))
6381 /* Nonzero if integer constants T1 and T2 represent values that satisfy <.
6382 The precise way of comparison depends on their data type. */
6385 tree_int_cst_lt (const_tree t1
, const_tree t2
)
6390 if (TYPE_UNSIGNED (TREE_TYPE (t1
)) != TYPE_UNSIGNED (TREE_TYPE (t2
)))
6392 int t1_sgn
= tree_int_cst_sgn (t1
);
6393 int t2_sgn
= tree_int_cst_sgn (t2
);
6395 if (t1_sgn
< t2_sgn
)
6397 else if (t1_sgn
> t2_sgn
)
6399 /* Otherwise, both are non-negative, so we compare them as
6400 unsigned just in case one of them would overflow a signed
6403 else if (!TYPE_UNSIGNED (TREE_TYPE (t1
)))
6404 return INT_CST_LT (t1
, t2
);
6406 return INT_CST_LT_UNSIGNED (t1
, t2
);
6409 /* Returns -1 if T1 < T2, 0 if T1 == T2, and 1 if T1 > T2. */
6412 tree_int_cst_compare (const_tree t1
, const_tree t2
)
6414 if (tree_int_cst_lt (t1
, t2
))
6416 else if (tree_int_cst_lt (t2
, t1
))
6422 /* Return 1 if T is an INTEGER_CST that can be manipulated efficiently on
6423 the host. If POS is zero, the value can be represented in a single
6424 HOST_WIDE_INT. If POS is nonzero, the value must be non-negative and can
6425 be represented in a single unsigned HOST_WIDE_INT. */
6428 host_integerp (const_tree t
, int pos
)
6433 return (TREE_CODE (t
) == INTEGER_CST
6434 && ((TREE_INT_CST_HIGH (t
) == 0
6435 && (HOST_WIDE_INT
) TREE_INT_CST_LOW (t
) >= 0)
6436 || (! pos
&& TREE_INT_CST_HIGH (t
) == -1
6437 && (HOST_WIDE_INT
) TREE_INT_CST_LOW (t
) < 0
6438 && (!TYPE_UNSIGNED (TREE_TYPE (t
))
6439 || (TREE_CODE (TREE_TYPE (t
)) == INTEGER_TYPE
6440 && TYPE_IS_SIZETYPE (TREE_TYPE (t
)))))
6441 || (pos
&& TREE_INT_CST_HIGH (t
) == 0)));
6444 /* Return the HOST_WIDE_INT least significant bits of T if it is an
6445 INTEGER_CST and there is no overflow. POS is nonzero if the result must
6446 be non-negative. We must be able to satisfy the above conditions. */
6449 tree_low_cst (const_tree t
, int pos
)
6451 gcc_assert (host_integerp (t
, pos
));
6452 return TREE_INT_CST_LOW (t
);
6455 /* Return the most significant bit of the integer constant T. */
6458 tree_int_cst_msb (const_tree t
)
6462 unsigned HOST_WIDE_INT l
;
6464 /* Note that using TYPE_PRECISION here is wrong. We care about the
6465 actual bits, not the (arbitrary) range of the type. */
6466 prec
= GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (t
))) - 1;
6467 rshift_double (TREE_INT_CST_LOW (t
), TREE_INT_CST_HIGH (t
), prec
,
6468 2 * HOST_BITS_PER_WIDE_INT
, &l
, &h
, 0);
6469 return (l
& 1) == 1;
6472 /* Return an indication of the sign of the integer constant T.
6473 The return value is -1 if T < 0, 0 if T == 0, and 1 if T > 0.
6474 Note that -1 will never be returned if T's type is unsigned. */
6477 tree_int_cst_sgn (const_tree t
)
6479 if (TREE_INT_CST_LOW (t
) == 0 && TREE_INT_CST_HIGH (t
) == 0)
6481 else if (TYPE_UNSIGNED (TREE_TYPE (t
)))
6483 else if (TREE_INT_CST_HIGH (t
) < 0)
6489 /* Return the minimum number of bits needed to represent VALUE in a
6490 signed or unsigned type, UNSIGNEDP says which. */
6493 tree_int_cst_min_precision (tree value
, bool unsignedp
)
6497 /* If the value is negative, compute its negative minus 1. The latter
6498 adjustment is because the absolute value of the largest negative value
6499 is one larger than the largest positive value. This is equivalent to
6500 a bit-wise negation, so use that operation instead. */
6502 if (tree_int_cst_sgn (value
) < 0)
6503 value
= fold_build1 (BIT_NOT_EXPR
, TREE_TYPE (value
), value
);
6505 /* Return the number of bits needed, taking into account the fact
6506 that we need one more bit for a signed than unsigned type. */
6508 if (integer_zerop (value
))
6511 log
= tree_floor_log2 (value
);
6513 return log
+ 1 + !unsignedp
;
6516 /* Compare two constructor-element-type constants. Return 1 if the lists
6517 are known to be equal; otherwise return 0. */
6520 simple_cst_list_equal (const_tree l1
, const_tree l2
)
6522 while (l1
!= NULL_TREE
&& l2
!= NULL_TREE
)
6524 if (simple_cst_equal (TREE_VALUE (l1
), TREE_VALUE (l2
)) != 1)
6527 l1
= TREE_CHAIN (l1
);
6528 l2
= TREE_CHAIN (l2
);
6534 /* Return truthvalue of whether T1 is the same tree structure as T2.
6535 Return 1 if they are the same.
6536 Return 0 if they are understandably different.
6537 Return -1 if either contains tree structure not understood by
6541 simple_cst_equal (const_tree t1
, const_tree t2
)
6543 enum tree_code code1
, code2
;
6549 if (t1
== 0 || t2
== 0)
6552 code1
= TREE_CODE (t1
);
6553 code2
= TREE_CODE (t2
);
6555 if (CONVERT_EXPR_CODE_P (code1
) || code1
== NON_LVALUE_EXPR
)
6557 if (CONVERT_EXPR_CODE_P (code2
)
6558 || code2
== NON_LVALUE_EXPR
)
6559 return simple_cst_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
6561 return simple_cst_equal (TREE_OPERAND (t1
, 0), t2
);
6564 else if (CONVERT_EXPR_CODE_P (code2
)
6565 || code2
== NON_LVALUE_EXPR
)
6566 return simple_cst_equal (t1
, TREE_OPERAND (t2
, 0));
6574 return (TREE_INT_CST_LOW (t1
) == TREE_INT_CST_LOW (t2
)
6575 && TREE_INT_CST_HIGH (t1
) == TREE_INT_CST_HIGH (t2
));
6578 return REAL_VALUES_IDENTICAL (TREE_REAL_CST (t1
), TREE_REAL_CST (t2
));
6581 return FIXED_VALUES_IDENTICAL (TREE_FIXED_CST (t1
), TREE_FIXED_CST (t2
));
6584 return (TREE_STRING_LENGTH (t1
) == TREE_STRING_LENGTH (t2
)
6585 && ! memcmp (TREE_STRING_POINTER (t1
), TREE_STRING_POINTER (t2
),
6586 TREE_STRING_LENGTH (t1
)));
6590 unsigned HOST_WIDE_INT idx
;
6591 VEC(constructor_elt
, gc
) *v1
= CONSTRUCTOR_ELTS (t1
);
6592 VEC(constructor_elt
, gc
) *v2
= CONSTRUCTOR_ELTS (t2
);
6594 if (VEC_length (constructor_elt
, v1
) != VEC_length (constructor_elt
, v2
))
6597 for (idx
= 0; idx
< VEC_length (constructor_elt
, v1
); ++idx
)
6598 /* ??? Should we handle also fields here? */
6599 if (!simple_cst_equal (VEC_index (constructor_elt
, v1
, idx
)->value
,
6600 VEC_index (constructor_elt
, v2
, idx
)->value
))
6606 return simple_cst_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
6609 cmp
= simple_cst_equal (CALL_EXPR_FN (t1
), CALL_EXPR_FN (t2
));
6612 if (call_expr_nargs (t1
) != call_expr_nargs (t2
))
6615 const_tree arg1
, arg2
;
6616 const_call_expr_arg_iterator iter1
, iter2
;
6617 for (arg1
= first_const_call_expr_arg (t1
, &iter1
),
6618 arg2
= first_const_call_expr_arg (t2
, &iter2
);
6620 arg1
= next_const_call_expr_arg (&iter1
),
6621 arg2
= next_const_call_expr_arg (&iter2
))
6623 cmp
= simple_cst_equal (arg1
, arg2
);
6627 return arg1
== arg2
;
6631 /* Special case: if either target is an unallocated VAR_DECL,
6632 it means that it's going to be unified with whatever the
6633 TARGET_EXPR is really supposed to initialize, so treat it
6634 as being equivalent to anything. */
6635 if ((TREE_CODE (TREE_OPERAND (t1
, 0)) == VAR_DECL
6636 && DECL_NAME (TREE_OPERAND (t1
, 0)) == NULL_TREE
6637 && !DECL_RTL_SET_P (TREE_OPERAND (t1
, 0)))
6638 || (TREE_CODE (TREE_OPERAND (t2
, 0)) == VAR_DECL
6639 && DECL_NAME (TREE_OPERAND (t2
, 0)) == NULL_TREE
6640 && !DECL_RTL_SET_P (TREE_OPERAND (t2
, 0))))
6643 cmp
= simple_cst_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
6648 return simple_cst_equal (TREE_OPERAND (t1
, 1), TREE_OPERAND (t2
, 1));
6650 case WITH_CLEANUP_EXPR
:
6651 cmp
= simple_cst_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
6655 return simple_cst_equal (TREE_OPERAND (t1
, 1), TREE_OPERAND (t1
, 1));
6658 if (TREE_OPERAND (t1
, 1) == TREE_OPERAND (t2
, 1))
6659 return simple_cst_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
6673 /* This general rule works for most tree codes. All exceptions should be
6674 handled above. If this is a language-specific tree code, we can't
6675 trust what might be in the operand, so say we don't know
6677 if ((int) code1
>= (int) LAST_AND_UNUSED_TREE_CODE
)
6680 switch (TREE_CODE_CLASS (code1
))
6684 case tcc_comparison
:
6685 case tcc_expression
:
6689 for (i
= 0; i
< TREE_CODE_LENGTH (code1
); i
++)
6691 cmp
= simple_cst_equal (TREE_OPERAND (t1
, i
), TREE_OPERAND (t2
, i
));
6703 /* Compare the value of T, an INTEGER_CST, with U, an unsigned integer value.
6704 Return -1, 0, or 1 if the value of T is less than, equal to, or greater
6705 than U, respectively. */
6708 compare_tree_int (const_tree t
, unsigned HOST_WIDE_INT u
)
6710 if (tree_int_cst_sgn (t
) < 0)
6712 else if (TREE_INT_CST_HIGH (t
) != 0)
6714 else if (TREE_INT_CST_LOW (t
) == u
)
6716 else if (TREE_INT_CST_LOW (t
) < u
)
6722 /* Return true if CODE represents an associative tree code. Otherwise
6725 associative_tree_code (enum tree_code code
)
6744 /* Return true if CODE represents a commutative tree code. Otherwise
6747 commutative_tree_code (enum tree_code code
)
6760 case UNORDERED_EXPR
:
6764 case TRUTH_AND_EXPR
:
6765 case TRUTH_XOR_EXPR
:
6775 /* Return true if CODE represents a ternary tree code for which the
6776 first two operands are commutative. Otherwise return false. */
6778 commutative_ternary_tree_code (enum tree_code code
)
6782 case WIDEN_MULT_PLUS_EXPR
:
6783 case WIDEN_MULT_MINUS_EXPR
:
6792 /* Generate a hash value for an expression. This can be used iteratively
6793 by passing a previous result as the VAL argument.
6795 This function is intended to produce the same hash for expressions which
6796 would compare equal using operand_equal_p. */
6799 iterative_hash_expr (const_tree t
, hashval_t val
)
6802 enum tree_code code
;
6806 return iterative_hash_hashval_t (0, val
);
6808 code
= TREE_CODE (t
);
6812 /* Alas, constants aren't shared, so we can't rely on pointer
6815 val
= iterative_hash_host_wide_int (TREE_INT_CST_LOW (t
), val
);
6816 return iterative_hash_host_wide_int (TREE_INT_CST_HIGH (t
), val
);
6819 unsigned int val2
= real_hash (TREE_REAL_CST_PTR (t
));
6821 return iterative_hash_hashval_t (val2
, val
);
6825 unsigned int val2
= fixed_hash (TREE_FIXED_CST_PTR (t
));
6827 return iterative_hash_hashval_t (val2
, val
);
6830 return iterative_hash (TREE_STRING_POINTER (t
),
6831 TREE_STRING_LENGTH (t
), val
);
6833 val
= iterative_hash_expr (TREE_REALPART (t
), val
);
6834 return iterative_hash_expr (TREE_IMAGPART (t
), val
);
6836 return iterative_hash_expr (TREE_VECTOR_CST_ELTS (t
), val
);
6838 /* We can just compare by pointer. */
6839 return iterative_hash_host_wide_int (SSA_NAME_VERSION (t
), val
);
6840 case PLACEHOLDER_EXPR
:
6841 /* The node itself doesn't matter. */
6844 /* A list of expressions, for a CALL_EXPR or as the elements of a
6846 for (; t
; t
= TREE_CHAIN (t
))
6847 val
= iterative_hash_expr (TREE_VALUE (t
), val
);
6851 unsigned HOST_WIDE_INT idx
;
6853 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t
), idx
, field
, value
)
6855 val
= iterative_hash_expr (field
, val
);
6856 val
= iterative_hash_expr (value
, val
);
6862 /* The type of the second operand is relevant, except for
6863 its top-level qualifiers. */
6864 tree type
= TYPE_MAIN_VARIANT (TREE_TYPE (TREE_OPERAND (t
, 1)));
6866 val
= iterative_hash_object (TYPE_HASH (type
), val
);
6868 /* We could use the standard hash computation from this point
6870 val
= iterative_hash_object (code
, val
);
6871 val
= iterative_hash_expr (TREE_OPERAND (t
, 1), val
);
6872 val
= iterative_hash_expr (TREE_OPERAND (t
, 0), val
);
6876 /* When referring to a built-in FUNCTION_DECL, use the __builtin__ form.
6877 Otherwise nodes that compare equal according to operand_equal_p might
6878 get different hash codes. However, don't do this for machine specific
6879 or front end builtins, since the function code is overloaded in those
6881 if (DECL_BUILT_IN_CLASS (t
) == BUILT_IN_NORMAL
6882 && built_in_decls
[DECL_FUNCTION_CODE (t
)])
6884 t
= built_in_decls
[DECL_FUNCTION_CODE (t
)];
6885 code
= TREE_CODE (t
);
6889 tclass
= TREE_CODE_CLASS (code
);
6891 if (tclass
== tcc_declaration
)
6893 /* DECL's have a unique ID */
6894 val
= iterative_hash_host_wide_int (DECL_UID (t
), val
);
6898 gcc_assert (IS_EXPR_CODE_CLASS (tclass
));
6900 val
= iterative_hash_object (code
, val
);
6902 /* Don't hash the type, that can lead to having nodes which
6903 compare equal according to operand_equal_p, but which
6904 have different hash codes. */
6905 if (CONVERT_EXPR_CODE_P (code
)
6906 || code
== NON_LVALUE_EXPR
)
6908 /* Make sure to include signness in the hash computation. */
6909 val
+= TYPE_UNSIGNED (TREE_TYPE (t
));
6910 val
= iterative_hash_expr (TREE_OPERAND (t
, 0), val
);
6913 else if (commutative_tree_code (code
))
6915 /* It's a commutative expression. We want to hash it the same
6916 however it appears. We do this by first hashing both operands
6917 and then rehashing based on the order of their independent
6919 hashval_t one
= iterative_hash_expr (TREE_OPERAND (t
, 0), 0);
6920 hashval_t two
= iterative_hash_expr (TREE_OPERAND (t
, 1), 0);
6924 t
= one
, one
= two
, two
= t
;
6926 val
= iterative_hash_hashval_t (one
, val
);
6927 val
= iterative_hash_hashval_t (two
, val
);
6930 for (i
= TREE_OPERAND_LENGTH (t
) - 1; i
>= 0; --i
)
6931 val
= iterative_hash_expr (TREE_OPERAND (t
, i
), val
);
6938 /* Generate a hash value for a pair of expressions. This can be used
6939 iteratively by passing a previous result as the VAL argument.
6941 The same hash value is always returned for a given pair of expressions,
6942 regardless of the order in which they are presented. This is useful in
6943 hashing the operands of commutative functions. */
6946 iterative_hash_exprs_commutative (const_tree t1
,
6947 const_tree t2
, hashval_t val
)
6949 hashval_t one
= iterative_hash_expr (t1
, 0);
6950 hashval_t two
= iterative_hash_expr (t2
, 0);
6954 t
= one
, one
= two
, two
= t
;
6955 val
= iterative_hash_hashval_t (one
, val
);
6956 val
= iterative_hash_hashval_t (two
, val
);
6961 /* Constructors for pointer, array and function types.
6962 (RECORD_TYPE, UNION_TYPE and ENUMERAL_TYPE nodes are
6963 constructed by language-dependent code, not here.) */
6965 /* Construct, lay out and return the type of pointers to TO_TYPE with
6966 mode MODE. If CAN_ALIAS_ALL is TRUE, indicate this type can
6967 reference all of memory. If such a type has already been
6968 constructed, reuse it. */
6971 build_pointer_type_for_mode (tree to_type
, enum machine_mode mode
,
6976 if (to_type
== error_mark_node
)
6977 return error_mark_node
;
6979 /* If the pointed-to type has the may_alias attribute set, force
6980 a TYPE_REF_CAN_ALIAS_ALL pointer to be generated. */
6981 if (lookup_attribute ("may_alias", TYPE_ATTRIBUTES (to_type
)))
6982 can_alias_all
= true;
6984 /* In some cases, languages will have things that aren't a POINTER_TYPE
6985 (such as a RECORD_TYPE for fat pointers in Ada) as TYPE_POINTER_TO.
6986 In that case, return that type without regard to the rest of our
6989 ??? This is a kludge, but consistent with the way this function has
6990 always operated and there doesn't seem to be a good way to avoid this
6992 if (TYPE_POINTER_TO (to_type
) != 0
6993 && TREE_CODE (TYPE_POINTER_TO (to_type
)) != POINTER_TYPE
)
6994 return TYPE_POINTER_TO (to_type
);
6996 /* First, if we already have a type for pointers to TO_TYPE and it's
6997 the proper mode, use it. */
6998 for (t
= TYPE_POINTER_TO (to_type
); t
; t
= TYPE_NEXT_PTR_TO (t
))
6999 if (TYPE_MODE (t
) == mode
&& TYPE_REF_CAN_ALIAS_ALL (t
) == can_alias_all
)
7002 t
= make_node (POINTER_TYPE
);
7004 TREE_TYPE (t
) = to_type
;
7005 SET_TYPE_MODE (t
, mode
);
7006 TYPE_REF_CAN_ALIAS_ALL (t
) = can_alias_all
;
7007 TYPE_NEXT_PTR_TO (t
) = TYPE_POINTER_TO (to_type
);
7008 TYPE_POINTER_TO (to_type
) = t
;
7010 if (TYPE_STRUCTURAL_EQUALITY_P (to_type
))
7011 SET_TYPE_STRUCTURAL_EQUALITY (t
);
7012 else if (TYPE_CANONICAL (to_type
) != to_type
)
7014 = build_pointer_type_for_mode (TYPE_CANONICAL (to_type
),
7015 mode
, can_alias_all
);
7017 /* Lay out the type. This function has many callers that are concerned
7018 with expression-construction, and this simplifies them all. */
7024 /* By default build pointers in ptr_mode. */
7027 build_pointer_type (tree to_type
)
7029 addr_space_t as
= to_type
== error_mark_node
? ADDR_SPACE_GENERIC
7030 : TYPE_ADDR_SPACE (to_type
);
7031 enum machine_mode pointer_mode
= targetm
.addr_space
.pointer_mode (as
);
7032 return build_pointer_type_for_mode (to_type
, pointer_mode
, false);
7035 /* Same as build_pointer_type_for_mode, but for REFERENCE_TYPE. */
7038 build_reference_type_for_mode (tree to_type
, enum machine_mode mode
,
7043 if (to_type
== error_mark_node
)
7044 return error_mark_node
;
7046 /* If the pointed-to type has the may_alias attribute set, force
7047 a TYPE_REF_CAN_ALIAS_ALL pointer to be generated. */
7048 if (lookup_attribute ("may_alias", TYPE_ATTRIBUTES (to_type
)))
7049 can_alias_all
= true;
7051 /* In some cases, languages will have things that aren't a REFERENCE_TYPE
7052 (such as a RECORD_TYPE for fat pointers in Ada) as TYPE_REFERENCE_TO.
7053 In that case, return that type without regard to the rest of our
7056 ??? This is a kludge, but consistent with the way this function has
7057 always operated and there doesn't seem to be a good way to avoid this
7059 if (TYPE_REFERENCE_TO (to_type
) != 0
7060 && TREE_CODE (TYPE_REFERENCE_TO (to_type
)) != REFERENCE_TYPE
)
7061 return TYPE_REFERENCE_TO (to_type
);
7063 /* First, if we already have a type for pointers to TO_TYPE and it's
7064 the proper mode, use it. */
7065 for (t
= TYPE_REFERENCE_TO (to_type
); t
; t
= TYPE_NEXT_REF_TO (t
))
7066 if (TYPE_MODE (t
) == mode
&& TYPE_REF_CAN_ALIAS_ALL (t
) == can_alias_all
)
7069 t
= make_node (REFERENCE_TYPE
);
7071 TREE_TYPE (t
) = to_type
;
7072 SET_TYPE_MODE (t
, mode
);
7073 TYPE_REF_CAN_ALIAS_ALL (t
) = can_alias_all
;
7074 TYPE_NEXT_REF_TO (t
) = TYPE_REFERENCE_TO (to_type
);
7075 TYPE_REFERENCE_TO (to_type
) = t
;
7077 if (TYPE_STRUCTURAL_EQUALITY_P (to_type
))
7078 SET_TYPE_STRUCTURAL_EQUALITY (t
);
7079 else if (TYPE_CANONICAL (to_type
) != to_type
)
7081 = build_reference_type_for_mode (TYPE_CANONICAL (to_type
),
7082 mode
, can_alias_all
);
7090 /* Build the node for the type of references-to-TO_TYPE by default
7094 build_reference_type (tree to_type
)
7096 addr_space_t as
= to_type
== error_mark_node
? ADDR_SPACE_GENERIC
7097 : TYPE_ADDR_SPACE (to_type
);
7098 enum machine_mode pointer_mode
= targetm
.addr_space
.pointer_mode (as
);
7099 return build_reference_type_for_mode (to_type
, pointer_mode
, false);
7102 /* Build a type that is compatible with t but has no cv quals anywhere
7105 const char *const *const * -> char ***. */
7108 build_type_no_quals (tree t
)
7110 switch (TREE_CODE (t
))
7113 return build_pointer_type_for_mode (build_type_no_quals (TREE_TYPE (t
)),
7115 TYPE_REF_CAN_ALIAS_ALL (t
));
7116 case REFERENCE_TYPE
:
7118 build_reference_type_for_mode (build_type_no_quals (TREE_TYPE (t
)),
7120 TYPE_REF_CAN_ALIAS_ALL (t
));
7122 return TYPE_MAIN_VARIANT (t
);
7126 #define MAX_INT_CACHED_PREC \
7127 (HOST_BITS_PER_WIDE_INT > 64 ? HOST_BITS_PER_WIDE_INT : 64)
7128 static GTY(()) tree nonstandard_integer_type_cache
[2 * MAX_INT_CACHED_PREC
+ 2];
7130 /* Builds a signed or unsigned integer type of precision PRECISION.
7131 Used for C bitfields whose precision does not match that of
7132 built-in target types. */
7134 build_nonstandard_integer_type (unsigned HOST_WIDE_INT precision
,
7140 unsignedp
= MAX_INT_CACHED_PREC
+ 1;
7142 if (precision
<= MAX_INT_CACHED_PREC
)
7144 itype
= nonstandard_integer_type_cache
[precision
+ unsignedp
];
7149 itype
= make_node (INTEGER_TYPE
);
7150 TYPE_PRECISION (itype
) = precision
;
7153 fixup_unsigned_type (itype
);
7155 fixup_signed_type (itype
);
7158 if (host_integerp (TYPE_MAX_VALUE (itype
), 1))
7159 ret
= type_hash_canon (tree_low_cst (TYPE_MAX_VALUE (itype
), 1), itype
);
7160 if (precision
<= MAX_INT_CACHED_PREC
)
7161 nonstandard_integer_type_cache
[precision
+ unsignedp
] = ret
;
7166 /* Create a range of some discrete type TYPE (an INTEGER_TYPE, ENUMERAL_TYPE
7167 or BOOLEAN_TYPE) with low bound LOWVAL and high bound HIGHVAL. If SHARED
7168 is true, reuse such a type that has already been constructed. */
7171 build_range_type_1 (tree type
, tree lowval
, tree highval
, bool shared
)
7173 tree itype
= make_node (INTEGER_TYPE
);
7174 hashval_t hashcode
= 0;
7176 TREE_TYPE (itype
) = type
;
7178 TYPE_MIN_VALUE (itype
) = fold_convert (type
, lowval
);
7179 TYPE_MAX_VALUE (itype
) = highval
? fold_convert (type
, highval
) : NULL
;
7181 TYPE_PRECISION (itype
) = TYPE_PRECISION (type
);
7182 SET_TYPE_MODE (itype
, TYPE_MODE (type
));
7183 TYPE_SIZE (itype
) = TYPE_SIZE (type
);
7184 TYPE_SIZE_UNIT (itype
) = TYPE_SIZE_UNIT (type
);
7185 TYPE_ALIGN (itype
) = TYPE_ALIGN (type
);
7186 TYPE_USER_ALIGN (itype
) = TYPE_USER_ALIGN (type
);
7191 if ((TYPE_MIN_VALUE (itype
)
7192 && TREE_CODE (TYPE_MIN_VALUE (itype
)) != INTEGER_CST
)
7193 || (TYPE_MAX_VALUE (itype
)
7194 && TREE_CODE (TYPE_MAX_VALUE (itype
)) != INTEGER_CST
))
7196 /* Since we cannot reliably merge this type, we need to compare it using
7197 structural equality checks. */
7198 SET_TYPE_STRUCTURAL_EQUALITY (itype
);
7202 hashcode
= iterative_hash_expr (TYPE_MIN_VALUE (itype
), hashcode
);
7203 hashcode
= iterative_hash_expr (TYPE_MAX_VALUE (itype
), hashcode
);
7204 hashcode
= iterative_hash_hashval_t (TYPE_HASH (type
), hashcode
);
7205 itype
= type_hash_canon (hashcode
, itype
);
7210 /* Wrapper around build_range_type_1 with SHARED set to true. */
7213 build_range_type (tree type
, tree lowval
, tree highval
)
7215 return build_range_type_1 (type
, lowval
, highval
, true);
7218 /* Wrapper around build_range_type_1 with SHARED set to false. */
7221 build_nonshared_range_type (tree type
, tree lowval
, tree highval
)
7223 return build_range_type_1 (type
, lowval
, highval
, false);
7226 /* Create a type of integers to be the TYPE_DOMAIN of an ARRAY_TYPE.
7227 MAXVAL should be the maximum value in the domain
7228 (one less than the length of the array).
7230 The maximum value that MAXVAL can have is INT_MAX for a HOST_WIDE_INT.
7231 We don't enforce this limit, that is up to caller (e.g. language front end).
7232 The limit exists because the result is a signed type and we don't handle
7233 sizes that use more than one HOST_WIDE_INT. */
7236 build_index_type (tree maxval
)
7238 return build_range_type (sizetype
, size_zero_node
, maxval
);
7241 /* Return true if the debug information for TYPE, a subtype, should be emitted
7242 as a subrange type. If so, set LOWVAL to the low bound and HIGHVAL to the
7243 high bound, respectively. Sometimes doing so unnecessarily obfuscates the
7244 debug info and doesn't reflect the source code. */
7247 subrange_type_for_debug_p (const_tree type
, tree
*lowval
, tree
*highval
)
7249 tree base_type
= TREE_TYPE (type
), low
, high
;
7251 /* Subrange types have a base type which is an integral type. */
7252 if (!INTEGRAL_TYPE_P (base_type
))
7255 /* Get the real bounds of the subtype. */
7256 if (lang_hooks
.types
.get_subrange_bounds
)
7257 lang_hooks
.types
.get_subrange_bounds (type
, &low
, &high
);
7260 low
= TYPE_MIN_VALUE (type
);
7261 high
= TYPE_MAX_VALUE (type
);
7264 /* If the type and its base type have the same representation and the same
7265 name, then the type is not a subrange but a copy of the base type. */
7266 if ((TREE_CODE (base_type
) == INTEGER_TYPE
7267 || TREE_CODE (base_type
) == BOOLEAN_TYPE
)
7268 && int_size_in_bytes (type
) == int_size_in_bytes (base_type
)
7269 && tree_int_cst_equal (low
, TYPE_MIN_VALUE (base_type
))
7270 && tree_int_cst_equal (high
, TYPE_MAX_VALUE (base_type
)))
7272 tree type_name
= TYPE_NAME (type
);
7273 tree base_type_name
= TYPE_NAME (base_type
);
7275 if (type_name
&& TREE_CODE (type_name
) == TYPE_DECL
)
7276 type_name
= DECL_NAME (type_name
);
7278 if (base_type_name
&& TREE_CODE (base_type_name
) == TYPE_DECL
)
7279 base_type_name
= DECL_NAME (base_type_name
);
7281 if (type_name
== base_type_name
)
7292 /* Construct, lay out and return the type of arrays of elements with ELT_TYPE
7293 and number of elements specified by the range of values of INDEX_TYPE.
7294 If SHARED is true, reuse such a type that has already been constructed. */
7297 build_array_type_1 (tree elt_type
, tree index_type
, bool shared
)
7301 if (TREE_CODE (elt_type
) == FUNCTION_TYPE
)
7303 error ("arrays of functions are not meaningful");
7304 elt_type
= integer_type_node
;
7307 t
= make_node (ARRAY_TYPE
);
7308 TREE_TYPE (t
) = elt_type
;
7309 TYPE_DOMAIN (t
) = index_type
;
7310 TYPE_ADDR_SPACE (t
) = TYPE_ADDR_SPACE (elt_type
);
7313 /* If the element type is incomplete at this point we get marked for
7314 structural equality. Do not record these types in the canonical
7316 if (TYPE_STRUCTURAL_EQUALITY_P (t
))
7321 hashval_t hashcode
= iterative_hash_object (TYPE_HASH (elt_type
), 0);
7323 hashcode
= iterative_hash_object (TYPE_HASH (index_type
), hashcode
);
7324 t
= type_hash_canon (hashcode
, t
);
7327 if (TYPE_CANONICAL (t
) == t
)
7329 if (TYPE_STRUCTURAL_EQUALITY_P (elt_type
)
7330 || (index_type
&& TYPE_STRUCTURAL_EQUALITY_P (index_type
)))
7331 SET_TYPE_STRUCTURAL_EQUALITY (t
);
7332 else if (TYPE_CANONICAL (elt_type
) != elt_type
7333 || (index_type
&& TYPE_CANONICAL (index_type
) != index_type
))
7335 = build_array_type_1 (TYPE_CANONICAL (elt_type
),
7337 ? TYPE_CANONICAL (index_type
) : NULL_TREE
,
7344 /* Wrapper around build_array_type_1 with SHARED set to true. */
7347 build_array_type (tree elt_type
, tree index_type
)
7349 return build_array_type_1 (elt_type
, index_type
, true);
7352 /* Wrapper around build_array_type_1 with SHARED set to false. */
7355 build_nonshared_array_type (tree elt_type
, tree index_type
)
7357 return build_array_type_1 (elt_type
, index_type
, false);
7360 /* Return a representation of ELT_TYPE[NELTS], using indices of type
7364 build_array_type_nelts (tree elt_type
, unsigned HOST_WIDE_INT nelts
)
7366 return build_array_type (elt_type
, build_index_type (size_int (nelts
- 1)));
7369 /* Recursively examines the array elements of TYPE, until a non-array
7370 element type is found. */
7373 strip_array_types (tree type
)
7375 while (TREE_CODE (type
) == ARRAY_TYPE
)
7376 type
= TREE_TYPE (type
);
7381 /* Computes the canonical argument types from the argument type list
7384 Upon return, *ANY_STRUCTURAL_P will be true iff either it was true
7385 on entry to this function, or if any of the ARGTYPES are
7388 Upon return, *ANY_NONCANONICAL_P will be true iff either it was
7389 true on entry to this function, or if any of the ARGTYPES are
7392 Returns a canonical argument list, which may be ARGTYPES when the
7393 canonical argument list is unneeded (i.e., *ANY_STRUCTURAL_P is
7394 true) or would not differ from ARGTYPES. */
7397 maybe_canonicalize_argtypes(tree argtypes
,
7398 bool *any_structural_p
,
7399 bool *any_noncanonical_p
)
7402 bool any_noncanonical_argtypes_p
= false;
7404 for (arg
= argtypes
; arg
&& !(*any_structural_p
); arg
= TREE_CHAIN (arg
))
7406 if (!TREE_VALUE (arg
) || TREE_VALUE (arg
) == error_mark_node
)
7407 /* Fail gracefully by stating that the type is structural. */
7408 *any_structural_p
= true;
7409 else if (TYPE_STRUCTURAL_EQUALITY_P (TREE_VALUE (arg
)))
7410 *any_structural_p
= true;
7411 else if (TYPE_CANONICAL (TREE_VALUE (arg
)) != TREE_VALUE (arg
)
7412 || TREE_PURPOSE (arg
))
7413 /* If the argument has a default argument, we consider it
7414 non-canonical even though the type itself is canonical.
7415 That way, different variants of function and method types
7416 with default arguments will all point to the variant with
7417 no defaults as their canonical type. */
7418 any_noncanonical_argtypes_p
= true;
7421 if (*any_structural_p
)
7424 if (any_noncanonical_argtypes_p
)
7426 /* Build the canonical list of argument types. */
7427 tree canon_argtypes
= NULL_TREE
;
7428 bool is_void
= false;
7430 for (arg
= argtypes
; arg
; arg
= TREE_CHAIN (arg
))
7432 if (arg
== void_list_node
)
7435 canon_argtypes
= tree_cons (NULL_TREE
,
7436 TYPE_CANONICAL (TREE_VALUE (arg
)),
7440 canon_argtypes
= nreverse (canon_argtypes
);
7442 canon_argtypes
= chainon (canon_argtypes
, void_list_node
);
7444 /* There is a non-canonical type. */
7445 *any_noncanonical_p
= true;
7446 return canon_argtypes
;
7449 /* The canonical argument types are the same as ARGTYPES. */
7453 /* Construct, lay out and return
7454 the type of functions returning type VALUE_TYPE
7455 given arguments of types ARG_TYPES.
7456 ARG_TYPES is a chain of TREE_LIST nodes whose TREE_VALUEs
7457 are data type nodes for the arguments of the function.
7458 If such a type has already been constructed, reuse it. */
7461 build_function_type (tree value_type
, tree arg_types
)
7464 hashval_t hashcode
= 0;
7465 bool any_structural_p
, any_noncanonical_p
;
7466 tree canon_argtypes
;
7468 if (TREE_CODE (value_type
) == FUNCTION_TYPE
)
7470 error ("function return type cannot be function");
7471 value_type
= integer_type_node
;
7474 /* Make a node of the sort we want. */
7475 t
= make_node (FUNCTION_TYPE
);
7476 TREE_TYPE (t
) = value_type
;
7477 TYPE_ARG_TYPES (t
) = arg_types
;
7479 /* If we already have such a type, use the old one. */
7480 hashcode
= iterative_hash_object (TYPE_HASH (value_type
), hashcode
);
7481 hashcode
= type_hash_list (arg_types
, hashcode
);
7482 t
= type_hash_canon (hashcode
, t
);
7484 /* Set up the canonical type. */
7485 any_structural_p
= TYPE_STRUCTURAL_EQUALITY_P (value_type
);
7486 any_noncanonical_p
= TYPE_CANONICAL (value_type
) != value_type
;
7487 canon_argtypes
= maybe_canonicalize_argtypes (arg_types
,
7489 &any_noncanonical_p
);
7490 if (any_structural_p
)
7491 SET_TYPE_STRUCTURAL_EQUALITY (t
);
7492 else if (any_noncanonical_p
)
7493 TYPE_CANONICAL (t
) = build_function_type (TYPE_CANONICAL (value_type
),
7496 if (!COMPLETE_TYPE_P (t
))
7501 /* Build variant of function type ORIG_TYPE skipping ARGS_TO_SKIP. */
7504 build_function_type_skip_args (tree orig_type
, bitmap args_to_skip
)
7506 tree new_type
= NULL
;
7507 tree args
, new_args
= NULL
, t
;
7511 for (args
= TYPE_ARG_TYPES (orig_type
); args
&& args
!= void_list_node
;
7512 args
= TREE_CHAIN (args
), i
++)
7513 if (!bitmap_bit_p (args_to_skip
, i
))
7514 new_args
= tree_cons (NULL_TREE
, TREE_VALUE (args
), new_args
);
7516 new_reversed
= nreverse (new_args
);
7520 TREE_CHAIN (new_args
) = void_list_node
;
7522 new_reversed
= void_list_node
;
7525 /* Use copy_node to preserve as much as possible from original type
7526 (debug info, attribute lists etc.)
7527 Exception is METHOD_TYPEs must have THIS argument.
7528 When we are asked to remove it, we need to build new FUNCTION_TYPE
7530 if (TREE_CODE (orig_type
) != METHOD_TYPE
7531 || !bitmap_bit_p (args_to_skip
, 0))
7533 new_type
= build_distinct_type_copy (orig_type
);
7534 TYPE_ARG_TYPES (new_type
) = new_reversed
;
7539 = build_distinct_type_copy (build_function_type (TREE_TYPE (orig_type
),
7541 TYPE_CONTEXT (new_type
) = TYPE_CONTEXT (orig_type
);
7544 /* This is a new type, not a copy of an old type. Need to reassociate
7545 variants. We can handle everything except the main variant lazily. */
7546 t
= TYPE_MAIN_VARIANT (orig_type
);
7549 TYPE_MAIN_VARIANT (new_type
) = t
;
7550 TYPE_NEXT_VARIANT (new_type
) = TYPE_NEXT_VARIANT (t
);
7551 TYPE_NEXT_VARIANT (t
) = new_type
;
7555 TYPE_MAIN_VARIANT (new_type
) = new_type
;
7556 TYPE_NEXT_VARIANT (new_type
) = NULL
;
7561 /* Build variant of function type ORIG_TYPE skipping ARGS_TO_SKIP.
7563 Arguments from DECL_ARGUMENTS list can't be removed now, since they are
7564 linked by TREE_CHAIN directly. The caller is responsible for eliminating
7565 them when they are being duplicated (i.e. copy_arguments_for_versioning). */
7568 build_function_decl_skip_args (tree orig_decl
, bitmap args_to_skip
)
7570 tree new_decl
= copy_node (orig_decl
);
7573 new_type
= TREE_TYPE (orig_decl
);
7574 if (prototype_p (new_type
))
7575 new_type
= build_function_type_skip_args (new_type
, args_to_skip
);
7576 TREE_TYPE (new_decl
) = new_type
;
7578 /* For declarations setting DECL_VINDEX (i.e. methods)
7579 we expect first argument to be THIS pointer. */
7580 if (bitmap_bit_p (args_to_skip
, 0))
7581 DECL_VINDEX (new_decl
) = NULL_TREE
;
7583 /* When signature changes, we need to clear builtin info. */
7584 if (DECL_BUILT_IN (new_decl
) && !bitmap_empty_p (args_to_skip
))
7586 DECL_BUILT_IN_CLASS (new_decl
) = NOT_BUILT_IN
;
7587 DECL_FUNCTION_CODE (new_decl
) = (enum built_in_function
) 0;
7592 /* Build a function type. The RETURN_TYPE is the type returned by the
7593 function. If VAARGS is set, no void_type_node is appended to the
7594 the list. ARGP must be always be terminated be a NULL_TREE. */
7597 build_function_type_list_1 (bool vaargs
, tree return_type
, va_list argp
)
7601 t
= va_arg (argp
, tree
);
7602 for (args
= NULL_TREE
; t
!= NULL_TREE
; t
= va_arg (argp
, tree
))
7603 args
= tree_cons (NULL_TREE
, t
, args
);
7608 if (args
!= NULL_TREE
)
7609 args
= nreverse (args
);
7610 gcc_assert (last
!= void_list_node
);
7612 else if (args
== NULL_TREE
)
7613 args
= void_list_node
;
7617 args
= nreverse (args
);
7618 TREE_CHAIN (last
) = void_list_node
;
7620 args
= build_function_type (return_type
, args
);
7625 /* Build a function type. The RETURN_TYPE is the type returned by the
7626 function. If additional arguments are provided, they are
7627 additional argument types. The list of argument types must always
7628 be terminated by NULL_TREE. */
7631 build_function_type_list (tree return_type
, ...)
7636 va_start (p
, return_type
);
7637 args
= build_function_type_list_1 (false, return_type
, p
);
7642 /* Build a variable argument function type. The RETURN_TYPE is the
7643 type returned by the function. If additional arguments are provided,
7644 they are additional argument types. The list of argument types must
7645 always be terminated by NULL_TREE. */
7648 build_varargs_function_type_list (tree return_type
, ...)
7653 va_start (p
, return_type
);
7654 args
= build_function_type_list_1 (true, return_type
, p
);
7660 /* Build a function type. RETURN_TYPE is the type returned by the
7661 function; VAARGS indicates whether the function takes varargs. The
7662 function takes N named arguments, the types of which are provided in
7666 build_function_type_array_1 (bool vaargs
, tree return_type
, int n
,
7670 tree t
= vaargs
? NULL_TREE
: void_list_node
;
7672 for (i
= n
- 1; i
>= 0; i
--)
7673 t
= tree_cons (NULL_TREE
, arg_types
[i
], t
);
7675 return build_function_type (return_type
, t
);
7678 /* Build a function type. RETURN_TYPE is the type returned by the
7679 function. The function takes N named arguments, the types of which
7680 are provided in ARG_TYPES. */
7683 build_function_type_array (tree return_type
, int n
, tree
*arg_types
)
7685 return build_function_type_array_1 (false, return_type
, n
, arg_types
);
7688 /* Build a variable argument function type. RETURN_TYPE is the type
7689 returned by the function. The function takes N named arguments, the
7690 types of which are provided in ARG_TYPES. */
7693 build_varargs_function_type_array (tree return_type
, int n
, tree
*arg_types
)
7695 return build_function_type_array_1 (true, return_type
, n
, arg_types
);
7698 /* Build a METHOD_TYPE for a member of BASETYPE. The RETTYPE (a TYPE)
7699 and ARGTYPES (a TREE_LIST) are the return type and arguments types
7700 for the method. An implicit additional parameter (of type
7701 pointer-to-BASETYPE) is added to the ARGTYPES. */
7704 build_method_type_directly (tree basetype
,
7711 bool any_structural_p
, any_noncanonical_p
;
7712 tree canon_argtypes
;
7714 /* Make a node of the sort we want. */
7715 t
= make_node (METHOD_TYPE
);
7717 TYPE_METHOD_BASETYPE (t
) = TYPE_MAIN_VARIANT (basetype
);
7718 TREE_TYPE (t
) = rettype
;
7719 ptype
= build_pointer_type (basetype
);
7721 /* The actual arglist for this function includes a "hidden" argument
7722 which is "this". Put it into the list of argument types. */
7723 argtypes
= tree_cons (NULL_TREE
, ptype
, argtypes
);
7724 TYPE_ARG_TYPES (t
) = argtypes
;
7726 /* If we already have such a type, use the old one. */
7727 hashcode
= iterative_hash_object (TYPE_HASH (basetype
), hashcode
);
7728 hashcode
= iterative_hash_object (TYPE_HASH (rettype
), hashcode
);
7729 hashcode
= type_hash_list (argtypes
, hashcode
);
7730 t
= type_hash_canon (hashcode
, t
);
7732 /* Set up the canonical type. */
7734 = (TYPE_STRUCTURAL_EQUALITY_P (basetype
)
7735 || TYPE_STRUCTURAL_EQUALITY_P (rettype
));
7737 = (TYPE_CANONICAL (basetype
) != basetype
7738 || TYPE_CANONICAL (rettype
) != rettype
);
7739 canon_argtypes
= maybe_canonicalize_argtypes (TREE_CHAIN (argtypes
),
7741 &any_noncanonical_p
);
7742 if (any_structural_p
)
7743 SET_TYPE_STRUCTURAL_EQUALITY (t
);
7744 else if (any_noncanonical_p
)
7746 = build_method_type_directly (TYPE_CANONICAL (basetype
),
7747 TYPE_CANONICAL (rettype
),
7749 if (!COMPLETE_TYPE_P (t
))
7755 /* Construct, lay out and return the type of methods belonging to class
7756 BASETYPE and whose arguments and values are described by TYPE.
7757 If that type exists already, reuse it.
7758 TYPE must be a FUNCTION_TYPE node. */
7761 build_method_type (tree basetype
, tree type
)
7763 gcc_assert (TREE_CODE (type
) == FUNCTION_TYPE
);
7765 return build_method_type_directly (basetype
,
7767 TYPE_ARG_TYPES (type
));
7770 /* Construct, lay out and return the type of offsets to a value
7771 of type TYPE, within an object of type BASETYPE.
7772 If a suitable offset type exists already, reuse it. */
7775 build_offset_type (tree basetype
, tree type
)
7778 hashval_t hashcode
= 0;
7780 /* Make a node of the sort we want. */
7781 t
= make_node (OFFSET_TYPE
);
7783 TYPE_OFFSET_BASETYPE (t
) = TYPE_MAIN_VARIANT (basetype
);
7784 TREE_TYPE (t
) = type
;
7786 /* If we already have such a type, use the old one. */
7787 hashcode
= iterative_hash_object (TYPE_HASH (basetype
), hashcode
);
7788 hashcode
= iterative_hash_object (TYPE_HASH (type
), hashcode
);
7789 t
= type_hash_canon (hashcode
, t
);
7791 if (!COMPLETE_TYPE_P (t
))
7794 if (TYPE_CANONICAL (t
) == t
)
7796 if (TYPE_STRUCTURAL_EQUALITY_P (basetype
)
7797 || TYPE_STRUCTURAL_EQUALITY_P (type
))
7798 SET_TYPE_STRUCTURAL_EQUALITY (t
);
7799 else if (TYPE_CANONICAL (TYPE_MAIN_VARIANT (basetype
)) != basetype
7800 || TYPE_CANONICAL (type
) != type
)
7802 = build_offset_type (TYPE_CANONICAL (TYPE_MAIN_VARIANT (basetype
)),
7803 TYPE_CANONICAL (type
));
7809 /* Create a complex type whose components are COMPONENT_TYPE. */
7812 build_complex_type (tree component_type
)
7817 gcc_assert (INTEGRAL_TYPE_P (component_type
)
7818 || SCALAR_FLOAT_TYPE_P (component_type
)
7819 || FIXED_POINT_TYPE_P (component_type
));
7821 /* Make a node of the sort we want. */
7822 t
= make_node (COMPLEX_TYPE
);
7824 TREE_TYPE (t
) = TYPE_MAIN_VARIANT (component_type
);
7826 /* If we already have such a type, use the old one. */
7827 hashcode
= iterative_hash_object (TYPE_HASH (component_type
), 0);
7828 t
= type_hash_canon (hashcode
, t
);
7830 if (!COMPLETE_TYPE_P (t
))
7833 if (TYPE_CANONICAL (t
) == t
)
7835 if (TYPE_STRUCTURAL_EQUALITY_P (component_type
))
7836 SET_TYPE_STRUCTURAL_EQUALITY (t
);
7837 else if (TYPE_CANONICAL (component_type
) != component_type
)
7839 = build_complex_type (TYPE_CANONICAL (component_type
));
7842 /* We need to create a name, since complex is a fundamental type. */
7843 if (! TYPE_NAME (t
))
7846 if (component_type
== char_type_node
)
7847 name
= "complex char";
7848 else if (component_type
== signed_char_type_node
)
7849 name
= "complex signed char";
7850 else if (component_type
== unsigned_char_type_node
)
7851 name
= "complex unsigned char";
7852 else if (component_type
== short_integer_type_node
)
7853 name
= "complex short int";
7854 else if (component_type
== short_unsigned_type_node
)
7855 name
= "complex short unsigned int";
7856 else if (component_type
== integer_type_node
)
7857 name
= "complex int";
7858 else if (component_type
== unsigned_type_node
)
7859 name
= "complex unsigned int";
7860 else if (component_type
== long_integer_type_node
)
7861 name
= "complex long int";
7862 else if (component_type
== long_unsigned_type_node
)
7863 name
= "complex long unsigned int";
7864 else if (component_type
== long_long_integer_type_node
)
7865 name
= "complex long long int";
7866 else if (component_type
== long_long_unsigned_type_node
)
7867 name
= "complex long long unsigned int";
7872 TYPE_NAME (t
) = build_decl (UNKNOWN_LOCATION
, TYPE_DECL
,
7873 get_identifier (name
), t
);
7876 return build_qualified_type (t
, TYPE_QUALS (component_type
));
7879 /* If TYPE is a real or complex floating-point type and the target
7880 does not directly support arithmetic on TYPE then return the wider
7881 type to be used for arithmetic on TYPE. Otherwise, return
7885 excess_precision_type (tree type
)
7887 if (flag_excess_precision
!= EXCESS_PRECISION_FAST
)
7889 int flt_eval_method
= TARGET_FLT_EVAL_METHOD
;
7890 switch (TREE_CODE (type
))
7893 switch (flt_eval_method
)
7896 if (TYPE_MODE (type
) == TYPE_MODE (float_type_node
))
7897 return double_type_node
;
7900 if (TYPE_MODE (type
) == TYPE_MODE (float_type_node
)
7901 || TYPE_MODE (type
) == TYPE_MODE (double_type_node
))
7902 return long_double_type_node
;
7909 if (TREE_CODE (TREE_TYPE (type
)) != REAL_TYPE
)
7911 switch (flt_eval_method
)
7914 if (TYPE_MODE (TREE_TYPE (type
)) == TYPE_MODE (float_type_node
))
7915 return complex_double_type_node
;
7918 if (TYPE_MODE (TREE_TYPE (type
)) == TYPE_MODE (float_type_node
)
7919 || (TYPE_MODE (TREE_TYPE (type
))
7920 == TYPE_MODE (double_type_node
)))
7921 return complex_long_double_type_node
;
7934 /* Return OP, stripped of any conversions to wider types as much as is safe.
7935 Converting the value back to OP's type makes a value equivalent to OP.
7937 If FOR_TYPE is nonzero, we return a value which, if converted to
7938 type FOR_TYPE, would be equivalent to converting OP to type FOR_TYPE.
7940 OP must have integer, real or enumeral type. Pointers are not allowed!
7942 There are some cases where the obvious value we could return
7943 would regenerate to OP if converted to OP's type,
7944 but would not extend like OP to wider types.
7945 If FOR_TYPE indicates such extension is contemplated, we eschew such values.
7946 For example, if OP is (unsigned short)(signed char)-1,
7947 we avoid returning (signed char)-1 if FOR_TYPE is int,
7948 even though extending that to an unsigned short would regenerate OP,
7949 since the result of extending (signed char)-1 to (int)
7950 is different from (int) OP. */
7953 get_unwidened (tree op
, tree for_type
)
7955 /* Set UNS initially if converting OP to FOR_TYPE is a zero-extension. */
7956 tree type
= TREE_TYPE (op
);
7958 = TYPE_PRECISION (for_type
!= 0 ? for_type
: type
);
7960 = (for_type
!= 0 && for_type
!= type
7961 && final_prec
> TYPE_PRECISION (type
)
7962 && TYPE_UNSIGNED (type
));
7965 while (CONVERT_EXPR_P (op
))
7969 /* TYPE_PRECISION on vector types has different meaning
7970 (TYPE_VECTOR_SUBPARTS) and casts from vectors are view conversions,
7971 so avoid them here. */
7972 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (op
, 0))) == VECTOR_TYPE
)
7975 bitschange
= TYPE_PRECISION (TREE_TYPE (op
))
7976 - TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op
, 0)));
7978 /* Truncations are many-one so cannot be removed.
7979 Unless we are later going to truncate down even farther. */
7981 && final_prec
> TYPE_PRECISION (TREE_TYPE (op
)))
7984 /* See what's inside this conversion. If we decide to strip it,
7986 op
= TREE_OPERAND (op
, 0);
7988 /* If we have not stripped any zero-extensions (uns is 0),
7989 we can strip any kind of extension.
7990 If we have previously stripped a zero-extension,
7991 only zero-extensions can safely be stripped.
7992 Any extension can be stripped if the bits it would produce
7993 are all going to be discarded later by truncating to FOR_TYPE. */
7997 if (! uns
|| final_prec
<= TYPE_PRECISION (TREE_TYPE (op
)))
7999 /* TYPE_UNSIGNED says whether this is a zero-extension.
8000 Let's avoid computing it if it does not affect WIN
8001 and if UNS will not be needed again. */
8003 || CONVERT_EXPR_P (op
))
8004 && TYPE_UNSIGNED (TREE_TYPE (op
)))
8012 /* If we finally reach a constant see if it fits in for_type and
8013 in that case convert it. */
8015 && TREE_CODE (win
) == INTEGER_CST
8016 && TREE_TYPE (win
) != for_type
8017 && int_fits_type_p (win
, for_type
))
8018 win
= fold_convert (for_type
, win
);
8023 /* Return OP or a simpler expression for a narrower value
8024 which can be sign-extended or zero-extended to give back OP.
8025 Store in *UNSIGNEDP_PTR either 1 if the value should be zero-extended
8026 or 0 if the value should be sign-extended. */
8029 get_narrower (tree op
, int *unsignedp_ptr
)
8034 bool integral_p
= INTEGRAL_TYPE_P (TREE_TYPE (op
));
8036 while (TREE_CODE (op
) == NOP_EXPR
)
8039 = (TYPE_PRECISION (TREE_TYPE (op
))
8040 - TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op
, 0))));
8042 /* Truncations are many-one so cannot be removed. */
8046 /* See what's inside this conversion. If we decide to strip it,
8051 op
= TREE_OPERAND (op
, 0);
8052 /* An extension: the outermost one can be stripped,
8053 but remember whether it is zero or sign extension. */
8055 uns
= TYPE_UNSIGNED (TREE_TYPE (op
));
8056 /* Otherwise, if a sign extension has been stripped,
8057 only sign extensions can now be stripped;
8058 if a zero extension has been stripped, only zero-extensions. */
8059 else if (uns
!= TYPE_UNSIGNED (TREE_TYPE (op
)))
8063 else /* bitschange == 0 */
8065 /* A change in nominal type can always be stripped, but we must
8066 preserve the unsignedness. */
8068 uns
= TYPE_UNSIGNED (TREE_TYPE (op
));
8070 op
= TREE_OPERAND (op
, 0);
8071 /* Keep trying to narrow, but don't assign op to win if it
8072 would turn an integral type into something else. */
8073 if (INTEGRAL_TYPE_P (TREE_TYPE (op
)) != integral_p
)
8080 if (TREE_CODE (op
) == COMPONENT_REF
8081 /* Since type_for_size always gives an integer type. */
8082 && TREE_CODE (TREE_TYPE (op
)) != REAL_TYPE
8083 && TREE_CODE (TREE_TYPE (op
)) != FIXED_POINT_TYPE
8084 /* Ensure field is laid out already. */
8085 && DECL_SIZE (TREE_OPERAND (op
, 1)) != 0
8086 && host_integerp (DECL_SIZE (TREE_OPERAND (op
, 1)), 1))
8088 unsigned HOST_WIDE_INT innerprec
8089 = tree_low_cst (DECL_SIZE (TREE_OPERAND (op
, 1)), 1);
8090 int unsignedp
= (DECL_UNSIGNED (TREE_OPERAND (op
, 1))
8091 || TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op
, 1))));
8092 tree type
= lang_hooks
.types
.type_for_size (innerprec
, unsignedp
);
8094 /* We can get this structure field in a narrower type that fits it,
8095 but the resulting extension to its nominal type (a fullword type)
8096 must satisfy the same conditions as for other extensions.
8098 Do this only for fields that are aligned (not bit-fields),
8099 because when bit-field insns will be used there is no
8100 advantage in doing this. */
8102 if (innerprec
< TYPE_PRECISION (TREE_TYPE (op
))
8103 && ! DECL_BIT_FIELD (TREE_OPERAND (op
, 1))
8104 && (first
|| uns
== DECL_UNSIGNED (TREE_OPERAND (op
, 1)))
8108 uns
= DECL_UNSIGNED (TREE_OPERAND (op
, 1));
8109 win
= fold_convert (type
, op
);
8113 *unsignedp_ptr
= uns
;
8117 /* Returns true if integer constant C has a value that is permissible
8118 for type TYPE (an INTEGER_TYPE). */
8121 int_fits_type_p (const_tree c
, const_tree type
)
8123 tree type_low_bound
, type_high_bound
;
8124 bool ok_for_low_bound
, ok_for_high_bound
, unsc
;
8127 dc
= tree_to_double_int (c
);
8128 unsc
= TYPE_UNSIGNED (TREE_TYPE (c
));
8130 if (TREE_CODE (TREE_TYPE (c
)) == INTEGER_TYPE
8131 && TYPE_IS_SIZETYPE (TREE_TYPE (c
))
8133 /* So c is an unsigned integer whose type is sizetype and type is not.
8134 sizetype'd integers are sign extended even though they are
8135 unsigned. If the integer value fits in the lower end word of c,
8136 and if the higher end word has all its bits set to 1, that
8137 means the higher end bits are set to 1 only for sign extension.
8138 So let's convert c into an equivalent zero extended unsigned
8140 dc
= double_int_zext (dc
, TYPE_PRECISION (TREE_TYPE (c
)));
8143 type_low_bound
= TYPE_MIN_VALUE (type
);
8144 type_high_bound
= TYPE_MAX_VALUE (type
);
8146 /* If at least one bound of the type is a constant integer, we can check
8147 ourselves and maybe make a decision. If no such decision is possible, but
8148 this type is a subtype, try checking against that. Otherwise, use
8149 double_int_fits_to_tree_p, which checks against the precision.
8151 Compute the status for each possibly constant bound, and return if we see
8152 one does not match. Use ok_for_xxx_bound for this purpose, assigning -1
8153 for "unknown if constant fits", 0 for "constant known *not* to fit" and 1
8154 for "constant known to fit". */
8156 /* Check if c >= type_low_bound. */
8157 if (type_low_bound
&& TREE_CODE (type_low_bound
) == INTEGER_CST
)
8159 dd
= tree_to_double_int (type_low_bound
);
8160 if (TREE_CODE (type
) == INTEGER_TYPE
8161 && TYPE_IS_SIZETYPE (type
)
8162 && TYPE_UNSIGNED (type
))
8163 dd
= double_int_zext (dd
, TYPE_PRECISION (type
));
8164 if (unsc
!= TYPE_UNSIGNED (TREE_TYPE (type_low_bound
)))
8166 int c_neg
= (!unsc
&& double_int_negative_p (dc
));
8167 int t_neg
= (unsc
&& double_int_negative_p (dd
));
8169 if (c_neg
&& !t_neg
)
8171 if ((c_neg
|| !t_neg
) && double_int_ucmp (dc
, dd
) < 0)
8174 else if (double_int_cmp (dc
, dd
, unsc
) < 0)
8176 ok_for_low_bound
= true;
8179 ok_for_low_bound
= false;
8181 /* Check if c <= type_high_bound. */
8182 if (type_high_bound
&& TREE_CODE (type_high_bound
) == INTEGER_CST
)
8184 dd
= tree_to_double_int (type_high_bound
);
8185 if (TREE_CODE (type
) == INTEGER_TYPE
8186 && TYPE_IS_SIZETYPE (type
)
8187 && TYPE_UNSIGNED (type
))
8188 dd
= double_int_zext (dd
, TYPE_PRECISION (type
));
8189 if (unsc
!= TYPE_UNSIGNED (TREE_TYPE (type_high_bound
)))
8191 int c_neg
= (!unsc
&& double_int_negative_p (dc
));
8192 int t_neg
= (unsc
&& double_int_negative_p (dd
));
8194 if (t_neg
&& !c_neg
)
8196 if ((t_neg
|| !c_neg
) && double_int_ucmp (dc
, dd
) > 0)
8199 else if (double_int_cmp (dc
, dd
, unsc
) > 0)
8201 ok_for_high_bound
= true;
8204 ok_for_high_bound
= false;
8206 /* If the constant fits both bounds, the result is known. */
8207 if (ok_for_low_bound
&& ok_for_high_bound
)
8210 /* Perform some generic filtering which may allow making a decision
8211 even if the bounds are not constant. First, negative integers
8212 never fit in unsigned types, */
8213 if (TYPE_UNSIGNED (type
) && !unsc
&& double_int_negative_p (dc
))
8216 /* Second, narrower types always fit in wider ones. */
8217 if (TYPE_PRECISION (type
) > TYPE_PRECISION (TREE_TYPE (c
)))
8220 /* Third, unsigned integers with top bit set never fit signed types. */
8221 if (! TYPE_UNSIGNED (type
) && unsc
)
8223 int prec
= GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (c
))) - 1;
8224 if (prec
< HOST_BITS_PER_WIDE_INT
)
8226 if (((((unsigned HOST_WIDE_INT
) 1) << prec
) & dc
.low
) != 0)
8229 else if (((((unsigned HOST_WIDE_INT
) 1)
8230 << (prec
- HOST_BITS_PER_WIDE_INT
)) & dc
.high
) != 0)
8234 /* If we haven't been able to decide at this point, there nothing more we
8235 can check ourselves here. Look at the base type if we have one and it
8236 has the same precision. */
8237 if (TREE_CODE (type
) == INTEGER_TYPE
8238 && TREE_TYPE (type
) != 0
8239 && TYPE_PRECISION (type
) == TYPE_PRECISION (TREE_TYPE (type
)))
8241 type
= TREE_TYPE (type
);
8245 /* Or to double_int_fits_to_tree_p, if nothing else. */
8246 return double_int_fits_to_tree_p (type
, dc
);
8249 /* Stores bounds of an integer TYPE in MIN and MAX. If TYPE has non-constant
8250 bounds or is a POINTER_TYPE, the maximum and/or minimum values that can be
8251 represented (assuming two's-complement arithmetic) within the bit
8252 precision of the type are returned instead. */
8255 get_type_static_bounds (const_tree type
, mpz_t min
, mpz_t max
)
8257 if (!POINTER_TYPE_P (type
) && TYPE_MIN_VALUE (type
)
8258 && TREE_CODE (TYPE_MIN_VALUE (type
)) == INTEGER_CST
)
8259 mpz_set_double_int (min
, tree_to_double_int (TYPE_MIN_VALUE (type
)),
8260 TYPE_UNSIGNED (type
));
8263 if (TYPE_UNSIGNED (type
))
8264 mpz_set_ui (min
, 0);
8268 mn
= double_int_mask (TYPE_PRECISION (type
) - 1);
8269 mn
= double_int_sext (double_int_add (mn
, double_int_one
),
8270 TYPE_PRECISION (type
));
8271 mpz_set_double_int (min
, mn
, false);
8275 if (!POINTER_TYPE_P (type
) && TYPE_MAX_VALUE (type
)
8276 && TREE_CODE (TYPE_MAX_VALUE (type
)) == INTEGER_CST
)
8277 mpz_set_double_int (max
, tree_to_double_int (TYPE_MAX_VALUE (type
)),
8278 TYPE_UNSIGNED (type
));
8281 if (TYPE_UNSIGNED (type
))
8282 mpz_set_double_int (max
, double_int_mask (TYPE_PRECISION (type
)),
8285 mpz_set_double_int (max
, double_int_mask (TYPE_PRECISION (type
) - 1),
8290 /* Return true if VAR is an automatic variable defined in function FN. */
8293 auto_var_in_fn_p (const_tree var
, const_tree fn
)
8295 return (DECL_P (var
) && DECL_CONTEXT (var
) == fn
8296 && ((((TREE_CODE (var
) == VAR_DECL
&& ! DECL_EXTERNAL (var
))
8297 || TREE_CODE (var
) == PARM_DECL
)
8298 && ! TREE_STATIC (var
))
8299 || TREE_CODE (var
) == LABEL_DECL
8300 || TREE_CODE (var
) == RESULT_DECL
));
8303 /* Subprogram of following function. Called by walk_tree.
8305 Return *TP if it is an automatic variable or parameter of the
8306 function passed in as DATA. */
8309 find_var_from_fn (tree
*tp
, int *walk_subtrees
, void *data
)
8311 tree fn
= (tree
) data
;
8316 else if (DECL_P (*tp
)
8317 && auto_var_in_fn_p (*tp
, fn
))
8323 /* Returns true if T is, contains, or refers to a type with variable
8324 size. For METHOD_TYPEs and FUNCTION_TYPEs we exclude the
8325 arguments, but not the return type. If FN is nonzero, only return
8326 true if a modifier of the type or position of FN is a variable or
8327 parameter inside FN.
8329 This concept is more general than that of C99 'variably modified types':
8330 in C99, a struct type is never variably modified because a VLA may not
8331 appear as a structure member. However, in GNU C code like:
8333 struct S { int i[f()]; };
8335 is valid, and other languages may define similar constructs. */
8338 variably_modified_type_p (tree type
, tree fn
)
8342 /* Test if T is either variable (if FN is zero) or an expression containing
8343 a variable in FN. */
8344 #define RETURN_TRUE_IF_VAR(T) \
8345 do { tree _t = (T); \
8346 if (_t && _t != error_mark_node && TREE_CODE (_t) != INTEGER_CST \
8347 && (!fn || walk_tree (&_t, find_var_from_fn, fn, NULL))) \
8348 return true; } while (0)
8350 if (type
== error_mark_node
)
8353 /* If TYPE itself has variable size, it is variably modified. */
8354 RETURN_TRUE_IF_VAR (TYPE_SIZE (type
));
8355 RETURN_TRUE_IF_VAR (TYPE_SIZE_UNIT (type
));
8357 switch (TREE_CODE (type
))
8360 case REFERENCE_TYPE
:
8362 if (variably_modified_type_p (TREE_TYPE (type
), fn
))
8368 /* If TYPE is a function type, it is variably modified if the
8369 return type is variably modified. */
8370 if (variably_modified_type_p (TREE_TYPE (type
), fn
))
8376 case FIXED_POINT_TYPE
:
8379 /* Scalar types are variably modified if their end points
8381 RETURN_TRUE_IF_VAR (TYPE_MIN_VALUE (type
));
8382 RETURN_TRUE_IF_VAR (TYPE_MAX_VALUE (type
));
8387 case QUAL_UNION_TYPE
:
8388 /* We can't see if any of the fields are variably-modified by the
8389 definition we normally use, since that would produce infinite
8390 recursion via pointers. */
8391 /* This is variably modified if some field's type is. */
8392 for (t
= TYPE_FIELDS (type
); t
; t
= DECL_CHAIN (t
))
8393 if (TREE_CODE (t
) == FIELD_DECL
)
8395 RETURN_TRUE_IF_VAR (DECL_FIELD_OFFSET (t
));
8396 RETURN_TRUE_IF_VAR (DECL_SIZE (t
));
8397 RETURN_TRUE_IF_VAR (DECL_SIZE_UNIT (t
));
8399 if (TREE_CODE (type
) == QUAL_UNION_TYPE
)
8400 RETURN_TRUE_IF_VAR (DECL_QUALIFIER (t
));
8405 /* Do not call ourselves to avoid infinite recursion. This is
8406 variably modified if the element type is. */
8407 RETURN_TRUE_IF_VAR (TYPE_SIZE (TREE_TYPE (type
)));
8408 RETURN_TRUE_IF_VAR (TYPE_SIZE_UNIT (TREE_TYPE (type
)));
8415 /* The current language may have other cases to check, but in general,
8416 all other types are not variably modified. */
8417 return lang_hooks
.tree_inlining
.var_mod_type_p (type
, fn
);
8419 #undef RETURN_TRUE_IF_VAR
8422 /* Given a DECL or TYPE, return the scope in which it was declared, or
8423 NULL_TREE if there is no containing scope. */
8426 get_containing_scope (const_tree t
)
8428 return (TYPE_P (t
) ? TYPE_CONTEXT (t
) : DECL_CONTEXT (t
));
8431 /* Return the innermost context enclosing DECL that is
8432 a FUNCTION_DECL, or zero if none. */
8435 decl_function_context (const_tree decl
)
8439 if (TREE_CODE (decl
) == ERROR_MARK
)
8442 /* C++ virtual functions use DECL_CONTEXT for the class of the vtable
8443 where we look up the function at runtime. Such functions always take
8444 a first argument of type 'pointer to real context'.
8446 C++ should really be fixed to use DECL_CONTEXT for the real context,
8447 and use something else for the "virtual context". */
8448 else if (TREE_CODE (decl
) == FUNCTION_DECL
&& DECL_VINDEX (decl
))
8451 (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl
)))));
8453 context
= DECL_CONTEXT (decl
);
8455 while (context
&& TREE_CODE (context
) != FUNCTION_DECL
)
8457 if (TREE_CODE (context
) == BLOCK
)
8458 context
= BLOCK_SUPERCONTEXT (context
);
8460 context
= get_containing_scope (context
);
8466 /* Return the innermost context enclosing DECL that is
8467 a RECORD_TYPE, UNION_TYPE or QUAL_UNION_TYPE, or zero if none.
8468 TYPE_DECLs and FUNCTION_DECLs are transparent to this function. */
8471 decl_type_context (const_tree decl
)
8473 tree context
= DECL_CONTEXT (decl
);
8476 switch (TREE_CODE (context
))
8478 case NAMESPACE_DECL
:
8479 case TRANSLATION_UNIT_DECL
:
8484 case QUAL_UNION_TYPE
:
8489 context
= DECL_CONTEXT (context
);
8493 context
= BLOCK_SUPERCONTEXT (context
);
8503 /* CALL is a CALL_EXPR. Return the declaration for the function
8504 called, or NULL_TREE if the called function cannot be
8508 get_callee_fndecl (const_tree call
)
8512 if (call
== error_mark_node
)
8513 return error_mark_node
;
8515 /* It's invalid to call this function with anything but a
8517 gcc_assert (TREE_CODE (call
) == CALL_EXPR
);
8519 /* The first operand to the CALL is the address of the function
8521 addr
= CALL_EXPR_FN (call
);
8525 /* If this is a readonly function pointer, extract its initial value. */
8526 if (DECL_P (addr
) && TREE_CODE (addr
) != FUNCTION_DECL
8527 && TREE_READONLY (addr
) && ! TREE_THIS_VOLATILE (addr
)
8528 && DECL_INITIAL (addr
))
8529 addr
= DECL_INITIAL (addr
);
8531 /* If the address is just `&f' for some function `f', then we know
8532 that `f' is being called. */
8533 if (TREE_CODE (addr
) == ADDR_EXPR
8534 && TREE_CODE (TREE_OPERAND (addr
, 0)) == FUNCTION_DECL
)
8535 return TREE_OPERAND (addr
, 0);
8537 /* We couldn't figure out what was being called. */
8541 /* Print debugging information about tree nodes generated during the compile,
8542 and any language-specific information. */
8545 dump_tree_statistics (void)
8547 #ifdef GATHER_STATISTICS
8549 int total_nodes
, total_bytes
;
8552 fprintf (stderr
, "\n??? tree nodes created\n\n");
8553 #ifdef GATHER_STATISTICS
8554 fprintf (stderr
, "Kind Nodes Bytes\n");
8555 fprintf (stderr
, "---------------------------------------\n");
8556 total_nodes
= total_bytes
= 0;
8557 for (i
= 0; i
< (int) all_kinds
; i
++)
8559 fprintf (stderr
, "%-20s %7d %10d\n", tree_node_kind_names
[i
],
8560 tree_node_counts
[i
], tree_node_sizes
[i
]);
8561 total_nodes
+= tree_node_counts
[i
];
8562 total_bytes
+= tree_node_sizes
[i
];
8564 fprintf (stderr
, "---------------------------------------\n");
8565 fprintf (stderr
, "%-20s %7d %10d\n", "Total", total_nodes
, total_bytes
);
8566 fprintf (stderr
, "---------------------------------------\n");
8567 fprintf (stderr
, "Code Nodes\n");
8568 fprintf (stderr
, "----------------------------\n");
8569 for (i
= 0; i
< (int) MAX_TREE_CODES
; i
++)
8570 fprintf (stderr
, "%-20s %7d\n", tree_code_name
[i
], tree_code_counts
[i
]);
8571 fprintf (stderr
, "----------------------------\n");
8572 ssanames_print_statistics ();
8573 phinodes_print_statistics ();
8575 fprintf (stderr
, "(No per-node statistics)\n");
8577 print_type_hash_statistics ();
8578 print_debug_expr_statistics ();
8579 print_value_expr_statistics ();
8580 lang_hooks
.print_statistics ();
8583 #define FILE_FUNCTION_FORMAT "_GLOBAL__%s_%s"
8585 /* Generate a crc32 of a byte. */
8588 crc32_byte (unsigned chksum
, char byte
)
8590 unsigned value
= (unsigned) byte
<< 24;
8593 for (ix
= 8; ix
--; value
<<= 1)
8597 feedback
= (value
^ chksum
) & 0x80000000 ? 0x04c11db7 : 0;
8605 /* Generate a crc32 of a string. */
8608 crc32_string (unsigned chksum
, const char *string
)
8612 chksum
= crc32_byte (chksum
, *string
);
8618 /* P is a string that will be used in a symbol. Mask out any characters
8619 that are not valid in that context. */
8622 clean_symbol_name (char *p
)
8626 #ifndef NO_DOLLAR_IN_LABEL /* this for `$'; unlikely, but... -- kr */
8629 #ifndef NO_DOT_IN_LABEL /* this for `.'; unlikely, but... */
8636 /* Generate a name for a special-purpose function.
8637 The generated name may need to be unique across the whole link.
8638 Changes to this function may also require corresponding changes to
8639 xstrdup_mask_random.
8640 TYPE is some string to identify the purpose of this function to the
8641 linker or collect2; it must start with an uppercase letter,
8643 I - for constructors
8645 N - for C++ anonymous namespaces
8646 F - for DWARF unwind frame information. */
8649 get_file_function_name (const char *type
)
8655 /* If we already have a name we know to be unique, just use that. */
8656 if (first_global_object_name
)
8657 p
= q
= ASTRDUP (first_global_object_name
);
8658 /* If the target is handling the constructors/destructors, they
8659 will be local to this file and the name is only necessary for
8661 We also assign sub_I and sub_D sufixes to constructors called from
8662 the global static constructors. These are always local. */
8663 else if (((type
[0] == 'I' || type
[0] == 'D') && targetm
.have_ctors_dtors
)
8664 || (strncmp (type
, "sub_", 4) == 0
8665 && (type
[4] == 'I' || type
[4] == 'D')))
8667 const char *file
= main_input_filename
;
8669 file
= input_filename
;
8670 /* Just use the file's basename, because the full pathname
8671 might be quite long. */
8672 p
= q
= ASTRDUP (lbasename (file
));
8676 /* Otherwise, the name must be unique across the entire link.
8677 We don't have anything that we know to be unique to this translation
8678 unit, so use what we do have and throw in some randomness. */
8680 const char *name
= weak_global_object_name
;
8681 const char *file
= main_input_filename
;
8686 file
= input_filename
;
8688 len
= strlen (file
);
8689 q
= (char *) alloca (9 * 2 + len
+ 1);
8690 memcpy (q
, file
, len
+ 1);
8692 sprintf (q
+ len
, "_%08X_%08X", crc32_string (0, name
),
8693 crc32_string (0, get_random_seed (false)));
8698 clean_symbol_name (q
);
8699 buf
= (char *) alloca (sizeof (FILE_FUNCTION_FORMAT
) + strlen (p
)
8702 /* Set up the name of the file-level functions we may need.
8703 Use a global object (which is already required to be unique over
8704 the program) rather than the file name (which imposes extra
8706 sprintf (buf
, FILE_FUNCTION_FORMAT
, type
, p
);
8708 return get_identifier (buf
);
8711 #if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
8713 /* Complain that the tree code of NODE does not match the expected 0
8714 terminated list of trailing codes. The trailing code list can be
8715 empty, for a more vague error message. FILE, LINE, and FUNCTION
8716 are of the caller. */
8719 tree_check_failed (const_tree node
, const char *file
,
8720 int line
, const char *function
, ...)
8724 unsigned length
= 0;
8727 va_start (args
, function
);
8728 while ((code
= va_arg (args
, int)))
8729 length
+= 4 + strlen (tree_code_name
[code
]);
8734 va_start (args
, function
);
8735 length
+= strlen ("expected ");
8736 buffer
= tmp
= (char *) alloca (length
);
8738 while ((code
= va_arg (args
, int)))
8740 const char *prefix
= length
? " or " : "expected ";
8742 strcpy (tmp
+ length
, prefix
);
8743 length
+= strlen (prefix
);
8744 strcpy (tmp
+ length
, tree_code_name
[code
]);
8745 length
+= strlen (tree_code_name
[code
]);
8750 buffer
= "unexpected node";
8752 internal_error ("tree check: %s, have %s in %s, at %s:%d",
8753 buffer
, tree_code_name
[TREE_CODE (node
)],
8754 function
, trim_filename (file
), line
);
8757 /* Complain that the tree code of NODE does match the expected 0
8758 terminated list of trailing codes. FILE, LINE, and FUNCTION are of
8762 tree_not_check_failed (const_tree node
, const char *file
,
8763 int line
, const char *function
, ...)
8767 unsigned length
= 0;
8770 va_start (args
, function
);
8771 while ((code
= va_arg (args
, int)))
8772 length
+= 4 + strlen (tree_code_name
[code
]);
8774 va_start (args
, function
);
8775 buffer
= (char *) alloca (length
);
8777 while ((code
= va_arg (args
, int)))
8781 strcpy (buffer
+ length
, " or ");
8784 strcpy (buffer
+ length
, tree_code_name
[code
]);
8785 length
+= strlen (tree_code_name
[code
]);
8789 internal_error ("tree check: expected none of %s, have %s in %s, at %s:%d",
8790 buffer
, tree_code_name
[TREE_CODE (node
)],
8791 function
, trim_filename (file
), line
);
8794 /* Similar to tree_check_failed, except that we check for a class of tree
8795 code, given in CL. */
8798 tree_class_check_failed (const_tree node
, const enum tree_code_class cl
,
8799 const char *file
, int line
, const char *function
)
8802 ("tree check: expected class %qs, have %qs (%s) in %s, at %s:%d",
8803 TREE_CODE_CLASS_STRING (cl
),
8804 TREE_CODE_CLASS_STRING (TREE_CODE_CLASS (TREE_CODE (node
))),
8805 tree_code_name
[TREE_CODE (node
)], function
, trim_filename (file
), line
);
8808 /* Similar to tree_check_failed, except that instead of specifying a
8809 dozen codes, use the knowledge that they're all sequential. */
8812 tree_range_check_failed (const_tree node
, const char *file
, int line
,
8813 const char *function
, enum tree_code c1
,
8817 unsigned length
= 0;
8820 for (c
= c1
; c
<= c2
; ++c
)
8821 length
+= 4 + strlen (tree_code_name
[c
]);
8823 length
+= strlen ("expected ");
8824 buffer
= (char *) alloca (length
);
8827 for (c
= c1
; c
<= c2
; ++c
)
8829 const char *prefix
= length
? " or " : "expected ";
8831 strcpy (buffer
+ length
, prefix
);
8832 length
+= strlen (prefix
);
8833 strcpy (buffer
+ length
, tree_code_name
[c
]);
8834 length
+= strlen (tree_code_name
[c
]);
8837 internal_error ("tree check: %s, have %s in %s, at %s:%d",
8838 buffer
, tree_code_name
[TREE_CODE (node
)],
8839 function
, trim_filename (file
), line
);
8843 /* Similar to tree_check_failed, except that we check that a tree does
8844 not have the specified code, given in CL. */
8847 tree_not_class_check_failed (const_tree node
, const enum tree_code_class cl
,
8848 const char *file
, int line
, const char *function
)
8851 ("tree check: did not expect class %qs, have %qs (%s) in %s, at %s:%d",
8852 TREE_CODE_CLASS_STRING (cl
),
8853 TREE_CODE_CLASS_STRING (TREE_CODE_CLASS (TREE_CODE (node
))),
8854 tree_code_name
[TREE_CODE (node
)], function
, trim_filename (file
), line
);
8858 /* Similar to tree_check_failed but applied to OMP_CLAUSE codes. */
8861 omp_clause_check_failed (const_tree node
, const char *file
, int line
,
8862 const char *function
, enum omp_clause_code code
)
8864 internal_error ("tree check: expected omp_clause %s, have %s in %s, at %s:%d",
8865 omp_clause_code_name
[code
], tree_code_name
[TREE_CODE (node
)],
8866 function
, trim_filename (file
), line
);
8870 /* Similar to tree_range_check_failed but applied to OMP_CLAUSE codes. */
8873 omp_clause_range_check_failed (const_tree node
, const char *file
, int line
,
8874 const char *function
, enum omp_clause_code c1
,
8875 enum omp_clause_code c2
)
8878 unsigned length
= 0;
8881 for (c
= c1
; c
<= c2
; ++c
)
8882 length
+= 4 + strlen (omp_clause_code_name
[c
]);
8884 length
+= strlen ("expected ");
8885 buffer
= (char *) alloca (length
);
8888 for (c
= c1
; c
<= c2
; ++c
)
8890 const char *prefix
= length
? " or " : "expected ";
8892 strcpy (buffer
+ length
, prefix
);
8893 length
+= strlen (prefix
);
8894 strcpy (buffer
+ length
, omp_clause_code_name
[c
]);
8895 length
+= strlen (omp_clause_code_name
[c
]);
8898 internal_error ("tree check: %s, have %s in %s, at %s:%d",
8899 buffer
, omp_clause_code_name
[TREE_CODE (node
)],
8900 function
, trim_filename (file
), line
);
8904 #undef DEFTREESTRUCT
8905 #define DEFTREESTRUCT(VAL, NAME) NAME,
8907 static const char *ts_enum_names
[] = {
8908 #include "treestruct.def"
8910 #undef DEFTREESTRUCT
8912 #define TS_ENUM_NAME(EN) (ts_enum_names[(EN)])
8914 /* Similar to tree_class_check_failed, except that we check for
8915 whether CODE contains the tree structure identified by EN. */
8918 tree_contains_struct_check_failed (const_tree node
,
8919 const enum tree_node_structure_enum en
,
8920 const char *file
, int line
,
8921 const char *function
)
8924 ("tree check: expected tree that contains %qs structure, have %qs in %s, at %s:%d",
8926 tree_code_name
[TREE_CODE (node
)], function
, trim_filename (file
), line
);
8930 /* Similar to above, except that the check is for the bounds of a TREE_VEC's
8931 (dynamically sized) vector. */
8934 tree_vec_elt_check_failed (int idx
, int len
, const char *file
, int line
,
8935 const char *function
)
8938 ("tree check: accessed elt %d of tree_vec with %d elts in %s, at %s:%d",
8939 idx
+ 1, len
, function
, trim_filename (file
), line
);
8942 /* Similar to above, except that the check is for the bounds of the operand
8943 vector of an expression node EXP. */
8946 tree_operand_check_failed (int idx
, const_tree exp
, const char *file
,
8947 int line
, const char *function
)
8949 int code
= TREE_CODE (exp
);
8951 ("tree check: accessed operand %d of %s with %d operands in %s, at %s:%d",
8952 idx
+ 1, tree_code_name
[code
], TREE_OPERAND_LENGTH (exp
),
8953 function
, trim_filename (file
), line
);
8956 /* Similar to above, except that the check is for the number of
8957 operands of an OMP_CLAUSE node. */
8960 omp_clause_operand_check_failed (int idx
, const_tree t
, const char *file
,
8961 int line
, const char *function
)
8964 ("tree check: accessed operand %d of omp_clause %s with %d operands "
8965 "in %s, at %s:%d", idx
+ 1, omp_clause_code_name
[OMP_CLAUSE_CODE (t
)],
8966 omp_clause_num_ops
[OMP_CLAUSE_CODE (t
)], function
,
8967 trim_filename (file
), line
);
8969 #endif /* ENABLE_TREE_CHECKING */
8971 /* Create a new vector type node holding SUBPARTS units of type INNERTYPE,
8972 and mapped to the machine mode MODE. Initialize its fields and build
8973 the information necessary for debugging output. */
8976 make_vector_type (tree innertype
, int nunits
, enum machine_mode mode
)
8979 hashval_t hashcode
= 0;
8981 t
= make_node (VECTOR_TYPE
);
8982 TREE_TYPE (t
) = TYPE_MAIN_VARIANT (innertype
);
8983 SET_TYPE_VECTOR_SUBPARTS (t
, nunits
);
8984 SET_TYPE_MODE (t
, mode
);
8986 if (TYPE_STRUCTURAL_EQUALITY_P (innertype
))
8987 SET_TYPE_STRUCTURAL_EQUALITY (t
);
8988 else if (TYPE_CANONICAL (innertype
) != innertype
8989 || mode
!= VOIDmode
)
8991 = make_vector_type (TYPE_CANONICAL (innertype
), nunits
, VOIDmode
);
8995 hashcode
= iterative_hash_host_wide_int (VECTOR_TYPE
, hashcode
);
8996 hashcode
= iterative_hash_host_wide_int (nunits
, hashcode
);
8997 hashcode
= iterative_hash_host_wide_int (mode
, hashcode
);
8998 hashcode
= iterative_hash_object (TYPE_HASH (TREE_TYPE (t
)), hashcode
);
8999 t
= type_hash_canon (hashcode
, t
);
9001 /* We have built a main variant, based on the main variant of the
9002 inner type. Use it to build the variant we return. */
9003 if ((TYPE_ATTRIBUTES (innertype
) || TYPE_QUALS (innertype
))
9004 && TREE_TYPE (t
) != innertype
)
9005 return build_type_attribute_qual_variant (t
,
9006 TYPE_ATTRIBUTES (innertype
),
9007 TYPE_QUALS (innertype
));
9013 make_or_reuse_type (unsigned size
, int unsignedp
)
9015 if (size
== INT_TYPE_SIZE
)
9016 return unsignedp
? unsigned_type_node
: integer_type_node
;
9017 if (size
== CHAR_TYPE_SIZE
)
9018 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
9019 if (size
== SHORT_TYPE_SIZE
)
9020 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
9021 if (size
== LONG_TYPE_SIZE
)
9022 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
9023 if (size
== LONG_LONG_TYPE_SIZE
)
9024 return (unsignedp
? long_long_unsigned_type_node
9025 : long_long_integer_type_node
);
9026 if (size
== 128 && int128_integer_type_node
)
9027 return (unsignedp
? int128_unsigned_type_node
9028 : int128_integer_type_node
);
9031 return make_unsigned_type (size
);
9033 return make_signed_type (size
);
9036 /* Create or reuse a fract type by SIZE, UNSIGNEDP, and SATP. */
9039 make_or_reuse_fract_type (unsigned size
, int unsignedp
, int satp
)
9043 if (size
== SHORT_FRACT_TYPE_SIZE
)
9044 return unsignedp
? sat_unsigned_short_fract_type_node
9045 : sat_short_fract_type_node
;
9046 if (size
== FRACT_TYPE_SIZE
)
9047 return unsignedp
? sat_unsigned_fract_type_node
: sat_fract_type_node
;
9048 if (size
== LONG_FRACT_TYPE_SIZE
)
9049 return unsignedp
? sat_unsigned_long_fract_type_node
9050 : sat_long_fract_type_node
;
9051 if (size
== LONG_LONG_FRACT_TYPE_SIZE
)
9052 return unsignedp
? sat_unsigned_long_long_fract_type_node
9053 : sat_long_long_fract_type_node
;
9057 if (size
== SHORT_FRACT_TYPE_SIZE
)
9058 return unsignedp
? unsigned_short_fract_type_node
9059 : short_fract_type_node
;
9060 if (size
== FRACT_TYPE_SIZE
)
9061 return unsignedp
? unsigned_fract_type_node
: fract_type_node
;
9062 if (size
== LONG_FRACT_TYPE_SIZE
)
9063 return unsignedp
? unsigned_long_fract_type_node
9064 : long_fract_type_node
;
9065 if (size
== LONG_LONG_FRACT_TYPE_SIZE
)
9066 return unsignedp
? unsigned_long_long_fract_type_node
9067 : long_long_fract_type_node
;
9070 return make_fract_type (size
, unsignedp
, satp
);
9073 /* Create or reuse an accum type by SIZE, UNSIGNEDP, and SATP. */
9076 make_or_reuse_accum_type (unsigned size
, int unsignedp
, int satp
)
9080 if (size
== SHORT_ACCUM_TYPE_SIZE
)
9081 return unsignedp
? sat_unsigned_short_accum_type_node
9082 : sat_short_accum_type_node
;
9083 if (size
== ACCUM_TYPE_SIZE
)
9084 return unsignedp
? sat_unsigned_accum_type_node
: sat_accum_type_node
;
9085 if (size
== LONG_ACCUM_TYPE_SIZE
)
9086 return unsignedp
? sat_unsigned_long_accum_type_node
9087 : sat_long_accum_type_node
;
9088 if (size
== LONG_LONG_ACCUM_TYPE_SIZE
)
9089 return unsignedp
? sat_unsigned_long_long_accum_type_node
9090 : sat_long_long_accum_type_node
;
9094 if (size
== SHORT_ACCUM_TYPE_SIZE
)
9095 return unsignedp
? unsigned_short_accum_type_node
9096 : short_accum_type_node
;
9097 if (size
== ACCUM_TYPE_SIZE
)
9098 return unsignedp
? unsigned_accum_type_node
: accum_type_node
;
9099 if (size
== LONG_ACCUM_TYPE_SIZE
)
9100 return unsignedp
? unsigned_long_accum_type_node
9101 : long_accum_type_node
;
9102 if (size
== LONG_LONG_ACCUM_TYPE_SIZE
)
9103 return unsignedp
? unsigned_long_long_accum_type_node
9104 : long_long_accum_type_node
;
9107 return make_accum_type (size
, unsignedp
, satp
);
9110 /* Create nodes for all integer types (and error_mark_node) using the sizes
9111 of C datatypes. The caller should call set_sizetype soon after calling
9112 this function to select one of the types as sizetype. */
9115 build_common_tree_nodes (bool signed_char
)
9117 error_mark_node
= make_node (ERROR_MARK
);
9118 TREE_TYPE (error_mark_node
) = error_mark_node
;
9120 initialize_sizetypes ();
9122 /* Define both `signed char' and `unsigned char'. */
9123 signed_char_type_node
= make_signed_type (CHAR_TYPE_SIZE
);
9124 TYPE_STRING_FLAG (signed_char_type_node
) = 1;
9125 unsigned_char_type_node
= make_unsigned_type (CHAR_TYPE_SIZE
);
9126 TYPE_STRING_FLAG (unsigned_char_type_node
) = 1;
9128 /* Define `char', which is like either `signed char' or `unsigned char'
9129 but not the same as either. */
9132 ? make_signed_type (CHAR_TYPE_SIZE
)
9133 : make_unsigned_type (CHAR_TYPE_SIZE
));
9134 TYPE_STRING_FLAG (char_type_node
) = 1;
9136 short_integer_type_node
= make_signed_type (SHORT_TYPE_SIZE
);
9137 short_unsigned_type_node
= make_unsigned_type (SHORT_TYPE_SIZE
);
9138 integer_type_node
= make_signed_type (INT_TYPE_SIZE
);
9139 unsigned_type_node
= make_unsigned_type (INT_TYPE_SIZE
);
9140 long_integer_type_node
= make_signed_type (LONG_TYPE_SIZE
);
9141 long_unsigned_type_node
= make_unsigned_type (LONG_TYPE_SIZE
);
9142 long_long_integer_type_node
= make_signed_type (LONG_LONG_TYPE_SIZE
);
9143 long_long_unsigned_type_node
= make_unsigned_type (LONG_LONG_TYPE_SIZE
);
9144 #if HOST_BITS_PER_WIDE_INT >= 64
9145 /* TODO: This isn't correct, but as logic depends at the moment on
9146 host's instead of target's wide-integer.
9147 If there is a target not supporting TImode, but has an 128-bit
9148 integer-scalar register, this target check needs to be adjusted. */
9149 if (targetm
.scalar_mode_supported_p (TImode
))
9151 int128_integer_type_node
= make_signed_type (128);
9152 int128_unsigned_type_node
= make_unsigned_type (128);
9155 /* Define a boolean type. This type only represents boolean values but
9156 may be larger than char depending on the value of BOOL_TYPE_SIZE.
9157 Front ends which want to override this size (i.e. Java) can redefine
9158 boolean_type_node before calling build_common_tree_nodes_2. */
9159 boolean_type_node
= make_unsigned_type (BOOL_TYPE_SIZE
);
9160 TREE_SET_CODE (boolean_type_node
, BOOLEAN_TYPE
);
9161 TYPE_MAX_VALUE (boolean_type_node
) = build_int_cst (boolean_type_node
, 1);
9162 TYPE_PRECISION (boolean_type_node
) = 1;
9164 /* Fill in the rest of the sized types. Reuse existing type nodes
9166 intQI_type_node
= make_or_reuse_type (GET_MODE_BITSIZE (QImode
), 0);
9167 intHI_type_node
= make_or_reuse_type (GET_MODE_BITSIZE (HImode
), 0);
9168 intSI_type_node
= make_or_reuse_type (GET_MODE_BITSIZE (SImode
), 0);
9169 intDI_type_node
= make_or_reuse_type (GET_MODE_BITSIZE (DImode
), 0);
9170 intTI_type_node
= make_or_reuse_type (GET_MODE_BITSIZE (TImode
), 0);
9172 unsigned_intQI_type_node
= make_or_reuse_type (GET_MODE_BITSIZE (QImode
), 1);
9173 unsigned_intHI_type_node
= make_or_reuse_type (GET_MODE_BITSIZE (HImode
), 1);
9174 unsigned_intSI_type_node
= make_or_reuse_type (GET_MODE_BITSIZE (SImode
), 1);
9175 unsigned_intDI_type_node
= make_or_reuse_type (GET_MODE_BITSIZE (DImode
), 1);
9176 unsigned_intTI_type_node
= make_or_reuse_type (GET_MODE_BITSIZE (TImode
), 1);
9178 access_public_node
= get_identifier ("public");
9179 access_protected_node
= get_identifier ("protected");
9180 access_private_node
= get_identifier ("private");
9183 /* Call this function after calling build_common_tree_nodes and set_sizetype.
9184 It will create several other common tree nodes. */
9187 build_common_tree_nodes_2 (int short_double
)
9189 /* Define these next since types below may used them. */
9190 integer_zero_node
= build_int_cst (integer_type_node
, 0);
9191 integer_one_node
= build_int_cst (integer_type_node
, 1);
9192 integer_three_node
= build_int_cst (integer_type_node
, 3);
9193 integer_minus_one_node
= build_int_cst (integer_type_node
, -1);
9195 size_zero_node
= size_int (0);
9196 size_one_node
= size_int (1);
9197 bitsize_zero_node
= bitsize_int (0);
9198 bitsize_one_node
= bitsize_int (1);
9199 bitsize_unit_node
= bitsize_int (BITS_PER_UNIT
);
9201 boolean_false_node
= TYPE_MIN_VALUE (boolean_type_node
);
9202 boolean_true_node
= TYPE_MAX_VALUE (boolean_type_node
);
9204 void_type_node
= make_node (VOID_TYPE
);
9205 layout_type (void_type_node
);
9207 /* We are not going to have real types in C with less than byte alignment,
9208 so we might as well not have any types that claim to have it. */
9209 TYPE_ALIGN (void_type_node
) = BITS_PER_UNIT
;
9210 TYPE_USER_ALIGN (void_type_node
) = 0;
9212 null_pointer_node
= build_int_cst (build_pointer_type (void_type_node
), 0);
9213 layout_type (TREE_TYPE (null_pointer_node
));
9215 ptr_type_node
= build_pointer_type (void_type_node
);
9217 = build_pointer_type (build_type_variant (void_type_node
, 1, 0));
9218 fileptr_type_node
= ptr_type_node
;
9220 float_type_node
= make_node (REAL_TYPE
);
9221 TYPE_PRECISION (float_type_node
) = FLOAT_TYPE_SIZE
;
9222 layout_type (float_type_node
);
9224 double_type_node
= make_node (REAL_TYPE
);
9226 TYPE_PRECISION (double_type_node
) = FLOAT_TYPE_SIZE
;
9228 TYPE_PRECISION (double_type_node
) = DOUBLE_TYPE_SIZE
;
9229 layout_type (double_type_node
);
9231 long_double_type_node
= make_node (REAL_TYPE
);
9232 TYPE_PRECISION (long_double_type_node
) = LONG_DOUBLE_TYPE_SIZE
;
9233 layout_type (long_double_type_node
);
9235 float_ptr_type_node
= build_pointer_type (float_type_node
);
9236 double_ptr_type_node
= build_pointer_type (double_type_node
);
9237 long_double_ptr_type_node
= build_pointer_type (long_double_type_node
);
9238 integer_ptr_type_node
= build_pointer_type (integer_type_node
);
9240 /* Fixed size integer types. */
9241 uint32_type_node
= build_nonstandard_integer_type (32, true);
9242 uint64_type_node
= build_nonstandard_integer_type (64, true);
9244 /* Decimal float types. */
9245 dfloat32_type_node
= make_node (REAL_TYPE
);
9246 TYPE_PRECISION (dfloat32_type_node
) = DECIMAL32_TYPE_SIZE
;
9247 layout_type (dfloat32_type_node
);
9248 SET_TYPE_MODE (dfloat32_type_node
, SDmode
);
9249 dfloat32_ptr_type_node
= build_pointer_type (dfloat32_type_node
);
9251 dfloat64_type_node
= make_node (REAL_TYPE
);
9252 TYPE_PRECISION (dfloat64_type_node
) = DECIMAL64_TYPE_SIZE
;
9253 layout_type (dfloat64_type_node
);
9254 SET_TYPE_MODE (dfloat64_type_node
, DDmode
);
9255 dfloat64_ptr_type_node
= build_pointer_type (dfloat64_type_node
);
9257 dfloat128_type_node
= make_node (REAL_TYPE
);
9258 TYPE_PRECISION (dfloat128_type_node
) = DECIMAL128_TYPE_SIZE
;
9259 layout_type (dfloat128_type_node
);
9260 SET_TYPE_MODE (dfloat128_type_node
, TDmode
);
9261 dfloat128_ptr_type_node
= build_pointer_type (dfloat128_type_node
);
9263 complex_integer_type_node
= build_complex_type (integer_type_node
);
9264 complex_float_type_node
= build_complex_type (float_type_node
);
9265 complex_double_type_node
= build_complex_type (double_type_node
);
9266 complex_long_double_type_node
= build_complex_type (long_double_type_node
);
9268 /* Make fixed-point nodes based on sat/non-sat and signed/unsigned. */
9269 #define MAKE_FIXED_TYPE_NODE(KIND,SIZE) \
9270 sat_ ## KIND ## _type_node = \
9271 make_sat_signed_ ## KIND ## _type (SIZE); \
9272 sat_unsigned_ ## KIND ## _type_node = \
9273 make_sat_unsigned_ ## KIND ## _type (SIZE); \
9274 KIND ## _type_node = make_signed_ ## KIND ## _type (SIZE); \
9275 unsigned_ ## KIND ## _type_node = \
9276 make_unsigned_ ## KIND ## _type (SIZE);
9278 #define MAKE_FIXED_TYPE_NODE_WIDTH(KIND,WIDTH,SIZE) \
9279 sat_ ## WIDTH ## KIND ## _type_node = \
9280 make_sat_signed_ ## KIND ## _type (SIZE); \
9281 sat_unsigned_ ## WIDTH ## KIND ## _type_node = \
9282 make_sat_unsigned_ ## KIND ## _type (SIZE); \
9283 WIDTH ## KIND ## _type_node = make_signed_ ## KIND ## _type (SIZE); \
9284 unsigned_ ## WIDTH ## KIND ## _type_node = \
9285 make_unsigned_ ## KIND ## _type (SIZE);
9287 /* Make fixed-point type nodes based on four different widths. */
9288 #define MAKE_FIXED_TYPE_NODE_FAMILY(N1,N2) \
9289 MAKE_FIXED_TYPE_NODE_WIDTH (N1, short_, SHORT_ ## N2 ## _TYPE_SIZE) \
9290 MAKE_FIXED_TYPE_NODE (N1, N2 ## _TYPE_SIZE) \
9291 MAKE_FIXED_TYPE_NODE_WIDTH (N1, long_, LONG_ ## N2 ## _TYPE_SIZE) \
9292 MAKE_FIXED_TYPE_NODE_WIDTH (N1, long_long_, LONG_LONG_ ## N2 ## _TYPE_SIZE)
9294 /* Make fixed-point mode nodes based on sat/non-sat and signed/unsigned. */
9295 #define MAKE_FIXED_MODE_NODE(KIND,NAME,MODE) \
9296 NAME ## _type_node = \
9297 make_or_reuse_signed_ ## KIND ## _type (GET_MODE_BITSIZE (MODE ## mode)); \
9298 u ## NAME ## _type_node = \
9299 make_or_reuse_unsigned_ ## KIND ## _type \
9300 (GET_MODE_BITSIZE (U ## MODE ## mode)); \
9301 sat_ ## NAME ## _type_node = \
9302 make_or_reuse_sat_signed_ ## KIND ## _type \
9303 (GET_MODE_BITSIZE (MODE ## mode)); \
9304 sat_u ## NAME ## _type_node = \
9305 make_or_reuse_sat_unsigned_ ## KIND ## _type \
9306 (GET_MODE_BITSIZE (U ## MODE ## mode));
9308 /* Fixed-point type and mode nodes. */
9309 MAKE_FIXED_TYPE_NODE_FAMILY (fract
, FRACT
)
9310 MAKE_FIXED_TYPE_NODE_FAMILY (accum
, ACCUM
)
9311 MAKE_FIXED_MODE_NODE (fract
, qq
, QQ
)
9312 MAKE_FIXED_MODE_NODE (fract
, hq
, HQ
)
9313 MAKE_FIXED_MODE_NODE (fract
, sq
, SQ
)
9314 MAKE_FIXED_MODE_NODE (fract
, dq
, DQ
)
9315 MAKE_FIXED_MODE_NODE (fract
, tq
, TQ
)
9316 MAKE_FIXED_MODE_NODE (accum
, ha
, HA
)
9317 MAKE_FIXED_MODE_NODE (accum
, sa
, SA
)
9318 MAKE_FIXED_MODE_NODE (accum
, da
, DA
)
9319 MAKE_FIXED_MODE_NODE (accum
, ta
, TA
)
9322 tree t
= targetm
.build_builtin_va_list ();
9324 /* Many back-ends define record types without setting TYPE_NAME.
9325 If we copied the record type here, we'd keep the original
9326 record type without a name. This breaks name mangling. So,
9327 don't copy record types and let c_common_nodes_and_builtins()
9328 declare the type to be __builtin_va_list. */
9329 if (TREE_CODE (t
) != RECORD_TYPE
)
9330 t
= build_variant_type_copy (t
);
9332 va_list_type_node
= t
;
9336 /* A subroutine of build_common_builtin_nodes. Define a builtin function. */
9339 local_define_builtin (const char *name
, tree type
, enum built_in_function code
,
9340 const char *library_name
, int ecf_flags
)
9344 decl
= add_builtin_function (name
, type
, code
, BUILT_IN_NORMAL
,
9345 library_name
, NULL_TREE
);
9346 if (ecf_flags
& ECF_CONST
)
9347 TREE_READONLY (decl
) = 1;
9348 if (ecf_flags
& ECF_PURE
)
9349 DECL_PURE_P (decl
) = 1;
9350 if (ecf_flags
& ECF_LOOPING_CONST_OR_PURE
)
9351 DECL_LOOPING_CONST_OR_PURE_P (decl
) = 1;
9352 if (ecf_flags
& ECF_NORETURN
)
9353 TREE_THIS_VOLATILE (decl
) = 1;
9354 if (ecf_flags
& ECF_NOTHROW
)
9355 TREE_NOTHROW (decl
) = 1;
9356 if (ecf_flags
& ECF_MALLOC
)
9357 DECL_IS_MALLOC (decl
) = 1;
9358 if (ecf_flags
& ECF_LEAF
)
9359 DECL_ATTRIBUTES (decl
) = tree_cons (get_identifier ("leaf"),
9360 NULL
, DECL_ATTRIBUTES (decl
));
9362 built_in_decls
[code
] = decl
;
9363 implicit_built_in_decls
[code
] = decl
;
9366 /* Call this function after instantiating all builtins that the language
9367 front end cares about. This will build the rest of the builtins that
9368 are relied upon by the tree optimizers and the middle-end. */
9371 build_common_builtin_nodes (void)
9375 if (built_in_decls
[BUILT_IN_MEMCPY
] == NULL
9376 || built_in_decls
[BUILT_IN_MEMMOVE
] == NULL
)
9378 ftype
= build_function_type_list (ptr_type_node
,
9379 ptr_type_node
, const_ptr_type_node
,
9380 size_type_node
, NULL_TREE
);
9382 if (built_in_decls
[BUILT_IN_MEMCPY
] == NULL
)
9383 local_define_builtin ("__builtin_memcpy", ftype
, BUILT_IN_MEMCPY
,
9384 "memcpy", ECF_NOTHROW
| ECF_LEAF
);
9385 if (built_in_decls
[BUILT_IN_MEMMOVE
] == NULL
)
9386 local_define_builtin ("__builtin_memmove", ftype
, BUILT_IN_MEMMOVE
,
9387 "memmove", ECF_NOTHROW
| ECF_LEAF
);
9390 if (built_in_decls
[BUILT_IN_MEMCMP
] == NULL
)
9392 ftype
= build_function_type_list (integer_type_node
, const_ptr_type_node
,
9393 const_ptr_type_node
, size_type_node
,
9395 local_define_builtin ("__builtin_memcmp", ftype
, BUILT_IN_MEMCMP
,
9396 "memcmp", ECF_PURE
| ECF_NOTHROW
| ECF_LEAF
);
9399 if (built_in_decls
[BUILT_IN_MEMSET
] == NULL
)
9401 ftype
= build_function_type_list (ptr_type_node
,
9402 ptr_type_node
, integer_type_node
,
9403 size_type_node
, NULL_TREE
);
9404 local_define_builtin ("__builtin_memset", ftype
, BUILT_IN_MEMSET
,
9405 "memset", ECF_NOTHROW
| ECF_LEAF
);
9408 if (built_in_decls
[BUILT_IN_ALLOCA
] == NULL
)
9410 ftype
= build_function_type_list (ptr_type_node
,
9411 size_type_node
, NULL_TREE
);
9412 local_define_builtin ("__builtin_alloca", ftype
, BUILT_IN_ALLOCA
,
9413 "alloca", ECF_MALLOC
| ECF_NOTHROW
| ECF_LEAF
);
9416 /* If we're checking the stack, `alloca' can throw. */
9417 if (flag_stack_check
)
9418 TREE_NOTHROW (built_in_decls
[BUILT_IN_ALLOCA
]) = 0;
9420 ftype
= build_function_type_list (void_type_node
,
9421 ptr_type_node
, ptr_type_node
,
9422 ptr_type_node
, NULL_TREE
);
9423 local_define_builtin ("__builtin_init_trampoline", ftype
,
9424 BUILT_IN_INIT_TRAMPOLINE
,
9425 "__builtin_init_trampoline", ECF_NOTHROW
| ECF_LEAF
);
9427 ftype
= build_function_type_list (ptr_type_node
, ptr_type_node
, NULL_TREE
);
9428 local_define_builtin ("__builtin_adjust_trampoline", ftype
,
9429 BUILT_IN_ADJUST_TRAMPOLINE
,
9430 "__builtin_adjust_trampoline",
9431 ECF_CONST
| ECF_NOTHROW
);
9433 ftype
= build_function_type_list (void_type_node
,
9434 ptr_type_node
, ptr_type_node
, NULL_TREE
);
9435 local_define_builtin ("__builtin_nonlocal_goto", ftype
,
9436 BUILT_IN_NONLOCAL_GOTO
,
9437 "__builtin_nonlocal_goto",
9438 ECF_NORETURN
| ECF_NOTHROW
);
9440 ftype
= build_function_type_list (void_type_node
,
9441 ptr_type_node
, ptr_type_node
, NULL_TREE
);
9442 local_define_builtin ("__builtin_setjmp_setup", ftype
,
9443 BUILT_IN_SETJMP_SETUP
,
9444 "__builtin_setjmp_setup", ECF_NOTHROW
);
9446 ftype
= build_function_type_list (ptr_type_node
, ptr_type_node
, NULL_TREE
);
9447 local_define_builtin ("__builtin_setjmp_dispatcher", ftype
,
9448 BUILT_IN_SETJMP_DISPATCHER
,
9449 "__builtin_setjmp_dispatcher",
9450 ECF_PURE
| ECF_NOTHROW
);
9452 ftype
= build_function_type_list (void_type_node
, ptr_type_node
, NULL_TREE
);
9453 local_define_builtin ("__builtin_setjmp_receiver", ftype
,
9454 BUILT_IN_SETJMP_RECEIVER
,
9455 "__builtin_setjmp_receiver", ECF_NOTHROW
);
9457 ftype
= build_function_type_list (ptr_type_node
, NULL_TREE
);
9458 local_define_builtin ("__builtin_stack_save", ftype
, BUILT_IN_STACK_SAVE
,
9459 "__builtin_stack_save", ECF_NOTHROW
| ECF_LEAF
);
9461 ftype
= build_function_type_list (void_type_node
, ptr_type_node
, NULL_TREE
);
9462 local_define_builtin ("__builtin_stack_restore", ftype
,
9463 BUILT_IN_STACK_RESTORE
,
9464 "__builtin_stack_restore", ECF_NOTHROW
| ECF_LEAF
);
9466 /* If there's a possibility that we might use the ARM EABI, build the
9467 alternate __cxa_end_cleanup node used to resume from C++ and Java. */
9468 if (targetm
.arm_eabi_unwinder
)
9470 ftype
= build_function_type_list (void_type_node
, NULL_TREE
);
9471 local_define_builtin ("__builtin_cxa_end_cleanup", ftype
,
9472 BUILT_IN_CXA_END_CLEANUP
,
9473 "__cxa_end_cleanup", ECF_NORETURN
| ECF_LEAF
);
9476 ftype
= build_function_type_list (void_type_node
, ptr_type_node
, NULL_TREE
);
9477 local_define_builtin ("__builtin_unwind_resume", ftype
,
9478 BUILT_IN_UNWIND_RESUME
,
9479 ((targetm
.except_unwind_info (&global_options
)
9481 ? "_Unwind_SjLj_Resume" : "_Unwind_Resume"),
9484 /* The exception object and filter values from the runtime. The argument
9485 must be zero before exception lowering, i.e. from the front end. After
9486 exception lowering, it will be the region number for the exception
9487 landing pad. These functions are PURE instead of CONST to prevent
9488 them from being hoisted past the exception edge that will initialize
9489 its value in the landing pad. */
9490 ftype
= build_function_type_list (ptr_type_node
,
9491 integer_type_node
, NULL_TREE
);
9492 local_define_builtin ("__builtin_eh_pointer", ftype
, BUILT_IN_EH_POINTER
,
9493 "__builtin_eh_pointer", ECF_PURE
| ECF_NOTHROW
| ECF_LEAF
);
9495 tmp
= lang_hooks
.types
.type_for_mode (targetm
.eh_return_filter_mode (), 0);
9496 ftype
= build_function_type_list (tmp
, integer_type_node
, NULL_TREE
);
9497 local_define_builtin ("__builtin_eh_filter", ftype
, BUILT_IN_EH_FILTER
,
9498 "__builtin_eh_filter", ECF_PURE
| ECF_NOTHROW
| ECF_LEAF
);
9500 ftype
= build_function_type_list (void_type_node
,
9501 integer_type_node
, integer_type_node
,
9503 local_define_builtin ("__builtin_eh_copy_values", ftype
,
9504 BUILT_IN_EH_COPY_VALUES
,
9505 "__builtin_eh_copy_values", ECF_NOTHROW
);
9507 /* Complex multiplication and division. These are handled as builtins
9508 rather than optabs because emit_library_call_value doesn't support
9509 complex. Further, we can do slightly better with folding these
9510 beasties if the real and complex parts of the arguments are separate. */
9514 for (mode
= MIN_MODE_COMPLEX_FLOAT
; mode
<= MAX_MODE_COMPLEX_FLOAT
; ++mode
)
9516 char mode_name_buf
[4], *q
;
9518 enum built_in_function mcode
, dcode
;
9519 tree type
, inner_type
;
9521 type
= lang_hooks
.types
.type_for_mode ((enum machine_mode
) mode
, 0);
9524 inner_type
= TREE_TYPE (type
);
9526 ftype
= build_function_type_list (type
, inner_type
, inner_type
,
9527 inner_type
, inner_type
, NULL_TREE
);
9529 mcode
= ((enum built_in_function
)
9530 (BUILT_IN_COMPLEX_MUL_MIN
+ mode
- MIN_MODE_COMPLEX_FLOAT
));
9531 dcode
= ((enum built_in_function
)
9532 (BUILT_IN_COMPLEX_DIV_MIN
+ mode
- MIN_MODE_COMPLEX_FLOAT
));
9534 for (p
= GET_MODE_NAME (mode
), q
= mode_name_buf
; *p
; p
++, q
++)
9538 built_in_names
[mcode
] = concat ("__mul", mode_name_buf
, "3", NULL
);
9539 local_define_builtin (built_in_names
[mcode
], ftype
, mcode
,
9540 built_in_names
[mcode
], ECF_CONST
| ECF_NOTHROW
| ECF_LEAF
);
9542 built_in_names
[dcode
] = concat ("__div", mode_name_buf
, "3", NULL
);
9543 local_define_builtin (built_in_names
[dcode
], ftype
, dcode
,
9544 built_in_names
[dcode
], ECF_CONST
| ECF_NOTHROW
| ECF_LEAF
);
9549 /* HACK. GROSS. This is absolutely disgusting. I wish there was a
9552 If we requested a pointer to a vector, build up the pointers that
9553 we stripped off while looking for the inner type. Similarly for
9554 return values from functions.
9556 The argument TYPE is the top of the chain, and BOTTOM is the
9557 new type which we will point to. */
9560 reconstruct_complex_type (tree type
, tree bottom
)
9564 if (TREE_CODE (type
) == POINTER_TYPE
)
9566 inner
= reconstruct_complex_type (TREE_TYPE (type
), bottom
);
9567 outer
= build_pointer_type_for_mode (inner
, TYPE_MODE (type
),
9568 TYPE_REF_CAN_ALIAS_ALL (type
));
9570 else if (TREE_CODE (type
) == REFERENCE_TYPE
)
9572 inner
= reconstruct_complex_type (TREE_TYPE (type
), bottom
);
9573 outer
= build_reference_type_for_mode (inner
, TYPE_MODE (type
),
9574 TYPE_REF_CAN_ALIAS_ALL (type
));
9576 else if (TREE_CODE (type
) == ARRAY_TYPE
)
9578 inner
= reconstruct_complex_type (TREE_TYPE (type
), bottom
);
9579 outer
= build_array_type (inner
, TYPE_DOMAIN (type
));
9581 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
9583 inner
= reconstruct_complex_type (TREE_TYPE (type
), bottom
);
9584 outer
= build_function_type (inner
, TYPE_ARG_TYPES (type
));
9586 else if (TREE_CODE (type
) == METHOD_TYPE
)
9588 inner
= reconstruct_complex_type (TREE_TYPE (type
), bottom
);
9589 /* The build_method_type_directly() routine prepends 'this' to argument list,
9590 so we must compensate by getting rid of it. */
9592 = build_method_type_directly
9593 (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (type
))),
9595 TREE_CHAIN (TYPE_ARG_TYPES (type
)));
9597 else if (TREE_CODE (type
) == OFFSET_TYPE
)
9599 inner
= reconstruct_complex_type (TREE_TYPE (type
), bottom
);
9600 outer
= build_offset_type (TYPE_OFFSET_BASETYPE (type
), inner
);
9605 return build_type_attribute_qual_variant (outer
, TYPE_ATTRIBUTES (type
),
9609 /* Returns a vector tree node given a mode (integer, vector, or BLKmode) and
9612 build_vector_type_for_mode (tree innertype
, enum machine_mode mode
)
9616 switch (GET_MODE_CLASS (mode
))
9618 case MODE_VECTOR_INT
:
9619 case MODE_VECTOR_FLOAT
:
9620 case MODE_VECTOR_FRACT
:
9621 case MODE_VECTOR_UFRACT
:
9622 case MODE_VECTOR_ACCUM
:
9623 case MODE_VECTOR_UACCUM
:
9624 nunits
= GET_MODE_NUNITS (mode
);
9628 /* Check that there are no leftover bits. */
9629 gcc_assert (GET_MODE_BITSIZE (mode
)
9630 % TREE_INT_CST_LOW (TYPE_SIZE (innertype
)) == 0);
9632 nunits
= GET_MODE_BITSIZE (mode
)
9633 / TREE_INT_CST_LOW (TYPE_SIZE (innertype
));
9640 return make_vector_type (innertype
, nunits
, mode
);
9643 /* Similarly, but takes the inner type and number of units, which must be
9647 build_vector_type (tree innertype
, int nunits
)
9649 return make_vector_type (innertype
, nunits
, VOIDmode
);
9652 /* Similarly, but takes the inner type and number of units, which must be
9656 build_opaque_vector_type (tree innertype
, int nunits
)
9659 innertype
= build_distinct_type_copy (innertype
);
9660 t
= make_vector_type (innertype
, nunits
, VOIDmode
);
9661 TYPE_VECTOR_OPAQUE (t
) = true;
9666 /* Given an initializer INIT, return TRUE if INIT is zero or some
9667 aggregate of zeros. Otherwise return FALSE. */
9669 initializer_zerop (const_tree init
)
9675 switch (TREE_CODE (init
))
9678 return integer_zerop (init
);
9681 /* ??? Note that this is not correct for C4X float formats. There,
9682 a bit pattern of all zeros is 1.0; 0.0 is encoded with the most
9683 negative exponent. */
9684 return real_zerop (init
)
9685 && ! REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (init
));
9688 return fixed_zerop (init
);
9691 return integer_zerop (init
)
9692 || (real_zerop (init
)
9693 && ! REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (TREE_REALPART (init
)))
9694 && ! REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (TREE_IMAGPART (init
))));
9697 for (elt
= TREE_VECTOR_CST_ELTS (init
); elt
; elt
= TREE_CHAIN (elt
))
9698 if (!initializer_zerop (TREE_VALUE (elt
)))
9704 unsigned HOST_WIDE_INT idx
;
9706 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (init
), idx
, elt
)
9707 if (!initializer_zerop (elt
))
9716 /* We need to loop through all elements to handle cases like
9717 "\0" and "\0foobar". */
9718 for (i
= 0; i
< TREE_STRING_LENGTH (init
); ++i
)
9719 if (TREE_STRING_POINTER (init
)[i
] != '\0')
9730 /* Build an empty statement at location LOC. */
9733 build_empty_stmt (location_t loc
)
9735 tree t
= build1 (NOP_EXPR
, void_type_node
, size_zero_node
);
9736 SET_EXPR_LOCATION (t
, loc
);
9741 /* Build an OpenMP clause with code CODE. LOC is the location of the
9745 build_omp_clause (location_t loc
, enum omp_clause_code code
)
9750 length
= omp_clause_num_ops
[code
];
9751 size
= (sizeof (struct tree_omp_clause
) + (length
- 1) * sizeof (tree
));
9753 record_node_allocation_statistics (OMP_CLAUSE
, size
);
9755 t
= ggc_alloc_tree_node (size
);
9756 memset (t
, 0, size
);
9757 TREE_SET_CODE (t
, OMP_CLAUSE
);
9758 OMP_CLAUSE_SET_CODE (t
, code
);
9759 OMP_CLAUSE_LOCATION (t
) = loc
;
9764 /* Build a tcc_vl_exp object with code CODE and room for LEN operands. LEN
9765 includes the implicit operand count in TREE_OPERAND 0, and so must be >= 1.
9766 Except for the CODE and operand count field, other storage for the
9767 object is initialized to zeros. */
9770 build_vl_exp_stat (enum tree_code code
, int len MEM_STAT_DECL
)
9773 int length
= (len
- 1) * sizeof (tree
) + sizeof (struct tree_exp
);
9775 gcc_assert (TREE_CODE_CLASS (code
) == tcc_vl_exp
);
9776 gcc_assert (len
>= 1);
9778 record_node_allocation_statistics (code
, length
);
9780 t
= ggc_alloc_zone_cleared_tree_node_stat (&tree_zone
, length PASS_MEM_STAT
);
9782 TREE_SET_CODE (t
, code
);
9784 /* Can't use TREE_OPERAND to store the length because if checking is
9785 enabled, it will try to check the length before we store it. :-P */
9786 t
->exp
.operands
[0] = build_int_cst (sizetype
, len
);
9791 /* Helper function for build_call_* functions; build a CALL_EXPR with
9792 indicated RETURN_TYPE, FN, and NARGS, but do not initialize any of
9793 the argument slots. */
9796 build_call_1 (tree return_type
, tree fn
, int nargs
)
9800 t
= build_vl_exp (CALL_EXPR
, nargs
+ 3);
9801 TREE_TYPE (t
) = return_type
;
9802 CALL_EXPR_FN (t
) = fn
;
9803 CALL_EXPR_STATIC_CHAIN (t
) = NULL
;
9808 /* Build a CALL_EXPR of class tcc_vl_exp with the indicated RETURN_TYPE and
9809 FN and a null static chain slot. NARGS is the number of call arguments
9810 which are specified as "..." arguments. */
9813 build_call_nary (tree return_type
, tree fn
, int nargs
, ...)
9817 va_start (args
, nargs
);
9818 ret
= build_call_valist (return_type
, fn
, nargs
, args
);
9823 /* Build a CALL_EXPR of class tcc_vl_exp with the indicated RETURN_TYPE and
9824 FN and a null static chain slot. NARGS is the number of call arguments
9825 which are specified as a va_list ARGS. */
9828 build_call_valist (tree return_type
, tree fn
, int nargs
, va_list args
)
9833 t
= build_call_1 (return_type
, fn
, nargs
);
9834 for (i
= 0; i
< nargs
; i
++)
9835 CALL_EXPR_ARG (t
, i
) = va_arg (args
, tree
);
9836 process_call_operands (t
);
9840 /* Build a CALL_EXPR of class tcc_vl_exp with the indicated RETURN_TYPE and
9841 FN and a null static chain slot. NARGS is the number of call arguments
9842 which are specified as a tree array ARGS. */
9845 build_call_array_loc (location_t loc
, tree return_type
, tree fn
,
9846 int nargs
, const tree
*args
)
9851 t
= build_call_1 (return_type
, fn
, nargs
);
9852 for (i
= 0; i
< nargs
; i
++)
9853 CALL_EXPR_ARG (t
, i
) = args
[i
];
9854 process_call_operands (t
);
9855 SET_EXPR_LOCATION (t
, loc
);
9859 /* Like build_call_array, but takes a VEC. */
9862 build_call_vec (tree return_type
, tree fn
, VEC(tree
,gc
) *args
)
9867 ret
= build_call_1 (return_type
, fn
, VEC_length (tree
, args
));
9868 FOR_EACH_VEC_ELT (tree
, args
, ix
, t
)
9869 CALL_EXPR_ARG (ret
, ix
) = t
;
9870 process_call_operands (ret
);
9875 /* Returns true if it is possible to prove that the index of
9876 an array access REF (an ARRAY_REF expression) falls into the
9880 in_array_bounds_p (tree ref
)
9882 tree idx
= TREE_OPERAND (ref
, 1);
9885 if (TREE_CODE (idx
) != INTEGER_CST
)
9888 min
= array_ref_low_bound (ref
);
9889 max
= array_ref_up_bound (ref
);
9892 || TREE_CODE (min
) != INTEGER_CST
9893 || TREE_CODE (max
) != INTEGER_CST
)
9896 if (tree_int_cst_lt (idx
, min
)
9897 || tree_int_cst_lt (max
, idx
))
9903 /* Returns true if it is possible to prove that the range of
9904 an array access REF (an ARRAY_RANGE_REF expression) falls
9905 into the array bounds. */
9908 range_in_array_bounds_p (tree ref
)
9910 tree domain_type
= TYPE_DOMAIN (TREE_TYPE (ref
));
9911 tree range_min
, range_max
, min
, max
;
9913 range_min
= TYPE_MIN_VALUE (domain_type
);
9914 range_max
= TYPE_MAX_VALUE (domain_type
);
9917 || TREE_CODE (range_min
) != INTEGER_CST
9918 || TREE_CODE (range_max
) != INTEGER_CST
)
9921 min
= array_ref_low_bound (ref
);
9922 max
= array_ref_up_bound (ref
);
9925 || TREE_CODE (min
) != INTEGER_CST
9926 || TREE_CODE (max
) != INTEGER_CST
)
9929 if (tree_int_cst_lt (range_min
, min
)
9930 || tree_int_cst_lt (max
, range_max
))
9936 /* Return true if T (assumed to be a DECL) must be assigned a memory
9940 needs_to_live_in_memory (const_tree t
)
9942 if (TREE_CODE (t
) == SSA_NAME
)
9943 t
= SSA_NAME_VAR (t
);
9945 return (TREE_ADDRESSABLE (t
)
9946 || is_global_var (t
)
9947 || (TREE_CODE (t
) == RESULT_DECL
9948 && !DECL_BY_REFERENCE (t
)
9949 && aggregate_value_p (t
, current_function_decl
)));
9952 /* Return value of a constant X and sign-extend it. */
9955 int_cst_value (const_tree x
)
9957 unsigned bits
= TYPE_PRECISION (TREE_TYPE (x
));
9958 unsigned HOST_WIDE_INT val
= TREE_INT_CST_LOW (x
);
9960 /* Make sure the sign-extended value will fit in a HOST_WIDE_INT. */
9961 gcc_assert (TREE_INT_CST_HIGH (x
) == 0
9962 || TREE_INT_CST_HIGH (x
) == -1);
9964 if (bits
< HOST_BITS_PER_WIDE_INT
)
9966 bool negative
= ((val
>> (bits
- 1)) & 1) != 0;
9968 val
|= (~(unsigned HOST_WIDE_INT
) 0) << (bits
- 1) << 1;
9970 val
&= ~((~(unsigned HOST_WIDE_INT
) 0) << (bits
- 1) << 1);
9976 /* Return value of a constant X and sign-extend it. */
9979 widest_int_cst_value (const_tree x
)
9981 unsigned bits
= TYPE_PRECISION (TREE_TYPE (x
));
9982 unsigned HOST_WIDEST_INT val
= TREE_INT_CST_LOW (x
);
9984 #if HOST_BITS_PER_WIDEST_INT > HOST_BITS_PER_WIDE_INT
9985 gcc_assert (HOST_BITS_PER_WIDEST_INT
>= 2 * HOST_BITS_PER_WIDE_INT
);
9986 val
|= (((unsigned HOST_WIDEST_INT
) TREE_INT_CST_HIGH (x
))
9987 << HOST_BITS_PER_WIDE_INT
);
9989 /* Make sure the sign-extended value will fit in a HOST_WIDE_INT. */
9990 gcc_assert (TREE_INT_CST_HIGH (x
) == 0
9991 || TREE_INT_CST_HIGH (x
) == -1);
9994 if (bits
< HOST_BITS_PER_WIDEST_INT
)
9996 bool negative
= ((val
>> (bits
- 1)) & 1) != 0;
9998 val
|= (~(unsigned HOST_WIDEST_INT
) 0) << (bits
- 1) << 1;
10000 val
&= ~((~(unsigned HOST_WIDEST_INT
) 0) << (bits
- 1) << 1);
10006 /* If TYPE is an integral type, return an equivalent type which is
10007 unsigned iff UNSIGNEDP is true. If TYPE is not an integral type,
10008 return TYPE itself. */
10011 signed_or_unsigned_type_for (int unsignedp
, tree type
)
10014 if (POINTER_TYPE_P (type
))
10016 /* If the pointer points to the normal address space, use the
10017 size_type_node. Otherwise use an appropriate size for the pointer
10018 based on the named address space it points to. */
10019 if (!TYPE_ADDR_SPACE (TREE_TYPE (t
)))
10020 t
= size_type_node
;
10022 return lang_hooks
.types
.type_for_size (TYPE_PRECISION (t
), unsignedp
);
10025 if (!INTEGRAL_TYPE_P (t
) || TYPE_UNSIGNED (t
) == unsignedp
)
10028 return lang_hooks
.types
.type_for_size (TYPE_PRECISION (t
), unsignedp
);
10031 /* Returns unsigned variant of TYPE. */
10034 unsigned_type_for (tree type
)
10036 return signed_or_unsigned_type_for (1, type
);
10039 /* Returns signed variant of TYPE. */
10042 signed_type_for (tree type
)
10044 return signed_or_unsigned_type_for (0, type
);
10047 /* Returns the largest value obtainable by casting something in INNER type to
10051 upper_bound_in_type (tree outer
, tree inner
)
10054 unsigned int det
= 0;
10055 unsigned oprec
= TYPE_PRECISION (outer
);
10056 unsigned iprec
= TYPE_PRECISION (inner
);
10059 /* Compute a unique number for every combination. */
10060 det
|= (oprec
> iprec
) ? 4 : 0;
10061 det
|= TYPE_UNSIGNED (outer
) ? 2 : 0;
10062 det
|= TYPE_UNSIGNED (inner
) ? 1 : 0;
10064 /* Determine the exponent to use. */
10069 /* oprec <= iprec, outer: signed, inner: don't care. */
10074 /* oprec <= iprec, outer: unsigned, inner: don't care. */
10078 /* oprec > iprec, outer: signed, inner: signed. */
10082 /* oprec > iprec, outer: signed, inner: unsigned. */
10086 /* oprec > iprec, outer: unsigned, inner: signed. */
10090 /* oprec > iprec, outer: unsigned, inner: unsigned. */
10094 gcc_unreachable ();
10097 /* Compute 2^^prec - 1. */
10098 if (prec
<= HOST_BITS_PER_WIDE_INT
)
10101 high
.low
= ((~(unsigned HOST_WIDE_INT
) 0)
10102 >> (HOST_BITS_PER_WIDE_INT
- prec
));
10106 high
.high
= ((~(unsigned HOST_WIDE_INT
) 0)
10107 >> (2 * HOST_BITS_PER_WIDE_INT
- prec
));
10108 high
.low
= ~(unsigned HOST_WIDE_INT
) 0;
10111 return double_int_to_tree (outer
, high
);
10114 /* Returns the smallest value obtainable by casting something in INNER type to
10118 lower_bound_in_type (tree outer
, tree inner
)
10121 unsigned oprec
= TYPE_PRECISION (outer
);
10122 unsigned iprec
= TYPE_PRECISION (inner
);
10124 /* If OUTER type is unsigned, we can definitely cast 0 to OUTER type
10126 if (TYPE_UNSIGNED (outer
)
10127 /* If we are widening something of an unsigned type, OUTER type
10128 contains all values of INNER type. In particular, both INNER
10129 and OUTER types have zero in common. */
10130 || (oprec
> iprec
&& TYPE_UNSIGNED (inner
)))
10131 low
.low
= low
.high
= 0;
10134 /* If we are widening a signed type to another signed type, we
10135 want to obtain -2^^(iprec-1). If we are keeping the
10136 precision or narrowing to a signed type, we want to obtain
10138 unsigned prec
= oprec
> iprec
? iprec
: oprec
;
10140 if (prec
<= HOST_BITS_PER_WIDE_INT
)
10142 low
.high
= ~(unsigned HOST_WIDE_INT
) 0;
10143 low
.low
= (~(unsigned HOST_WIDE_INT
) 0) << (prec
- 1);
10147 low
.high
= ((~(unsigned HOST_WIDE_INT
) 0)
10148 << (prec
- HOST_BITS_PER_WIDE_INT
- 1));
10153 return double_int_to_tree (outer
, low
);
10156 /* Return nonzero if two operands that are suitable for PHI nodes are
10157 necessarily equal. Specifically, both ARG0 and ARG1 must be either
10158 SSA_NAME or invariant. Note that this is strictly an optimization.
10159 That is, callers of this function can directly call operand_equal_p
10160 and get the same result, only slower. */
10163 operand_equal_for_phi_arg_p (const_tree arg0
, const_tree arg1
)
10167 if (TREE_CODE (arg0
) == SSA_NAME
|| TREE_CODE (arg1
) == SSA_NAME
)
10169 return operand_equal_p (arg0
, arg1
, 0);
10172 /* Returns number of zeros at the end of binary representation of X.
10174 ??? Use ffs if available? */
10177 num_ending_zeros (const_tree x
)
10179 unsigned HOST_WIDE_INT fr
, nfr
;
10180 unsigned num
, abits
;
10181 tree type
= TREE_TYPE (x
);
10183 if (TREE_INT_CST_LOW (x
) == 0)
10185 num
= HOST_BITS_PER_WIDE_INT
;
10186 fr
= TREE_INT_CST_HIGH (x
);
10191 fr
= TREE_INT_CST_LOW (x
);
10194 for (abits
= HOST_BITS_PER_WIDE_INT
/ 2; abits
; abits
/= 2)
10197 if (nfr
<< abits
== fr
)
10204 if (num
> TYPE_PRECISION (type
))
10205 num
= TYPE_PRECISION (type
);
10207 return build_int_cst_type (type
, num
);
10211 #define WALK_SUBTREE(NODE) \
10214 result = walk_tree_1 (&(NODE), func, data, pset, lh); \
10220 /* This is a subroutine of walk_tree that walks field of TYPE that are to
10221 be walked whenever a type is seen in the tree. Rest of operands and return
10222 value are as for walk_tree. */
10225 walk_type_fields (tree type
, walk_tree_fn func
, void *data
,
10226 struct pointer_set_t
*pset
, walk_tree_lh lh
)
10228 tree result
= NULL_TREE
;
10230 switch (TREE_CODE (type
))
10233 case REFERENCE_TYPE
:
10234 /* We have to worry about mutually recursive pointers. These can't
10235 be written in C. They can in Ada. It's pathological, but
10236 there's an ACATS test (c38102a) that checks it. Deal with this
10237 by checking if we're pointing to another pointer, that one
10238 points to another pointer, that one does too, and we have no htab.
10239 If so, get a hash table. We check three levels deep to avoid
10240 the cost of the hash table if we don't need one. */
10241 if (POINTER_TYPE_P (TREE_TYPE (type
))
10242 && POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (type
)))
10243 && POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (TREE_TYPE (type
))))
10246 result
= walk_tree_without_duplicates (&TREE_TYPE (type
),
10254 /* ... fall through ... */
10257 WALK_SUBTREE (TREE_TYPE (type
));
10261 WALK_SUBTREE (TYPE_METHOD_BASETYPE (type
));
10263 /* Fall through. */
10265 case FUNCTION_TYPE
:
10266 WALK_SUBTREE (TREE_TYPE (type
));
10270 /* We never want to walk into default arguments. */
10271 for (arg
= TYPE_ARG_TYPES (type
); arg
; arg
= TREE_CHAIN (arg
))
10272 WALK_SUBTREE (TREE_VALUE (arg
));
10277 /* Don't follow this nodes's type if a pointer for fear that
10278 we'll have infinite recursion. If we have a PSET, then we
10281 || (!POINTER_TYPE_P (TREE_TYPE (type
))
10282 && TREE_CODE (TREE_TYPE (type
)) != OFFSET_TYPE
))
10283 WALK_SUBTREE (TREE_TYPE (type
));
10284 WALK_SUBTREE (TYPE_DOMAIN (type
));
10288 WALK_SUBTREE (TREE_TYPE (type
));
10289 WALK_SUBTREE (TYPE_OFFSET_BASETYPE (type
));
10299 /* Apply FUNC to all the sub-trees of TP in a pre-order traversal. FUNC is
10300 called with the DATA and the address of each sub-tree. If FUNC returns a
10301 non-NULL value, the traversal is stopped, and the value returned by FUNC
10302 is returned. If PSET is non-NULL it is used to record the nodes visited,
10303 and to avoid visiting a node more than once. */
10306 walk_tree_1 (tree
*tp
, walk_tree_fn func
, void *data
,
10307 struct pointer_set_t
*pset
, walk_tree_lh lh
)
10309 enum tree_code code
;
10313 #define WALK_SUBTREE_TAIL(NODE) \
10317 goto tail_recurse; \
10322 /* Skip empty subtrees. */
10326 /* Don't walk the same tree twice, if the user has requested
10327 that we avoid doing so. */
10328 if (pset
&& pointer_set_insert (pset
, *tp
))
10331 /* Call the function. */
10333 result
= (*func
) (tp
, &walk_subtrees
, data
);
10335 /* If we found something, return it. */
10339 code
= TREE_CODE (*tp
);
10341 /* Even if we didn't, FUNC may have decided that there was nothing
10342 interesting below this point in the tree. */
10343 if (!walk_subtrees
)
10345 /* But we still need to check our siblings. */
10346 if (code
== TREE_LIST
)
10347 WALK_SUBTREE_TAIL (TREE_CHAIN (*tp
));
10348 else if (code
== OMP_CLAUSE
)
10349 WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp
));
10356 result
= (*lh
) (tp
, &walk_subtrees
, func
, data
, pset
);
10357 if (result
|| !walk_subtrees
)
10364 case IDENTIFIER_NODE
:
10371 case PLACEHOLDER_EXPR
:
10375 /* None of these have subtrees other than those already walked
10380 WALK_SUBTREE (TREE_VALUE (*tp
));
10381 WALK_SUBTREE_TAIL (TREE_CHAIN (*tp
));
10386 int len
= TREE_VEC_LENGTH (*tp
);
10391 /* Walk all elements but the first. */
10393 WALK_SUBTREE (TREE_VEC_ELT (*tp
, len
));
10395 /* Now walk the first one as a tail call. */
10396 WALK_SUBTREE_TAIL (TREE_VEC_ELT (*tp
, 0));
10400 WALK_SUBTREE (TREE_REALPART (*tp
));
10401 WALK_SUBTREE_TAIL (TREE_IMAGPART (*tp
));
10405 unsigned HOST_WIDE_INT idx
;
10406 constructor_elt
*ce
;
10409 VEC_iterate(constructor_elt
, CONSTRUCTOR_ELTS (*tp
), idx
, ce
);
10411 WALK_SUBTREE (ce
->value
);
10416 WALK_SUBTREE_TAIL (TREE_OPERAND (*tp
, 0));
10421 for (decl
= BIND_EXPR_VARS (*tp
); decl
; decl
= DECL_CHAIN (decl
))
10423 /* Walk the DECL_INITIAL and DECL_SIZE. We don't want to walk
10424 into declarations that are just mentioned, rather than
10425 declared; they don't really belong to this part of the tree.
10426 And, we can see cycles: the initializer for a declaration
10427 can refer to the declaration itself. */
10428 WALK_SUBTREE (DECL_INITIAL (decl
));
10429 WALK_SUBTREE (DECL_SIZE (decl
));
10430 WALK_SUBTREE (DECL_SIZE_UNIT (decl
));
10432 WALK_SUBTREE_TAIL (BIND_EXPR_BODY (*tp
));
10435 case STATEMENT_LIST
:
10437 tree_stmt_iterator i
;
10438 for (i
= tsi_start (*tp
); !tsi_end_p (i
); tsi_next (&i
))
10439 WALK_SUBTREE (*tsi_stmt_ptr (i
));
10444 switch (OMP_CLAUSE_CODE (*tp
))
10446 case OMP_CLAUSE_PRIVATE
:
10447 case OMP_CLAUSE_SHARED
:
10448 case OMP_CLAUSE_FIRSTPRIVATE
:
10449 case OMP_CLAUSE_COPYIN
:
10450 case OMP_CLAUSE_COPYPRIVATE
:
10451 case OMP_CLAUSE_IF
:
10452 case OMP_CLAUSE_NUM_THREADS
:
10453 case OMP_CLAUSE_SCHEDULE
:
10454 WALK_SUBTREE (OMP_CLAUSE_OPERAND (*tp
, 0));
10457 case OMP_CLAUSE_NOWAIT
:
10458 case OMP_CLAUSE_ORDERED
:
10459 case OMP_CLAUSE_DEFAULT
:
10460 case OMP_CLAUSE_UNTIED
:
10461 WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp
));
10463 case OMP_CLAUSE_LASTPRIVATE
:
10464 WALK_SUBTREE (OMP_CLAUSE_DECL (*tp
));
10465 WALK_SUBTREE (OMP_CLAUSE_LASTPRIVATE_STMT (*tp
));
10466 WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp
));
10468 case OMP_CLAUSE_COLLAPSE
:
10471 for (i
= 0; i
< 3; i
++)
10472 WALK_SUBTREE (OMP_CLAUSE_OPERAND (*tp
, i
));
10473 WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp
));
10476 case OMP_CLAUSE_REDUCTION
:
10479 for (i
= 0; i
< 4; i
++)
10480 WALK_SUBTREE (OMP_CLAUSE_OPERAND (*tp
, i
));
10481 WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp
));
10485 gcc_unreachable ();
10493 /* TARGET_EXPRs are peculiar: operands 1 and 3 can be the same.
10494 But, we only want to walk once. */
10495 len
= (TREE_OPERAND (*tp
, 3) == TREE_OPERAND (*tp
, 1)) ? 2 : 3;
10496 for (i
= 0; i
< len
; ++i
)
10497 WALK_SUBTREE (TREE_OPERAND (*tp
, i
));
10498 WALK_SUBTREE_TAIL (TREE_OPERAND (*tp
, len
));
10502 /* If this is a TYPE_DECL, walk into the fields of the type that it's
10503 defining. We only want to walk into these fields of a type in this
10504 case and not in the general case of a mere reference to the type.
10506 The criterion is as follows: if the field can be an expression, it
10507 must be walked only here. This should be in keeping with the fields
10508 that are directly gimplified in gimplify_type_sizes in order for the
10509 mark/copy-if-shared/unmark machinery of the gimplifier to work with
10510 variable-sized types.
10512 Note that DECLs get walked as part of processing the BIND_EXPR. */
10513 if (TREE_CODE (DECL_EXPR_DECL (*tp
)) == TYPE_DECL
)
10515 tree
*type_p
= &TREE_TYPE (DECL_EXPR_DECL (*tp
));
10516 if (TREE_CODE (*type_p
) == ERROR_MARK
)
10519 /* Call the function for the type. See if it returns anything or
10520 doesn't want us to continue. If we are to continue, walk both
10521 the normal fields and those for the declaration case. */
10522 result
= (*func
) (type_p
, &walk_subtrees
, data
);
10523 if (result
|| !walk_subtrees
)
10526 result
= walk_type_fields (*type_p
, func
, data
, pset
, lh
);
10530 /* If this is a record type, also walk the fields. */
10531 if (RECORD_OR_UNION_TYPE_P (*type_p
))
10535 for (field
= TYPE_FIELDS (*type_p
); field
;
10536 field
= DECL_CHAIN (field
))
10538 /* We'd like to look at the type of the field, but we can
10539 easily get infinite recursion. So assume it's pointed
10540 to elsewhere in the tree. Also, ignore things that
10542 if (TREE_CODE (field
) != FIELD_DECL
)
10545 WALK_SUBTREE (DECL_FIELD_OFFSET (field
));
10546 WALK_SUBTREE (DECL_SIZE (field
));
10547 WALK_SUBTREE (DECL_SIZE_UNIT (field
));
10548 if (TREE_CODE (*type_p
) == QUAL_UNION_TYPE
)
10549 WALK_SUBTREE (DECL_QUALIFIER (field
));
10553 /* Same for scalar types. */
10554 else if (TREE_CODE (*type_p
) == BOOLEAN_TYPE
10555 || TREE_CODE (*type_p
) == ENUMERAL_TYPE
10556 || TREE_CODE (*type_p
) == INTEGER_TYPE
10557 || TREE_CODE (*type_p
) == FIXED_POINT_TYPE
10558 || TREE_CODE (*type_p
) == REAL_TYPE
)
10560 WALK_SUBTREE (TYPE_MIN_VALUE (*type_p
));
10561 WALK_SUBTREE (TYPE_MAX_VALUE (*type_p
));
10564 WALK_SUBTREE (TYPE_SIZE (*type_p
));
10565 WALK_SUBTREE_TAIL (TYPE_SIZE_UNIT (*type_p
));
10570 if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (code
)))
10574 /* Walk over all the sub-trees of this operand. */
10575 len
= TREE_OPERAND_LENGTH (*tp
);
10577 /* Go through the subtrees. We need to do this in forward order so
10578 that the scope of a FOR_EXPR is handled properly. */
10581 for (i
= 0; i
< len
- 1; ++i
)
10582 WALK_SUBTREE (TREE_OPERAND (*tp
, i
));
10583 WALK_SUBTREE_TAIL (TREE_OPERAND (*tp
, len
- 1));
10586 /* If this is a type, walk the needed fields in the type. */
10587 else if (TYPE_P (*tp
))
10588 return walk_type_fields (*tp
, func
, data
, pset
, lh
);
10592 /* We didn't find what we were looking for. */
10595 #undef WALK_SUBTREE_TAIL
10597 #undef WALK_SUBTREE
10599 /* Like walk_tree, but does not walk duplicate nodes more than once. */
10602 walk_tree_without_duplicates_1 (tree
*tp
, walk_tree_fn func
, void *data
,
10606 struct pointer_set_t
*pset
;
10608 pset
= pointer_set_create ();
10609 result
= walk_tree_1 (tp
, func
, data
, pset
, lh
);
10610 pointer_set_destroy (pset
);
10616 tree_block (tree t
)
10618 char const c
= TREE_CODE_CLASS (TREE_CODE (t
));
10620 if (IS_EXPR_CODE_CLASS (c
))
10621 return &t
->exp
.block
;
10622 gcc_unreachable ();
10626 /* Create a nameless artificial label and put it in the current
10627 function context. The label has a location of LOC. Returns the
10628 newly created label. */
10631 create_artificial_label (location_t loc
)
10633 tree lab
= build_decl (loc
,
10634 LABEL_DECL
, NULL_TREE
, void_type_node
);
10636 DECL_ARTIFICIAL (lab
) = 1;
10637 DECL_IGNORED_P (lab
) = 1;
10638 DECL_CONTEXT (lab
) = current_function_decl
;
10642 /* Given a tree, try to return a useful variable name that we can use
10643 to prefix a temporary that is being assigned the value of the tree.
10644 I.E. given <temp> = &A, return A. */
10649 tree stripped_decl
;
10652 STRIP_NOPS (stripped_decl
);
10653 if (DECL_P (stripped_decl
) && DECL_NAME (stripped_decl
))
10654 return IDENTIFIER_POINTER (DECL_NAME (stripped_decl
));
10657 switch (TREE_CODE (stripped_decl
))
10660 return get_name (TREE_OPERAND (stripped_decl
, 0));
10667 /* Return true if TYPE has a variable argument list. */
10670 stdarg_p (const_tree fntype
)
10672 function_args_iterator args_iter
;
10673 tree n
= NULL_TREE
, t
;
10678 FOREACH_FUNCTION_ARGS(fntype
, t
, args_iter
)
10683 return n
!= NULL_TREE
&& n
!= void_type_node
;
10686 /* Return true if TYPE has a prototype. */
10689 prototype_p (tree fntype
)
10693 gcc_assert (fntype
!= NULL_TREE
);
10695 t
= TYPE_ARG_TYPES (fntype
);
10696 return (t
!= NULL_TREE
);
10699 /* If BLOCK is inlined from an __attribute__((__artificial__))
10700 routine, return pointer to location from where it has been
10703 block_nonartificial_location (tree block
)
10705 location_t
*ret
= NULL
;
10707 while (block
&& TREE_CODE (block
) == BLOCK
10708 && BLOCK_ABSTRACT_ORIGIN (block
))
10710 tree ao
= BLOCK_ABSTRACT_ORIGIN (block
);
10712 while (TREE_CODE (ao
) == BLOCK
10713 && BLOCK_ABSTRACT_ORIGIN (ao
)
10714 && BLOCK_ABSTRACT_ORIGIN (ao
) != ao
)
10715 ao
= BLOCK_ABSTRACT_ORIGIN (ao
);
10717 if (TREE_CODE (ao
) == FUNCTION_DECL
)
10719 /* If AO is an artificial inline, point RET to the
10720 call site locus at which it has been inlined and continue
10721 the loop, in case AO's caller is also an artificial
10723 if (DECL_DECLARED_INLINE_P (ao
)
10724 && lookup_attribute ("artificial", DECL_ATTRIBUTES (ao
)))
10725 ret
= &BLOCK_SOURCE_LOCATION (block
);
10729 else if (TREE_CODE (ao
) != BLOCK
)
10732 block
= BLOCK_SUPERCONTEXT (block
);
10738 /* If EXP is inlined from an __attribute__((__artificial__))
10739 function, return the location of the original call expression. */
10742 tree_nonartificial_location (tree exp
)
10744 location_t
*loc
= block_nonartificial_location (TREE_BLOCK (exp
));
10749 return EXPR_LOCATION (exp
);
10753 /* These are the hash table functions for the hash table of OPTIMIZATION_NODEq
10756 /* Return the hash code code X, an OPTIMIZATION_NODE or TARGET_OPTION code. */
10759 cl_option_hash_hash (const void *x
)
10761 const_tree
const t
= (const_tree
) x
;
10765 hashval_t hash
= 0;
10767 if (TREE_CODE (t
) == OPTIMIZATION_NODE
)
10769 p
= (const char *)TREE_OPTIMIZATION (t
);
10770 len
= sizeof (struct cl_optimization
);
10773 else if (TREE_CODE (t
) == TARGET_OPTION_NODE
)
10775 p
= (const char *)TREE_TARGET_OPTION (t
);
10776 len
= sizeof (struct cl_target_option
);
10780 gcc_unreachable ();
10782 /* assume most opt flags are just 0/1, some are 2-3, and a few might be
10784 for (i
= 0; i
< len
; i
++)
10786 hash
= (hash
<< 4) ^ ((i
<< 2) | p
[i
]);
10791 /* Return nonzero if the value represented by *X (an OPTIMIZATION or
10792 TARGET_OPTION tree node) is the same as that given by *Y, which is the
10796 cl_option_hash_eq (const void *x
, const void *y
)
10798 const_tree
const xt
= (const_tree
) x
;
10799 const_tree
const yt
= (const_tree
) y
;
10804 if (TREE_CODE (xt
) != TREE_CODE (yt
))
10807 if (TREE_CODE (xt
) == OPTIMIZATION_NODE
)
10809 xp
= (const char *)TREE_OPTIMIZATION (xt
);
10810 yp
= (const char *)TREE_OPTIMIZATION (yt
);
10811 len
= sizeof (struct cl_optimization
);
10814 else if (TREE_CODE (xt
) == TARGET_OPTION_NODE
)
10816 xp
= (const char *)TREE_TARGET_OPTION (xt
);
10817 yp
= (const char *)TREE_TARGET_OPTION (yt
);
10818 len
= sizeof (struct cl_target_option
);
10822 gcc_unreachable ();
10824 return (memcmp (xp
, yp
, len
) == 0);
10827 /* Build an OPTIMIZATION_NODE based on the current options. */
10830 build_optimization_node (void)
10835 /* Use the cache of optimization nodes. */
10837 cl_optimization_save (TREE_OPTIMIZATION (cl_optimization_node
),
10840 slot
= htab_find_slot (cl_option_hash_table
, cl_optimization_node
, INSERT
);
10844 /* Insert this one into the hash table. */
10845 t
= cl_optimization_node
;
10848 /* Make a new node for next time round. */
10849 cl_optimization_node
= make_node (OPTIMIZATION_NODE
);
10855 /* Build a TARGET_OPTION_NODE based on the current options. */
10858 build_target_option_node (void)
10863 /* Use the cache of optimization nodes. */
10865 cl_target_option_save (TREE_TARGET_OPTION (cl_target_option_node
),
10868 slot
= htab_find_slot (cl_option_hash_table
, cl_target_option_node
, INSERT
);
10872 /* Insert this one into the hash table. */
10873 t
= cl_target_option_node
;
10876 /* Make a new node for next time round. */
10877 cl_target_option_node
= make_node (TARGET_OPTION_NODE
);
10883 /* Determine the "ultimate origin" of a block. The block may be an inlined
10884 instance of an inlined instance of a block which is local to an inline
10885 function, so we have to trace all of the way back through the origin chain
10886 to find out what sort of node actually served as the original seed for the
10890 block_ultimate_origin (const_tree block
)
10892 tree immediate_origin
= BLOCK_ABSTRACT_ORIGIN (block
);
10894 /* output_inline_function sets BLOCK_ABSTRACT_ORIGIN for all the
10895 nodes in the function to point to themselves; ignore that if
10896 we're trying to output the abstract instance of this function. */
10897 if (BLOCK_ABSTRACT (block
) && immediate_origin
== block
)
10900 if (immediate_origin
== NULL_TREE
)
10905 tree lookahead
= immediate_origin
;
10909 ret_val
= lookahead
;
10910 lookahead
= (TREE_CODE (ret_val
) == BLOCK
10911 ? BLOCK_ABSTRACT_ORIGIN (ret_val
) : NULL
);
10913 while (lookahead
!= NULL
&& lookahead
!= ret_val
);
10915 /* The block's abstract origin chain may not be the *ultimate* origin of
10916 the block. It could lead to a DECL that has an abstract origin set.
10917 If so, we want that DECL's abstract origin (which is what DECL_ORIGIN
10918 will give us if it has one). Note that DECL's abstract origins are
10919 supposed to be the most distant ancestor (or so decl_ultimate_origin
10920 claims), so we don't need to loop following the DECL origins. */
10921 if (DECL_P (ret_val
))
10922 return DECL_ORIGIN (ret_val
);
10928 /* Return true if T1 and T2 are equivalent lists. */
10931 list_equal_p (const_tree t1
, const_tree t2
)
10933 for (; t1
&& t2
; t1
= TREE_CHAIN (t1
) , t2
= TREE_CHAIN (t2
))
10934 if (TREE_VALUE (t1
) != TREE_VALUE (t2
))
10939 /* Return true iff conversion in EXP generates no instruction. Mark
10940 it inline so that we fully inline into the stripping functions even
10941 though we have two uses of this function. */
10944 tree_nop_conversion (const_tree exp
)
10946 tree outer_type
, inner_type
;
10948 if (!CONVERT_EXPR_P (exp
)
10949 && TREE_CODE (exp
) != NON_LVALUE_EXPR
)
10951 if (TREE_OPERAND (exp
, 0) == error_mark_node
)
10954 outer_type
= TREE_TYPE (exp
);
10955 inner_type
= TREE_TYPE (TREE_OPERAND (exp
, 0));
10960 /* Use precision rather then machine mode when we can, which gives
10961 the correct answer even for submode (bit-field) types. */
10962 if ((INTEGRAL_TYPE_P (outer_type
)
10963 || POINTER_TYPE_P (outer_type
)
10964 || TREE_CODE (outer_type
) == OFFSET_TYPE
)
10965 && (INTEGRAL_TYPE_P (inner_type
)
10966 || POINTER_TYPE_P (inner_type
)
10967 || TREE_CODE (inner_type
) == OFFSET_TYPE
))
10968 return TYPE_PRECISION (outer_type
) == TYPE_PRECISION (inner_type
);
10970 /* Otherwise fall back on comparing machine modes (e.g. for
10971 aggregate types, floats). */
10972 return TYPE_MODE (outer_type
) == TYPE_MODE (inner_type
);
10975 /* Return true iff conversion in EXP generates no instruction. Don't
10976 consider conversions changing the signedness. */
10979 tree_sign_nop_conversion (const_tree exp
)
10981 tree outer_type
, inner_type
;
10983 if (!tree_nop_conversion (exp
))
10986 outer_type
= TREE_TYPE (exp
);
10987 inner_type
= TREE_TYPE (TREE_OPERAND (exp
, 0));
10989 return (TYPE_UNSIGNED (outer_type
) == TYPE_UNSIGNED (inner_type
)
10990 && POINTER_TYPE_P (outer_type
) == POINTER_TYPE_P (inner_type
));
10993 /* Strip conversions from EXP according to tree_nop_conversion and
10994 return the resulting expression. */
10997 tree_strip_nop_conversions (tree exp
)
10999 while (tree_nop_conversion (exp
))
11000 exp
= TREE_OPERAND (exp
, 0);
11004 /* Strip conversions from EXP according to tree_sign_nop_conversion
11005 and return the resulting expression. */
11008 tree_strip_sign_nop_conversions (tree exp
)
11010 while (tree_sign_nop_conversion (exp
))
11011 exp
= TREE_OPERAND (exp
, 0);
11015 static GTY(()) tree gcc_eh_personality_decl
;
11017 /* Return the GCC personality function decl. */
11020 lhd_gcc_personality (void)
11022 if (!gcc_eh_personality_decl
)
11023 gcc_eh_personality_decl
= build_personality_function ("gcc");
11024 return gcc_eh_personality_decl
;
11027 /* Try to find a base info of BINFO that would have its field decl at offset
11028 OFFSET within the BINFO type and which is of EXPECTED_TYPE. If it can be
11029 found, return, otherwise return NULL_TREE. */
11032 get_binfo_at_offset (tree binfo
, HOST_WIDE_INT offset
, tree expected_type
)
11034 tree type
= BINFO_TYPE (binfo
);
11038 HOST_WIDE_INT pos
, size
;
11042 if (TYPE_MAIN_VARIANT (type
) == TYPE_MAIN_VARIANT (expected_type
))
11047 for (fld
= TYPE_FIELDS (type
); fld
; fld
= DECL_CHAIN (fld
))
11049 if (TREE_CODE (fld
) != FIELD_DECL
)
11052 pos
= int_bit_position (fld
);
11053 size
= tree_low_cst (DECL_SIZE (fld
), 1);
11054 if (pos
<= offset
&& (pos
+ size
) > offset
)
11057 if (!fld
|| TREE_CODE (TREE_TYPE (fld
)) != RECORD_TYPE
)
11060 if (!DECL_ARTIFICIAL (fld
))
11062 binfo
= TYPE_BINFO (TREE_TYPE (fld
));
11066 /* Offset 0 indicates the primary base, whose vtable contents are
11067 represented in the binfo for the derived class. */
11068 else if (offset
!= 0)
11070 tree base_binfo
, found_binfo
= NULL_TREE
;
11071 for (i
= 0; BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
11072 if (TREE_TYPE (base_binfo
) == TREE_TYPE (fld
))
11074 found_binfo
= base_binfo
;
11079 binfo
= found_binfo
;
11082 type
= TREE_TYPE (fld
);
11087 /* Returns true if X is a typedef decl. */
11090 is_typedef_decl (tree x
)
11092 return (x
&& TREE_CODE (x
) == TYPE_DECL
11093 && DECL_ORIGINAL_TYPE (x
) != NULL_TREE
);
11096 /* Returns true iff TYPE is a type variant created for a typedef. */
11099 typedef_variant_p (tree type
)
11101 return is_typedef_decl (TYPE_NAME (type
));
11104 /* Warn about a use of an identifier which was marked deprecated. */
11106 warn_deprecated_use (tree node
, tree attr
)
11110 if (node
== 0 || !warn_deprecated_decl
)
11116 attr
= DECL_ATTRIBUTES (node
);
11117 else if (TYPE_P (node
))
11119 tree decl
= TYPE_STUB_DECL (node
);
11121 attr
= lookup_attribute ("deprecated",
11122 TYPE_ATTRIBUTES (TREE_TYPE (decl
)));
11127 attr
= lookup_attribute ("deprecated", attr
);
11130 msg
= TREE_STRING_POINTER (TREE_VALUE (TREE_VALUE (attr
)));
11136 expanded_location xloc
= expand_location (DECL_SOURCE_LOCATION (node
));
11138 warning (OPT_Wdeprecated_declarations
,
11139 "%qD is deprecated (declared at %s:%d): %s",
11140 node
, xloc
.file
, xloc
.line
, msg
);
11142 warning (OPT_Wdeprecated_declarations
,
11143 "%qD is deprecated (declared at %s:%d)",
11144 node
, xloc
.file
, xloc
.line
);
11146 else if (TYPE_P (node
))
11148 tree what
= NULL_TREE
;
11149 tree decl
= TYPE_STUB_DECL (node
);
11151 if (TYPE_NAME (node
))
11153 if (TREE_CODE (TYPE_NAME (node
)) == IDENTIFIER_NODE
)
11154 what
= TYPE_NAME (node
);
11155 else if (TREE_CODE (TYPE_NAME (node
)) == TYPE_DECL
11156 && DECL_NAME (TYPE_NAME (node
)))
11157 what
= DECL_NAME (TYPE_NAME (node
));
11162 expanded_location xloc
11163 = expand_location (DECL_SOURCE_LOCATION (decl
));
11167 warning (OPT_Wdeprecated_declarations
,
11168 "%qE is deprecated (declared at %s:%d): %s",
11169 what
, xloc
.file
, xloc
.line
, msg
);
11171 warning (OPT_Wdeprecated_declarations
,
11172 "%qE is deprecated (declared at %s:%d)", what
,
11173 xloc
.file
, xloc
.line
);
11178 warning (OPT_Wdeprecated_declarations
,
11179 "type is deprecated (declared at %s:%d): %s",
11180 xloc
.file
, xloc
.line
, msg
);
11182 warning (OPT_Wdeprecated_declarations
,
11183 "type is deprecated (declared at %s:%d)",
11184 xloc
.file
, xloc
.line
);
11192 warning (OPT_Wdeprecated_declarations
, "%qE is deprecated: %s",
11195 warning (OPT_Wdeprecated_declarations
, "%qE is deprecated", what
);
11200 warning (OPT_Wdeprecated_declarations
, "type is deprecated: %s",
11203 warning (OPT_Wdeprecated_declarations
, "type is deprecated");
11209 #include "gt-tree.h"