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 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"
46 #include "langhooks.h"
47 #include "tree-inline.h"
48 #include "tree-iterator.h"
49 #include "basic-block.h"
50 #include "tree-flow.h"
52 #include "pointer-set.h"
53 #include "tree-pass.h"
54 #include "langhooks-def.h"
55 #include "diagnostic.h"
56 #include "tree-diagnostic.h"
57 #include "tree-pretty-print.h"
64 /* Tree code classes. */
66 #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) TYPE,
67 #define END_OF_BASE_TREE_CODES tcc_exceptional,
69 const enum tree_code_class tree_code_type[] = {
70 #include "all-tree.def"
74 #undef END_OF_BASE_TREE_CODES
76 /* Table indexed by tree code giving number of expression
77 operands beyond the fixed part of the node structure.
78 Not used for types or decls. */
80 #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) LENGTH,
81 #define END_OF_BASE_TREE_CODES 0,
83 const unsigned char tree_code_length[] = {
84 #include "all-tree.def"
88 #undef END_OF_BASE_TREE_CODES
90 /* Names of tree components.
91 Used for printing out the tree and error messages. */
92 #define DEFTREECODE(SYM, NAME, TYPE, LEN) NAME,
93 #define END_OF_BASE_TREE_CODES "@dummy",
95 const char *const tree_code_name[] = {
96 #include "all-tree.def"
100 #undef END_OF_BASE_TREE_CODES
102 /* Each tree code class has an associated string representation.
103 These must correspond to the tree_code_class entries. */
105 const char *const tree_code_class_strings[] =
120 /* obstack.[ch] explicitly declined to prototype this. */
121 extern int _obstack_allocated_p (struct obstack *h, void *obj);
123 #ifdef GATHER_STATISTICS
124 /* Statistics-gathering stuff. */
126 int tree_node_counts[(int) all_kinds];
127 int tree_node_sizes[(int) all_kinds];
129 /* Keep in sync with tree.h:enum tree_node_kind. */
130 static const char * const tree_node_kind_names[] = {
148 #endif /* GATHER_STATISTICS */
150 /* Unique id for next decl created. */
151 static GTY(()) int next_decl_uid;
152 /* Unique id for next type created. */
153 static GTY(()) int next_type_uid = 1;
154 /* Unique id for next debug decl created. Use negative numbers,
155 to catch erroneous uses. */
156 static GTY(()) int next_debug_decl_uid;
158 /* Since we cannot rehash a type after it is in the table, we have to
159 keep the hash code. */
161 struct GTY(()) type_hash {
166 /* Initial size of the hash table (rounded to next prime). */
167 #define TYPE_HASH_INITIAL_SIZE 1000
169 /* Now here is the hash table. When recording a type, it is added to
170 the slot whose index is the hash code. Note that the hash table is
171 used for several kinds of types (function types, array types and
172 array index range types, for now). While all these live in the
173 same table, they are completely independent, and the hash code is
174 computed differently for each of these. */
176 static GTY ((if_marked ("type_hash_marked_p"), param_is (struct type_hash)))
177 htab_t type_hash_table;
179 /* Hash table and temporary node for larger integer const values. */
180 static GTY (()) tree int_cst_node;
181 static GTY ((if_marked ("ggc_marked_p"), param_is (union tree_node)))
182 htab_t int_cst_hash_table;
184 /* Hash table for optimization flags and target option flags. Use the same
185 hash table for both sets of options. Nodes for building the current
186 optimization and target option nodes. The assumption is most of the time
187 the options created will already be in the hash table, so we avoid
188 allocating and freeing up a node repeatably. */
189 static GTY (()) tree cl_optimization_node;
190 static GTY (()) tree cl_target_option_node;
191 static GTY ((if_marked ("ggc_marked_p"), param_is (union tree_node)))
192 htab_t cl_option_hash_table;
194 /* General tree->tree mapping structure for use in hash tables. */
197 static GTY ((if_marked ("tree_decl_map_marked_p"), param_is (struct tree_decl_map)))
198 htab_t debug_expr_for_decl;
200 static GTY ((if_marked ("tree_decl_map_marked_p"), param_is (struct tree_decl_map)))
201 htab_t value_expr_for_decl;
203 static GTY ((if_marked ("tree_priority_map_marked_p"),
204 param_is (struct tree_priority_map)))
205 htab_t init_priority_for_decl;
207 static void set_type_quals (tree, int);
208 static int type_hash_eq (const void *, const void *);
209 static hashval_t type_hash_hash (const void *);
210 static hashval_t int_cst_hash_hash (const void *);
211 static int int_cst_hash_eq (const void *, const void *);
212 static hashval_t cl_option_hash_hash (const void *);
213 static int cl_option_hash_eq (const void *, const void *);
214 static void print_type_hash_statistics (void);
215 static void print_debug_expr_statistics (void);
216 static void print_value_expr_statistics (void);
217 static int type_hash_marked_p (const void *);
218 static unsigned int type_hash_list (const_tree, hashval_t);
219 static unsigned int attribute_hash_list (const_tree, hashval_t);
221 tree global_trees[TI_MAX];
222 tree integer_types[itk_none];
224 unsigned char tree_contains_struct[MAX_TREE_CODES][64];
226 /* Number of operands for each OpenMP clause. */
227 unsigned const char omp_clause_num_ops[] =
229 0, /* OMP_CLAUSE_ERROR */
230 1, /* OMP_CLAUSE_PRIVATE */
231 1, /* OMP_CLAUSE_SHARED */
232 1, /* OMP_CLAUSE_FIRSTPRIVATE */
233 2, /* OMP_CLAUSE_LASTPRIVATE */
234 4, /* OMP_CLAUSE_REDUCTION */
235 1, /* OMP_CLAUSE_COPYIN */
236 1, /* OMP_CLAUSE_COPYPRIVATE */
237 1, /* OMP_CLAUSE_IF */
238 1, /* OMP_CLAUSE_NUM_THREADS */
239 1, /* OMP_CLAUSE_SCHEDULE */
240 0, /* OMP_CLAUSE_NOWAIT */
241 0, /* OMP_CLAUSE_ORDERED */
242 0, /* OMP_CLAUSE_DEFAULT */
243 3, /* OMP_CLAUSE_COLLAPSE */
244 0 /* OMP_CLAUSE_UNTIED */
247 const char * const omp_clause_code_name[] =
268 /* Return the tree node structure used by tree code CODE. */
270 static inline enum tree_node_structure_enum
271 tree_node_structure_for_code (enum tree_code code)
273 switch (TREE_CODE_CLASS (code))
275 case tcc_declaration:
280 return TS_FIELD_DECL;
286 return TS_LABEL_DECL;
288 return TS_RESULT_DECL;
289 case DEBUG_EXPR_DECL:
292 return TS_CONST_DECL;
296 return TS_FUNCTION_DECL;
297 case TRANSLATION_UNIT_DECL:
298 return TS_TRANSLATION_UNIT_DECL;
300 return TS_DECL_NON_COMMON;
313 default: /* tcc_constant and tcc_exceptional */
318 /* tcc_constant cases. */
319 case INTEGER_CST: return TS_INT_CST;
320 case REAL_CST: return TS_REAL_CST;
321 case FIXED_CST: return TS_FIXED_CST;
322 case COMPLEX_CST: return TS_COMPLEX;
323 case VECTOR_CST: return TS_VECTOR;
324 case STRING_CST: return TS_STRING;
325 /* tcc_exceptional cases. */
326 case ERROR_MARK: return TS_COMMON;
327 case IDENTIFIER_NODE: return TS_IDENTIFIER;
328 case TREE_LIST: return TS_LIST;
329 case TREE_VEC: return TS_VEC;
330 case SSA_NAME: return TS_SSA_NAME;
331 case PLACEHOLDER_EXPR: return TS_COMMON;
332 case STATEMENT_LIST: return TS_STATEMENT_LIST;
333 case BLOCK: return TS_BLOCK;
334 case CONSTRUCTOR: return TS_CONSTRUCTOR;
335 case TREE_BINFO: return TS_BINFO;
336 case OMP_CLAUSE: return TS_OMP_CLAUSE;
337 case OPTIMIZATION_NODE: return TS_OPTIMIZATION;
338 case TARGET_OPTION_NODE: return TS_TARGET_OPTION;
346 /* Initialize tree_contains_struct to describe the hierarchy of tree
350 initialize_tree_contains_struct (void)
354 #define MARK_TS_BASE(C) \
356 tree_contains_struct[C][TS_BASE] = 1; \
359 #define MARK_TS_COMMON(C) \
362 tree_contains_struct[C][TS_COMMON] = 1; \
365 #define MARK_TS_DECL_MINIMAL(C) \
367 MARK_TS_COMMON (C); \
368 tree_contains_struct[C][TS_DECL_MINIMAL] = 1; \
371 #define MARK_TS_DECL_COMMON(C) \
373 MARK_TS_DECL_MINIMAL (C); \
374 tree_contains_struct[C][TS_DECL_COMMON] = 1; \
377 #define MARK_TS_DECL_WRTL(C) \
379 MARK_TS_DECL_COMMON (C); \
380 tree_contains_struct[C][TS_DECL_WRTL] = 1; \
383 #define MARK_TS_DECL_WITH_VIS(C) \
385 MARK_TS_DECL_WRTL (C); \
386 tree_contains_struct[C][TS_DECL_WITH_VIS] = 1; \
389 #define MARK_TS_DECL_NON_COMMON(C) \
391 MARK_TS_DECL_WITH_VIS (C); \
392 tree_contains_struct[C][TS_DECL_NON_COMMON] = 1; \
395 for (i = ERROR_MARK; i < LAST_AND_UNUSED_TREE_CODE; i++)
398 enum tree_node_structure_enum ts_code;
400 code = (enum tree_code) i;
401 ts_code = tree_node_structure_for_code (code);
403 /* Mark the TS structure itself. */
404 tree_contains_struct[code][ts_code] = 1;
406 /* Mark all the structures that TS is derived from. */
420 case TS_DECL_MINIMAL:
428 case TS_STATEMENT_LIST:
431 case TS_OPTIMIZATION:
432 case TS_TARGET_OPTION:
433 MARK_TS_COMMON (code);
437 MARK_TS_DECL_MINIMAL (code);
441 MARK_TS_DECL_COMMON (code);
444 case TS_DECL_NON_COMMON:
445 MARK_TS_DECL_WITH_VIS (code);
448 case TS_DECL_WITH_VIS:
453 MARK_TS_DECL_WRTL (code);
457 MARK_TS_DECL_COMMON (code);
461 MARK_TS_DECL_WITH_VIS (code);
465 case TS_FUNCTION_DECL:
466 MARK_TS_DECL_NON_COMMON (code);
469 case TS_TRANSLATION_UNIT_DECL:
470 MARK_TS_DECL_COMMON (code);
478 /* Basic consistency checks for attributes used in fold. */
479 gcc_assert (tree_contains_struct[FUNCTION_DECL][TS_DECL_NON_COMMON]);
480 gcc_assert (tree_contains_struct[TYPE_DECL][TS_DECL_NON_COMMON]);
481 gcc_assert (tree_contains_struct[CONST_DECL][TS_DECL_COMMON]);
482 gcc_assert (tree_contains_struct[VAR_DECL][TS_DECL_COMMON]);
483 gcc_assert (tree_contains_struct[PARM_DECL][TS_DECL_COMMON]);
484 gcc_assert (tree_contains_struct[RESULT_DECL][TS_DECL_COMMON]);
485 gcc_assert (tree_contains_struct[FUNCTION_DECL][TS_DECL_COMMON]);
486 gcc_assert (tree_contains_struct[TYPE_DECL][TS_DECL_COMMON]);
487 gcc_assert (tree_contains_struct[TRANSLATION_UNIT_DECL][TS_DECL_COMMON]);
488 gcc_assert (tree_contains_struct[LABEL_DECL][TS_DECL_COMMON]);
489 gcc_assert (tree_contains_struct[FIELD_DECL][TS_DECL_COMMON]);
490 gcc_assert (tree_contains_struct[CONST_DECL][TS_DECL_WRTL]);
491 gcc_assert (tree_contains_struct[VAR_DECL][TS_DECL_WRTL]);
492 gcc_assert (tree_contains_struct[PARM_DECL][TS_DECL_WRTL]);
493 gcc_assert (tree_contains_struct[RESULT_DECL][TS_DECL_WRTL]);
494 gcc_assert (tree_contains_struct[FUNCTION_DECL][TS_DECL_WRTL]);
495 gcc_assert (tree_contains_struct[LABEL_DECL][TS_DECL_WRTL]);
496 gcc_assert (tree_contains_struct[CONST_DECL][TS_DECL_MINIMAL]);
497 gcc_assert (tree_contains_struct[VAR_DECL][TS_DECL_MINIMAL]);
498 gcc_assert (tree_contains_struct[PARM_DECL][TS_DECL_MINIMAL]);
499 gcc_assert (tree_contains_struct[RESULT_DECL][TS_DECL_MINIMAL]);
500 gcc_assert (tree_contains_struct[FUNCTION_DECL][TS_DECL_MINIMAL]);
501 gcc_assert (tree_contains_struct[TYPE_DECL][TS_DECL_MINIMAL]);
502 gcc_assert (tree_contains_struct[TRANSLATION_UNIT_DECL][TS_DECL_MINIMAL]);
503 gcc_assert (tree_contains_struct[LABEL_DECL][TS_DECL_MINIMAL]);
504 gcc_assert (tree_contains_struct[FIELD_DECL][TS_DECL_MINIMAL]);
505 gcc_assert (tree_contains_struct[VAR_DECL][TS_DECL_WITH_VIS]);
506 gcc_assert (tree_contains_struct[FUNCTION_DECL][TS_DECL_WITH_VIS]);
507 gcc_assert (tree_contains_struct[TYPE_DECL][TS_DECL_WITH_VIS]);
508 gcc_assert (tree_contains_struct[VAR_DECL][TS_VAR_DECL]);
509 gcc_assert (tree_contains_struct[FIELD_DECL][TS_FIELD_DECL]);
510 gcc_assert (tree_contains_struct[PARM_DECL][TS_PARM_DECL]);
511 gcc_assert (tree_contains_struct[LABEL_DECL][TS_LABEL_DECL]);
512 gcc_assert (tree_contains_struct[RESULT_DECL][TS_RESULT_DECL]);
513 gcc_assert (tree_contains_struct[CONST_DECL][TS_CONST_DECL]);
514 gcc_assert (tree_contains_struct[TYPE_DECL][TS_TYPE_DECL]);
515 gcc_assert (tree_contains_struct[FUNCTION_DECL][TS_FUNCTION_DECL]);
516 gcc_assert (tree_contains_struct[IMPORTED_DECL][TS_DECL_MINIMAL]);
517 gcc_assert (tree_contains_struct[IMPORTED_DECL][TS_DECL_COMMON]);
520 #undef MARK_TS_COMMON
521 #undef MARK_TS_DECL_MINIMAL
522 #undef MARK_TS_DECL_COMMON
523 #undef MARK_TS_DECL_WRTL
524 #undef MARK_TS_DECL_WITH_VIS
525 #undef MARK_TS_DECL_NON_COMMON
534 /* Initialize the hash table of types. */
535 type_hash_table = htab_create_ggc (TYPE_HASH_INITIAL_SIZE, type_hash_hash,
538 debug_expr_for_decl = htab_create_ggc (512, tree_decl_map_hash,
539 tree_decl_map_eq, 0);
541 value_expr_for_decl = htab_create_ggc (512, tree_decl_map_hash,
542 tree_decl_map_eq, 0);
543 init_priority_for_decl = htab_create_ggc (512, tree_priority_map_hash,
544 tree_priority_map_eq, 0);
546 int_cst_hash_table = htab_create_ggc (1024, int_cst_hash_hash,
547 int_cst_hash_eq, NULL);
549 int_cst_node = make_node (INTEGER_CST);
551 cl_option_hash_table = htab_create_ggc (64, cl_option_hash_hash,
552 cl_option_hash_eq, NULL);
554 cl_optimization_node = make_node (OPTIMIZATION_NODE);
555 cl_target_option_node = make_node (TARGET_OPTION_NODE);
557 /* Initialize the tree_contains_struct array. */
558 initialize_tree_contains_struct ();
559 lang_hooks.init_ts ();
563 /* The name of the object as the assembler will see it (but before any
564 translations made by ASM_OUTPUT_LABELREF). Often this is the same
565 as DECL_NAME. It is an IDENTIFIER_NODE. */
567 decl_assembler_name (tree decl)
569 if (!DECL_ASSEMBLER_NAME_SET_P (decl))
570 lang_hooks.set_decl_assembler_name (decl);
571 return DECL_WITH_VIS_CHECK (decl)->decl_with_vis.assembler_name;
574 /* Compare ASMNAME with the DECL_ASSEMBLER_NAME of DECL. */
577 decl_assembler_name_equal (tree decl, const_tree asmname)
579 tree decl_asmname = DECL_ASSEMBLER_NAME (decl);
580 const char *decl_str;
581 const char *asmname_str;
584 if (decl_asmname == asmname)
587 decl_str = IDENTIFIER_POINTER (decl_asmname);
588 asmname_str = IDENTIFIER_POINTER (asmname);
591 /* If the target assembler name was set by the user, things are trickier.
592 We have a leading '*' to begin with. After that, it's arguable what
593 is the correct thing to do with -fleading-underscore. Arguably, we've
594 historically been doing the wrong thing in assemble_alias by always
595 printing the leading underscore. Since we're not changing that, make
596 sure user_label_prefix follows the '*' before matching. */
597 if (decl_str[0] == '*')
599 size_t ulp_len = strlen (user_label_prefix);
605 else if (strncmp (decl_str, user_label_prefix, ulp_len) == 0)
606 decl_str += ulp_len, test=true;
610 if (asmname_str[0] == '*')
612 size_t ulp_len = strlen (user_label_prefix);
618 else if (strncmp (asmname_str, user_label_prefix, ulp_len) == 0)
619 asmname_str += ulp_len, test=true;
626 return strcmp (decl_str, asmname_str) == 0;
629 /* Hash asmnames ignoring the user specified marks. */
632 decl_assembler_name_hash (const_tree asmname)
634 if (IDENTIFIER_POINTER (asmname)[0] == '*')
636 const char *decl_str = IDENTIFIER_POINTER (asmname) + 1;
637 size_t ulp_len = strlen (user_label_prefix);
641 else if (strncmp (decl_str, user_label_prefix, ulp_len) == 0)
644 return htab_hash_string (decl_str);
647 return htab_hash_string (IDENTIFIER_POINTER (asmname));
650 /* Compute the number of bytes occupied by a tree with code CODE.
651 This function cannot be used for nodes that have variable sizes,
652 including TREE_VEC, STRING_CST, and CALL_EXPR. */
654 tree_code_size (enum tree_code code)
656 switch (TREE_CODE_CLASS (code))
658 case tcc_declaration: /* A decl node */
663 return sizeof (struct tree_field_decl);
665 return sizeof (struct tree_parm_decl);
667 return sizeof (struct tree_var_decl);
669 return sizeof (struct tree_label_decl);
671 return sizeof (struct tree_result_decl);
673 return sizeof (struct tree_const_decl);
675 return sizeof (struct tree_type_decl);
677 return sizeof (struct tree_function_decl);
678 case DEBUG_EXPR_DECL:
679 return sizeof (struct tree_decl_with_rtl);
681 return sizeof (struct tree_decl_non_common);
685 case tcc_type: /* a type node */
686 return sizeof (struct tree_type);
688 case tcc_reference: /* a reference */
689 case tcc_expression: /* an expression */
690 case tcc_statement: /* an expression with side effects */
691 case tcc_comparison: /* a comparison expression */
692 case tcc_unary: /* a unary arithmetic expression */
693 case tcc_binary: /* a binary arithmetic expression */
694 return (sizeof (struct tree_exp)
695 + (TREE_CODE_LENGTH (code) - 1) * sizeof (tree));
697 case tcc_constant: /* a constant */
700 case INTEGER_CST: return sizeof (struct tree_int_cst);
701 case REAL_CST: return sizeof (struct tree_real_cst);
702 case FIXED_CST: return sizeof (struct tree_fixed_cst);
703 case COMPLEX_CST: return sizeof (struct tree_complex);
704 case VECTOR_CST: return sizeof (struct tree_vector);
705 case STRING_CST: gcc_unreachable ();
707 return lang_hooks.tree_size (code);
710 case tcc_exceptional: /* something random, like an identifier. */
713 case IDENTIFIER_NODE: return lang_hooks.identifier_size;
714 case TREE_LIST: return sizeof (struct tree_list);
717 case PLACEHOLDER_EXPR: return sizeof (struct tree_common);
720 case OMP_CLAUSE: gcc_unreachable ();
722 case SSA_NAME: return sizeof (struct tree_ssa_name);
724 case STATEMENT_LIST: return sizeof (struct tree_statement_list);
725 case BLOCK: return sizeof (struct tree_block);
726 case CONSTRUCTOR: return sizeof (struct tree_constructor);
727 case OPTIMIZATION_NODE: return sizeof (struct tree_optimization_option);
728 case TARGET_OPTION_NODE: return sizeof (struct tree_target_option);
731 return lang_hooks.tree_size (code);
739 /* Compute the number of bytes occupied by NODE. This routine only
740 looks at TREE_CODE, except for those nodes that have variable sizes. */
742 tree_size (const_tree node)
744 const enum tree_code code = TREE_CODE (node);
748 return (offsetof (struct tree_binfo, base_binfos)
749 + VEC_embedded_size (tree, BINFO_N_BASE_BINFOS (node)));
752 return (sizeof (struct tree_vec)
753 + (TREE_VEC_LENGTH (node) - 1) * sizeof (tree));
756 return TREE_STRING_LENGTH (node) + offsetof (struct tree_string, str) + 1;
759 return (sizeof (struct tree_omp_clause)
760 + (omp_clause_num_ops[OMP_CLAUSE_CODE (node)] - 1)
764 if (TREE_CODE_CLASS (code) == tcc_vl_exp)
765 return (sizeof (struct tree_exp)
766 + (VL_EXP_OPERAND_LENGTH (node) - 1) * sizeof (tree));
768 return tree_code_size (code);
772 /* Return a newly allocated node of code CODE. For decl and type
773 nodes, some other fields are initialized. The rest of the node is
774 initialized to zero. This function cannot be used for TREE_VEC or
775 OMP_CLAUSE nodes, which is enforced by asserts in tree_code_size.
777 Achoo! I got a code in the node. */
780 make_node_stat (enum tree_code code MEM_STAT_DECL)
783 enum tree_code_class type = TREE_CODE_CLASS (code);
784 size_t length = tree_code_size (code);
785 #ifdef GATHER_STATISTICS
790 case tcc_declaration: /* A decl node */
794 case tcc_type: /* a type node */
798 case tcc_statement: /* an expression with side effects */
802 case tcc_reference: /* a reference */
806 case tcc_expression: /* an expression */
807 case tcc_comparison: /* a comparison expression */
808 case tcc_unary: /* a unary arithmetic expression */
809 case tcc_binary: /* a binary arithmetic expression */
813 case tcc_constant: /* a constant */
817 case tcc_exceptional: /* something random, like an identifier. */
820 case IDENTIFIER_NODE:
833 kind = ssa_name_kind;
854 tree_node_counts[(int) kind]++;
855 tree_node_sizes[(int) kind] += length;
858 t = ggc_alloc_zone_cleared_tree_node_stat (
859 (code == IDENTIFIER_NODE) ? &tree_id_zone : &tree_zone,
860 length PASS_MEM_STAT);
861 TREE_SET_CODE (t, code);
866 TREE_SIDE_EFFECTS (t) = 1;
869 case tcc_declaration:
870 if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
872 if (code == FUNCTION_DECL)
874 DECL_ALIGN (t) = FUNCTION_BOUNDARY;
875 DECL_MODE (t) = FUNCTION_MODE;
880 DECL_SOURCE_LOCATION (t) = input_location;
881 if (TREE_CODE (t) == DEBUG_EXPR_DECL)
882 DECL_UID (t) = --next_debug_decl_uid;
885 DECL_UID (t) = next_decl_uid++;
886 SET_DECL_PT_UID (t, -1);
888 if (TREE_CODE (t) == LABEL_DECL)
889 LABEL_DECL_UID (t) = -1;
894 TYPE_UID (t) = next_type_uid++;
895 TYPE_ALIGN (t) = BITS_PER_UNIT;
896 TYPE_USER_ALIGN (t) = 0;
897 TYPE_MAIN_VARIANT (t) = t;
898 TYPE_CANONICAL (t) = t;
900 /* Default to no attributes for type, but let target change that. */
901 TYPE_ATTRIBUTES (t) = NULL_TREE;
902 targetm.set_default_type_attributes (t);
904 /* We have not yet computed the alias set for this type. */
905 TYPE_ALIAS_SET (t) = -1;
909 TREE_CONSTANT (t) = 1;
918 case PREDECREMENT_EXPR:
919 case PREINCREMENT_EXPR:
920 case POSTDECREMENT_EXPR:
921 case POSTINCREMENT_EXPR:
922 /* All of these have side-effects, no matter what their
924 TREE_SIDE_EFFECTS (t) = 1;
933 /* Other classes need no special treatment. */
940 /* Return a new node with the same contents as NODE except that its
941 TREE_CHAIN is zero and it has a fresh uid. */
944 copy_node_stat (tree node MEM_STAT_DECL)
947 enum tree_code code = TREE_CODE (node);
950 gcc_assert (code != STATEMENT_LIST);
952 length = tree_size (node);
953 t = ggc_alloc_zone_tree_node_stat (&tree_zone, length PASS_MEM_STAT);
954 memcpy (t, node, length);
957 TREE_ASM_WRITTEN (t) = 0;
958 TREE_VISITED (t) = 0;
959 if (code == VAR_DECL || code == PARM_DECL || code == RESULT_DECL)
960 *DECL_VAR_ANN_PTR (t) = 0;
962 if (TREE_CODE_CLASS (code) == tcc_declaration)
964 if (code == DEBUG_EXPR_DECL)
965 DECL_UID (t) = --next_debug_decl_uid;
968 DECL_UID (t) = next_decl_uid++;
969 if (DECL_PT_UID_SET_P (node))
970 SET_DECL_PT_UID (t, DECL_PT_UID (node));
972 if ((TREE_CODE (node) == PARM_DECL || TREE_CODE (node) == VAR_DECL)
973 && DECL_HAS_VALUE_EXPR_P (node))
975 SET_DECL_VALUE_EXPR (t, DECL_VALUE_EXPR (node));
976 DECL_HAS_VALUE_EXPR_P (t) = 1;
978 if (TREE_CODE (node) == VAR_DECL && DECL_HAS_INIT_PRIORITY_P (node))
980 SET_DECL_INIT_PRIORITY (t, DECL_INIT_PRIORITY (node));
981 DECL_HAS_INIT_PRIORITY_P (t) = 1;
984 else if (TREE_CODE_CLASS (code) == tcc_type)
986 TYPE_UID (t) = next_type_uid++;
987 /* The following is so that the debug code for
988 the copy is different from the original type.
989 The two statements usually duplicate each other
990 (because they clear fields of the same union),
991 but the optimizer should catch that. */
992 TYPE_SYMTAB_POINTER (t) = 0;
993 TYPE_SYMTAB_ADDRESS (t) = 0;
995 /* Do not copy the values cache. */
996 if (TYPE_CACHED_VALUES_P(t))
998 TYPE_CACHED_VALUES_P (t) = 0;
999 TYPE_CACHED_VALUES (t) = NULL_TREE;
1006 /* Return a copy of a chain of nodes, chained through the TREE_CHAIN field.
1007 For example, this can copy a list made of TREE_LIST nodes. */
1010 copy_list (tree list)
1018 head = prev = copy_node (list);
1019 next = TREE_CHAIN (list);
1022 TREE_CHAIN (prev) = copy_node (next);
1023 prev = TREE_CHAIN (prev);
1024 next = TREE_CHAIN (next);
1030 /* Create an INT_CST node with a LOW value sign extended. */
1033 build_int_cst (tree type, HOST_WIDE_INT low)
1035 /* Support legacy code. */
1037 type = integer_type_node;
1039 return build_int_cst_wide (type, low, low < 0 ? -1 : 0);
1042 /* Create an INT_CST node with a LOW value in TYPE. The value is sign extended
1043 if it is negative. This function is similar to build_int_cst, but
1044 the extra bits outside of the type precision are cleared. Constants
1045 with these extra bits may confuse the fold so that it detects overflows
1046 even in cases when they do not occur, and in general should be avoided.
1047 We cannot however make this a default behavior of build_int_cst without
1048 more intrusive changes, since there are parts of gcc that rely on the extra
1049 precision of the integer constants. */
1052 build_int_cst_type (tree type, HOST_WIDE_INT low)
1056 return double_int_to_tree (type, shwi_to_double_int (low));
1059 /* Constructs tree in type TYPE from with value given by CST. Signedness
1060 of CST is assumed to be the same as the signedness of TYPE. */
1063 double_int_to_tree (tree type, double_int cst)
1065 /* Size types *are* sign extended. */
1066 bool sign_extended_type = (!TYPE_UNSIGNED (type)
1067 || (TREE_CODE (type) == INTEGER_TYPE
1068 && TYPE_IS_SIZETYPE (type)));
1070 cst = double_int_ext (cst, TYPE_PRECISION (type), !sign_extended_type);
1072 return build_int_cst_wide (type, cst.low, cst.high);
1075 /* Returns true if CST fits into range of TYPE. Signedness of CST is assumed
1076 to be the same as the signedness of TYPE. */
1079 double_int_fits_to_tree_p (const_tree type, double_int cst)
1081 /* Size types *are* sign extended. */
1082 bool sign_extended_type = (!TYPE_UNSIGNED (type)
1083 || (TREE_CODE (type) == INTEGER_TYPE
1084 && TYPE_IS_SIZETYPE (type)));
1087 = double_int_ext (cst, TYPE_PRECISION (type), !sign_extended_type);
1089 return double_int_equal_p (cst, ext);
1092 /* We force the double_int CST to the range of the type TYPE by sign or
1093 zero extending it. OVERFLOWABLE indicates if we are interested in
1094 overflow of the value, when >0 we are only interested in signed
1095 overflow, for <0 we are interested in any overflow. OVERFLOWED
1096 indicates whether overflow has already occurred. CONST_OVERFLOWED
1097 indicates whether constant overflow has already occurred. We force
1098 T's value to be within range of T's type (by setting to 0 or 1 all
1099 the bits outside the type's range). We set TREE_OVERFLOWED if,
1100 OVERFLOWED is nonzero,
1101 or OVERFLOWABLE is >0 and signed overflow occurs
1102 or OVERFLOWABLE is <0 and any overflow occurs
1103 We return a new tree node for the extended double_int. The node
1104 is shared if no overflow flags are set. */
1108 force_fit_type_double (tree type, double_int cst, int overflowable,
1111 bool sign_extended_type;
1113 /* Size types *are* sign extended. */
1114 sign_extended_type = (!TYPE_UNSIGNED (type)
1115 || (TREE_CODE (type) == INTEGER_TYPE
1116 && TYPE_IS_SIZETYPE (type)));
1118 /* If we need to set overflow flags, return a new unshared node. */
1119 if (overflowed || !double_int_fits_to_tree_p(type, cst))
1123 || (overflowable > 0 && sign_extended_type))
1125 tree t = make_node (INTEGER_CST);
1126 TREE_INT_CST (t) = double_int_ext (cst, TYPE_PRECISION (type),
1127 !sign_extended_type);
1128 TREE_TYPE (t) = type;
1129 TREE_OVERFLOW (t) = 1;
1134 /* Else build a shared node. */
1135 return double_int_to_tree (type, cst);
1138 /* These are the hash table functions for the hash table of INTEGER_CST
1139 nodes of a sizetype. */
1141 /* Return the hash code code X, an INTEGER_CST. */
1144 int_cst_hash_hash (const void *x)
1146 const_tree const t = (const_tree) x;
1148 return (TREE_INT_CST_HIGH (t) ^ TREE_INT_CST_LOW (t)
1149 ^ htab_hash_pointer (TREE_TYPE (t)));
1152 /* Return nonzero if the value represented by *X (an INTEGER_CST tree node)
1153 is the same as that given by *Y, which is the same. */
1156 int_cst_hash_eq (const void *x, const void *y)
1158 const_tree const xt = (const_tree) x;
1159 const_tree const yt = (const_tree) y;
1161 return (TREE_TYPE (xt) == TREE_TYPE (yt)
1162 && TREE_INT_CST_HIGH (xt) == TREE_INT_CST_HIGH (yt)
1163 && TREE_INT_CST_LOW (xt) == TREE_INT_CST_LOW (yt));
1166 /* Create an INT_CST node of TYPE and value HI:LOW.
1167 The returned node is always shared. For small integers we use a
1168 per-type vector cache, for larger ones we use a single hash table. */
1171 build_int_cst_wide (tree type, unsigned HOST_WIDE_INT low, HOST_WIDE_INT hi)
1179 switch (TREE_CODE (type))
1182 gcc_assert (hi == 0 && low == 0);
1186 case REFERENCE_TYPE:
1187 /* Cache NULL pointer. */
1196 /* Cache false or true. */
1204 if (TYPE_UNSIGNED (type))
1207 limit = INTEGER_SHARE_LIMIT;
1208 if (!hi && low < (unsigned HOST_WIDE_INT)INTEGER_SHARE_LIMIT)
1214 limit = INTEGER_SHARE_LIMIT + 1;
1215 if (!hi && low < (unsigned HOST_WIDE_INT)INTEGER_SHARE_LIMIT)
1217 else if (hi == -1 && low == -(unsigned HOST_WIDE_INT)1)
1231 /* Look for it in the type's vector of small shared ints. */
1232 if (!TYPE_CACHED_VALUES_P (type))
1234 TYPE_CACHED_VALUES_P (type) = 1;
1235 TYPE_CACHED_VALUES (type) = make_tree_vec (limit);
1238 t = TREE_VEC_ELT (TYPE_CACHED_VALUES (type), ix);
1241 /* Make sure no one is clobbering the shared constant. */
1242 gcc_assert (TREE_TYPE (t) == type);
1243 gcc_assert (TREE_INT_CST_LOW (t) == low);
1244 gcc_assert (TREE_INT_CST_HIGH (t) == hi);
1248 /* Create a new shared int. */
1249 t = make_node (INTEGER_CST);
1251 TREE_INT_CST_LOW (t) = low;
1252 TREE_INT_CST_HIGH (t) = hi;
1253 TREE_TYPE (t) = type;
1255 TREE_VEC_ELT (TYPE_CACHED_VALUES (type), ix) = t;
1260 /* Use the cache of larger shared ints. */
1263 TREE_INT_CST_LOW (int_cst_node) = low;
1264 TREE_INT_CST_HIGH (int_cst_node) = hi;
1265 TREE_TYPE (int_cst_node) = type;
1267 slot = htab_find_slot (int_cst_hash_table, int_cst_node, INSERT);
1271 /* Insert this one into the hash table. */
1274 /* Make a new node for next time round. */
1275 int_cst_node = make_node (INTEGER_CST);
1282 /* Builds an integer constant in TYPE such that lowest BITS bits are ones
1283 and the rest are zeros. */
1286 build_low_bits_mask (tree type, unsigned bits)
1290 gcc_assert (bits <= TYPE_PRECISION (type));
1292 if (bits == TYPE_PRECISION (type)
1293 && !TYPE_UNSIGNED (type))
1294 /* Sign extended all-ones mask. */
1295 mask = double_int_minus_one;
1297 mask = double_int_mask (bits);
1299 return build_int_cst_wide (type, mask.low, mask.high);
1302 /* Checks that X is integer constant that can be expressed in (unsigned)
1303 HOST_WIDE_INT without loss of precision. */
1306 cst_and_fits_in_hwi (const_tree x)
1308 if (TREE_CODE (x) != INTEGER_CST)
1311 if (TYPE_PRECISION (TREE_TYPE (x)) > HOST_BITS_PER_WIDE_INT)
1314 return (TREE_INT_CST_HIGH (x) == 0
1315 || TREE_INT_CST_HIGH (x) == -1);
1318 /* Return a new VECTOR_CST node whose type is TYPE and whose values
1319 are in a list pointed to by VALS. */
1322 build_vector (tree type, tree vals)
1324 tree v = make_node (VECTOR_CST);
1329 TREE_VECTOR_CST_ELTS (v) = vals;
1330 TREE_TYPE (v) = type;
1332 /* Iterate through elements and check for overflow. */
1333 for (link = vals; link; link = TREE_CHAIN (link))
1335 tree value = TREE_VALUE (link);
1338 /* Don't crash if we get an address constant. */
1339 if (!CONSTANT_CLASS_P (value))
1342 over |= TREE_OVERFLOW (value);
1345 gcc_assert (cnt == TYPE_VECTOR_SUBPARTS (type));
1347 TREE_OVERFLOW (v) = over;
1351 /* Return a new VECTOR_CST node whose type is TYPE and whose values
1352 are extracted from V, a vector of CONSTRUCTOR_ELT. */
1355 build_vector_from_ctor (tree type, VEC(constructor_elt,gc) *v)
1357 tree list = NULL_TREE;
1358 unsigned HOST_WIDE_INT idx;
1361 FOR_EACH_CONSTRUCTOR_VALUE (v, idx, value)
1362 list = tree_cons (NULL_TREE, value, list);
1363 for (; idx < TYPE_VECTOR_SUBPARTS (type); ++idx)
1364 list = tree_cons (NULL_TREE,
1365 fold_convert (TREE_TYPE (type), integer_zero_node), list);
1366 return build_vector (type, nreverse (list));
1369 /* Build a vector of type VECTYPE where all the elements are SCs. */
1371 build_vector_from_val (tree vectype, tree sc)
1373 int i, nunits = TYPE_VECTOR_SUBPARTS (vectype);
1374 VEC(constructor_elt, gc) *v = NULL;
1376 if (sc == error_mark_node)
1379 gcc_assert (TREE_TYPE (sc) == TREE_TYPE (vectype));
1381 v = VEC_alloc (constructor_elt, gc, nunits);
1382 for (i = 0; i < nunits; ++i)
1383 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, sc);
1385 if (CONSTANT_CLASS_P (sc))
1386 return build_vector_from_ctor (vectype, v);
1388 return build_constructor (vectype, v);
1391 /* Return a new CONSTRUCTOR node whose type is TYPE and whose values
1392 are in the VEC pointed to by VALS. */
1394 build_constructor (tree type, VEC(constructor_elt,gc) *vals)
1396 tree c = make_node (CONSTRUCTOR);
1398 constructor_elt *elt;
1399 bool constant_p = true;
1401 TREE_TYPE (c) = type;
1402 CONSTRUCTOR_ELTS (c) = vals;
1404 FOR_EACH_VEC_ELT (constructor_elt, vals, i, elt)
1405 if (!TREE_CONSTANT (elt->value))
1411 TREE_CONSTANT (c) = constant_p;
1416 /* Build a CONSTRUCTOR node made of a single initializer, with the specified
1419 build_constructor_single (tree type, tree index, tree value)
1421 VEC(constructor_elt,gc) *v;
1422 constructor_elt *elt;
1424 v = VEC_alloc (constructor_elt, gc, 1);
1425 elt = VEC_quick_push (constructor_elt, v, NULL);
1429 return build_constructor (type, v);
1433 /* Return a new CONSTRUCTOR node whose type is TYPE and whose values
1434 are in a list pointed to by VALS. */
1436 build_constructor_from_list (tree type, tree vals)
1439 VEC(constructor_elt,gc) *v = NULL;
1443 v = VEC_alloc (constructor_elt, gc, list_length (vals));
1444 for (t = vals; t; t = TREE_CHAIN (t))
1445 CONSTRUCTOR_APPEND_ELT (v, TREE_PURPOSE (t), TREE_VALUE (t));
1448 return build_constructor (type, v);
1451 /* Return a new FIXED_CST node whose type is TYPE and value is F. */
1454 build_fixed (tree type, FIXED_VALUE_TYPE f)
1457 FIXED_VALUE_TYPE *fp;
1459 v = make_node (FIXED_CST);
1460 fp = ggc_alloc_fixed_value ();
1461 memcpy (fp, &f, sizeof (FIXED_VALUE_TYPE));
1463 TREE_TYPE (v) = type;
1464 TREE_FIXED_CST_PTR (v) = fp;
1468 /* Return a new REAL_CST node whose type is TYPE and value is D. */
1471 build_real (tree type, REAL_VALUE_TYPE d)
1474 REAL_VALUE_TYPE *dp;
1477 /* ??? Used to check for overflow here via CHECK_FLOAT_TYPE.
1478 Consider doing it via real_convert now. */
1480 v = make_node (REAL_CST);
1481 dp = ggc_alloc_real_value ();
1482 memcpy (dp, &d, sizeof (REAL_VALUE_TYPE));
1484 TREE_TYPE (v) = type;
1485 TREE_REAL_CST_PTR (v) = dp;
1486 TREE_OVERFLOW (v) = overflow;
1490 /* Return a new REAL_CST node whose type is TYPE
1491 and whose value is the integer value of the INTEGER_CST node I. */
1494 real_value_from_int_cst (const_tree type, const_tree i)
1498 /* Clear all bits of the real value type so that we can later do
1499 bitwise comparisons to see if two values are the same. */
1500 memset (&d, 0, sizeof d);
1502 real_from_integer (&d, type ? TYPE_MODE (type) : VOIDmode,
1503 TREE_INT_CST_LOW (i), TREE_INT_CST_HIGH (i),
1504 TYPE_UNSIGNED (TREE_TYPE (i)));
1508 /* Given a tree representing an integer constant I, return a tree
1509 representing the same value as a floating-point constant of type TYPE. */
1512 build_real_from_int_cst (tree type, const_tree i)
1515 int overflow = TREE_OVERFLOW (i);
1517 v = build_real (type, real_value_from_int_cst (type, i));
1519 TREE_OVERFLOW (v) |= overflow;
1523 /* Return a newly constructed STRING_CST node whose value is
1524 the LEN characters at STR.
1525 The TREE_TYPE is not initialized. */
1528 build_string (int len, const char *str)
1533 /* Do not waste bytes provided by padding of struct tree_string. */
1534 length = len + offsetof (struct tree_string, str) + 1;
1536 #ifdef GATHER_STATISTICS
1537 tree_node_counts[(int) c_kind]++;
1538 tree_node_sizes[(int) c_kind] += length;
1541 s = ggc_alloc_tree_node (length);
1543 memset (s, 0, sizeof (struct tree_common));
1544 TREE_SET_CODE (s, STRING_CST);
1545 TREE_CONSTANT (s) = 1;
1546 TREE_STRING_LENGTH (s) = len;
1547 memcpy (s->string.str, str, len);
1548 s->string.str[len] = '\0';
1553 /* Return a newly constructed COMPLEX_CST node whose value is
1554 specified by the real and imaginary parts REAL and IMAG.
1555 Both REAL and IMAG should be constant nodes. TYPE, if specified,
1556 will be the type of the COMPLEX_CST; otherwise a new type will be made. */
1559 build_complex (tree type, tree real, tree imag)
1561 tree t = make_node (COMPLEX_CST);
1563 TREE_REALPART (t) = real;
1564 TREE_IMAGPART (t) = imag;
1565 TREE_TYPE (t) = type ? type : build_complex_type (TREE_TYPE (real));
1566 TREE_OVERFLOW (t) = TREE_OVERFLOW (real) | TREE_OVERFLOW (imag);
1570 /* Return a constant of arithmetic type TYPE which is the
1571 multiplicative identity of the set TYPE. */
1574 build_one_cst (tree type)
1576 switch (TREE_CODE (type))
1578 case INTEGER_TYPE: case ENUMERAL_TYPE: case BOOLEAN_TYPE:
1579 case POINTER_TYPE: case REFERENCE_TYPE:
1581 return build_int_cst (type, 1);
1584 return build_real (type, dconst1);
1586 case FIXED_POINT_TYPE:
1587 /* We can only generate 1 for accum types. */
1588 gcc_assert (ALL_SCALAR_ACCUM_MODE_P (TYPE_MODE (type)));
1589 return build_fixed (type, FCONST1(TYPE_MODE (type)));
1596 scalar = build_one_cst (TREE_TYPE (type));
1598 /* Create 'vect_cst_ = {cst,cst,...,cst}' */
1600 for (i = TYPE_VECTOR_SUBPARTS (type); --i >= 0; )
1601 cst = tree_cons (NULL_TREE, scalar, cst);
1603 return build_vector (type, cst);
1607 return build_complex (type,
1608 build_one_cst (TREE_TYPE (type)),
1609 fold_convert (TREE_TYPE (type), integer_zero_node));
1616 /* Build 0 constant of type TYPE. This is used by constructor folding and thus
1617 the constant should correspond zero in memory representation. */
1620 build_zero_cst (tree type)
1622 if (!AGGREGATE_TYPE_P (type))
1623 return fold_convert (type, integer_zero_node);
1624 return build_constructor (type, NULL);
1628 /* Build a BINFO with LEN language slots. */
1631 make_tree_binfo_stat (unsigned base_binfos MEM_STAT_DECL)
1634 size_t length = (offsetof (struct tree_binfo, base_binfos)
1635 + VEC_embedded_size (tree, base_binfos));
1637 #ifdef GATHER_STATISTICS
1638 tree_node_counts[(int) binfo_kind]++;
1639 tree_node_sizes[(int) binfo_kind] += length;
1642 t = ggc_alloc_zone_tree_node_stat (&tree_zone, length PASS_MEM_STAT);
1644 memset (t, 0, offsetof (struct tree_binfo, base_binfos));
1646 TREE_SET_CODE (t, TREE_BINFO);
1648 VEC_embedded_init (tree, BINFO_BASE_BINFOS (t), base_binfos);
1654 /* Build a newly constructed TREE_VEC node of length LEN. */
1657 make_tree_vec_stat (int len MEM_STAT_DECL)
1660 int length = (len - 1) * sizeof (tree) + sizeof (struct tree_vec);
1662 #ifdef GATHER_STATISTICS
1663 tree_node_counts[(int) vec_kind]++;
1664 tree_node_sizes[(int) vec_kind] += length;
1667 t = ggc_alloc_zone_cleared_tree_node_stat (&tree_zone, length PASS_MEM_STAT);
1669 TREE_SET_CODE (t, TREE_VEC);
1670 TREE_VEC_LENGTH (t) = len;
1675 /* Return 1 if EXPR is the integer constant zero or a complex constant
1679 integer_zerop (const_tree expr)
1683 return ((TREE_CODE (expr) == INTEGER_CST
1684 && TREE_INT_CST_LOW (expr) == 0
1685 && TREE_INT_CST_HIGH (expr) == 0)
1686 || (TREE_CODE (expr) == COMPLEX_CST
1687 && integer_zerop (TREE_REALPART (expr))
1688 && integer_zerop (TREE_IMAGPART (expr))));
1691 /* Return 1 if EXPR is the integer constant one or the corresponding
1692 complex constant. */
1695 integer_onep (const_tree expr)
1699 return ((TREE_CODE (expr) == INTEGER_CST
1700 && TREE_INT_CST_LOW (expr) == 1
1701 && TREE_INT_CST_HIGH (expr) == 0)
1702 || (TREE_CODE (expr) == COMPLEX_CST
1703 && integer_onep (TREE_REALPART (expr))
1704 && integer_zerop (TREE_IMAGPART (expr))));
1707 /* Return 1 if EXPR is an integer containing all 1's in as much precision as
1708 it contains. Likewise for the corresponding complex constant. */
1711 integer_all_onesp (const_tree expr)
1718 if (TREE_CODE (expr) == COMPLEX_CST
1719 && integer_all_onesp (TREE_REALPART (expr))
1720 && integer_zerop (TREE_IMAGPART (expr)))
1723 else if (TREE_CODE (expr) != INTEGER_CST)
1726 uns = TYPE_UNSIGNED (TREE_TYPE (expr));
1727 if (TREE_INT_CST_LOW (expr) == ~(unsigned HOST_WIDE_INT) 0
1728 && TREE_INT_CST_HIGH (expr) == -1)
1733 /* Note that using TYPE_PRECISION here is wrong. We care about the
1734 actual bits, not the (arbitrary) range of the type. */
1735 prec = GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (expr)));
1736 if (prec >= HOST_BITS_PER_WIDE_INT)
1738 HOST_WIDE_INT high_value;
1741 shift_amount = prec - HOST_BITS_PER_WIDE_INT;
1743 /* Can not handle precisions greater than twice the host int size. */
1744 gcc_assert (shift_amount <= HOST_BITS_PER_WIDE_INT);
1745 if (shift_amount == HOST_BITS_PER_WIDE_INT)
1746 /* Shifting by the host word size is undefined according to the ANSI
1747 standard, so we must handle this as a special case. */
1750 high_value = ((HOST_WIDE_INT) 1 << shift_amount) - 1;
1752 return (TREE_INT_CST_LOW (expr) == ~(unsigned HOST_WIDE_INT) 0
1753 && TREE_INT_CST_HIGH (expr) == high_value);
1756 return TREE_INT_CST_LOW (expr) == ((unsigned HOST_WIDE_INT) 1 << prec) - 1;
1759 /* Return 1 if EXPR is an integer constant that is a power of 2 (i.e., has only
1763 integer_pow2p (const_tree expr)
1766 HOST_WIDE_INT high, low;
1770 if (TREE_CODE (expr) == COMPLEX_CST
1771 && integer_pow2p (TREE_REALPART (expr))
1772 && integer_zerop (TREE_IMAGPART (expr)))
1775 if (TREE_CODE (expr) != INTEGER_CST)
1778 prec = TYPE_PRECISION (TREE_TYPE (expr));
1779 high = TREE_INT_CST_HIGH (expr);
1780 low = TREE_INT_CST_LOW (expr);
1782 /* First clear all bits that are beyond the type's precision in case
1783 we've been sign extended. */
1785 if (prec == 2 * HOST_BITS_PER_WIDE_INT)
1787 else if (prec > HOST_BITS_PER_WIDE_INT)
1788 high &= ~((HOST_WIDE_INT) (-1) << (prec - HOST_BITS_PER_WIDE_INT));
1792 if (prec < HOST_BITS_PER_WIDE_INT)
1793 low &= ~((HOST_WIDE_INT) (-1) << prec);
1796 if (high == 0 && low == 0)
1799 return ((high == 0 && (low & (low - 1)) == 0)
1800 || (low == 0 && (high & (high - 1)) == 0));
1803 /* Return 1 if EXPR is an integer constant other than zero or a
1804 complex constant other than zero. */
1807 integer_nonzerop (const_tree expr)
1811 return ((TREE_CODE (expr) == INTEGER_CST
1812 && (TREE_INT_CST_LOW (expr) != 0
1813 || TREE_INT_CST_HIGH (expr) != 0))
1814 || (TREE_CODE (expr) == COMPLEX_CST
1815 && (integer_nonzerop (TREE_REALPART (expr))
1816 || integer_nonzerop (TREE_IMAGPART (expr)))));
1819 /* Return 1 if EXPR is the fixed-point constant zero. */
1822 fixed_zerop (const_tree expr)
1824 return (TREE_CODE (expr) == FIXED_CST
1825 && double_int_zero_p (TREE_FIXED_CST (expr).data));
1828 /* Return the power of two represented by a tree node known to be a
1832 tree_log2 (const_tree expr)
1835 HOST_WIDE_INT high, low;
1839 if (TREE_CODE (expr) == COMPLEX_CST)
1840 return tree_log2 (TREE_REALPART (expr));
1842 prec = TYPE_PRECISION (TREE_TYPE (expr));
1843 high = TREE_INT_CST_HIGH (expr);
1844 low = TREE_INT_CST_LOW (expr);
1846 /* First clear all bits that are beyond the type's precision in case
1847 we've been sign extended. */
1849 if (prec == 2 * HOST_BITS_PER_WIDE_INT)
1851 else if (prec > HOST_BITS_PER_WIDE_INT)
1852 high &= ~((HOST_WIDE_INT) (-1) << (prec - HOST_BITS_PER_WIDE_INT));
1856 if (prec < HOST_BITS_PER_WIDE_INT)
1857 low &= ~((HOST_WIDE_INT) (-1) << prec);
1860 return (high != 0 ? HOST_BITS_PER_WIDE_INT + exact_log2 (high)
1861 : exact_log2 (low));
1864 /* Similar, but return the largest integer Y such that 2 ** Y is less
1865 than or equal to EXPR. */
1868 tree_floor_log2 (const_tree expr)
1871 HOST_WIDE_INT high, low;
1875 if (TREE_CODE (expr) == COMPLEX_CST)
1876 return tree_log2 (TREE_REALPART (expr));
1878 prec = TYPE_PRECISION (TREE_TYPE (expr));
1879 high = TREE_INT_CST_HIGH (expr);
1880 low = TREE_INT_CST_LOW (expr);
1882 /* First clear all bits that are beyond the type's precision in case
1883 we've been sign extended. Ignore if type's precision hasn't been set
1884 since what we are doing is setting it. */
1886 if (prec == 2 * HOST_BITS_PER_WIDE_INT || prec == 0)
1888 else if (prec > HOST_BITS_PER_WIDE_INT)
1889 high &= ~((HOST_WIDE_INT) (-1) << (prec - HOST_BITS_PER_WIDE_INT));
1893 if (prec < HOST_BITS_PER_WIDE_INT)
1894 low &= ~((HOST_WIDE_INT) (-1) << prec);
1897 return (high != 0 ? HOST_BITS_PER_WIDE_INT + floor_log2 (high)
1898 : floor_log2 (low));
1901 /* Return 1 if EXPR is the real constant zero. Trailing zeroes matter for
1902 decimal float constants, so don't return 1 for them. */
1905 real_zerop (const_tree expr)
1909 return ((TREE_CODE (expr) == REAL_CST
1910 && REAL_VALUES_EQUAL (TREE_REAL_CST (expr), dconst0)
1911 && !(DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (expr)))))
1912 || (TREE_CODE (expr) == COMPLEX_CST
1913 && real_zerop (TREE_REALPART (expr))
1914 && real_zerop (TREE_IMAGPART (expr))));
1917 /* Return 1 if EXPR is the real constant one in real or complex form.
1918 Trailing zeroes matter for decimal float constants, so don't return
1922 real_onep (const_tree expr)
1926 return ((TREE_CODE (expr) == REAL_CST
1927 && REAL_VALUES_EQUAL (TREE_REAL_CST (expr), dconst1)
1928 && !(DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (expr)))))
1929 || (TREE_CODE (expr) == COMPLEX_CST
1930 && real_onep (TREE_REALPART (expr))
1931 && real_zerop (TREE_IMAGPART (expr))));
1934 /* Return 1 if EXPR is the real constant two. Trailing zeroes matter
1935 for decimal float constants, so don't return 1 for them. */
1938 real_twop (const_tree expr)
1942 return ((TREE_CODE (expr) == REAL_CST
1943 && REAL_VALUES_EQUAL (TREE_REAL_CST (expr), dconst2)
1944 && !(DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (expr)))))
1945 || (TREE_CODE (expr) == COMPLEX_CST
1946 && real_twop (TREE_REALPART (expr))
1947 && real_zerop (TREE_IMAGPART (expr))));
1950 /* Return 1 if EXPR is the real constant minus one. Trailing zeroes
1951 matter for decimal float constants, so don't return 1 for them. */
1954 real_minus_onep (const_tree expr)
1958 return ((TREE_CODE (expr) == REAL_CST
1959 && REAL_VALUES_EQUAL (TREE_REAL_CST (expr), dconstm1)
1960 && !(DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (expr)))))
1961 || (TREE_CODE (expr) == COMPLEX_CST
1962 && real_minus_onep (TREE_REALPART (expr))
1963 && real_zerop (TREE_IMAGPART (expr))));
1966 /* Nonzero if EXP is a constant or a cast of a constant. */
1969 really_constant_p (const_tree exp)
1971 /* This is not quite the same as STRIP_NOPS. It does more. */
1972 while (CONVERT_EXPR_P (exp)
1973 || TREE_CODE (exp) == NON_LVALUE_EXPR)
1974 exp = TREE_OPERAND (exp, 0);
1975 return TREE_CONSTANT (exp);
1978 /* Return first list element whose TREE_VALUE is ELEM.
1979 Return 0 if ELEM is not in LIST. */
1982 value_member (tree elem, tree list)
1986 if (elem == TREE_VALUE (list))
1988 list = TREE_CHAIN (list);
1993 /* Return first list element whose TREE_PURPOSE is ELEM.
1994 Return 0 if ELEM is not in LIST. */
1997 purpose_member (const_tree elem, tree list)
2001 if (elem == TREE_PURPOSE (list))
2003 list = TREE_CHAIN (list);
2008 /* Return true if ELEM is in V. */
2011 vec_member (const_tree elem, VEC(tree,gc) *v)
2015 FOR_EACH_VEC_ELT (tree, v, ix, t)
2021 /* Returns element number IDX (zero-origin) of chain CHAIN, or
2025 chain_index (int idx, tree chain)
2027 for (; chain && idx > 0; --idx)
2028 chain = TREE_CHAIN (chain);
2032 /* Return nonzero if ELEM is part of the chain CHAIN. */
2035 chain_member (const_tree elem, const_tree chain)
2041 chain = DECL_CHAIN (chain);
2047 /* Return the length of a chain of nodes chained through TREE_CHAIN.
2048 We expect a null pointer to mark the end of the chain.
2049 This is the Lisp primitive `length'. */
2052 list_length (const_tree t)
2055 #ifdef ENABLE_TREE_CHECKING
2063 #ifdef ENABLE_TREE_CHECKING
2066 gcc_assert (p != q);
2074 /* Returns the number of FIELD_DECLs in TYPE. */
2077 fields_length (const_tree type)
2079 tree t = TYPE_FIELDS (type);
2082 for (; t; t = DECL_CHAIN (t))
2083 if (TREE_CODE (t) == FIELD_DECL)
2089 /* Returns the first FIELD_DECL in the TYPE_FIELDS of the RECORD_TYPE or
2090 UNION_TYPE TYPE, or NULL_TREE if none. */
2093 first_field (const_tree type)
2095 tree t = TYPE_FIELDS (type);
2096 while (t && TREE_CODE (t) != FIELD_DECL)
2101 /* Concatenate two chains of nodes (chained through TREE_CHAIN)
2102 by modifying the last node in chain 1 to point to chain 2.
2103 This is the Lisp primitive `nconc'. */
2106 chainon (tree op1, tree op2)
2115 for (t1 = op1; TREE_CHAIN (t1); t1 = TREE_CHAIN (t1))
2117 TREE_CHAIN (t1) = op2;
2119 #ifdef ENABLE_TREE_CHECKING
2122 for (t2 = op2; t2; t2 = TREE_CHAIN (t2))
2123 gcc_assert (t2 != t1);
2130 /* Return the last node in a chain of nodes (chained through TREE_CHAIN). */
2133 tree_last (tree chain)
2137 while ((next = TREE_CHAIN (chain)))
2142 /* Reverse the order of elements in the chain T,
2143 and return the new head of the chain (old last element). */
2148 tree prev = 0, decl, next;
2149 for (decl = t; decl; decl = next)
2151 /* We shouldn't be using this function to reverse BLOCK chains; we
2152 have blocks_nreverse for that. */
2153 gcc_checking_assert (TREE_CODE (decl) != BLOCK);
2154 next = TREE_CHAIN (decl);
2155 TREE_CHAIN (decl) = prev;
2161 /* Return a newly created TREE_LIST node whose
2162 purpose and value fields are PARM and VALUE. */
2165 build_tree_list_stat (tree parm, tree value MEM_STAT_DECL)
2167 tree t = make_node_stat (TREE_LIST PASS_MEM_STAT);
2168 TREE_PURPOSE (t) = parm;
2169 TREE_VALUE (t) = value;
2173 /* Build a chain of TREE_LIST nodes from a vector. */
2176 build_tree_list_vec_stat (const VEC(tree,gc) *vec MEM_STAT_DECL)
2178 tree ret = NULL_TREE;
2182 FOR_EACH_VEC_ELT (tree, vec, i, t)
2184 *pp = build_tree_list_stat (NULL, t PASS_MEM_STAT);
2185 pp = &TREE_CHAIN (*pp);
2190 /* Return a newly created TREE_LIST node whose
2191 purpose and value fields are PURPOSE and VALUE
2192 and whose TREE_CHAIN is CHAIN. */
2195 tree_cons_stat (tree purpose, tree value, tree chain MEM_STAT_DECL)
2199 node = ggc_alloc_zone_tree_node_stat (&tree_zone, sizeof (struct tree_list)
2201 memset (node, 0, sizeof (struct tree_common));
2203 #ifdef GATHER_STATISTICS
2204 tree_node_counts[(int) x_kind]++;
2205 tree_node_sizes[(int) x_kind] += sizeof (struct tree_list);
2208 TREE_SET_CODE (node, TREE_LIST);
2209 TREE_CHAIN (node) = chain;
2210 TREE_PURPOSE (node) = purpose;
2211 TREE_VALUE (node) = value;
2215 /* Return the values of the elements of a CONSTRUCTOR as a vector of
2219 ctor_to_vec (tree ctor)
2221 VEC(tree, gc) *vec = VEC_alloc (tree, gc, CONSTRUCTOR_NELTS (ctor));
2225 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (ctor), ix, val)
2226 VEC_quick_push (tree, vec, val);
2231 /* Return the size nominally occupied by an object of type TYPE
2232 when it resides in memory. The value is measured in units of bytes,
2233 and its data type is that normally used for type sizes
2234 (which is the first type created by make_signed_type or
2235 make_unsigned_type). */
2238 size_in_bytes (const_tree type)
2242 if (type == error_mark_node)
2243 return integer_zero_node;
2245 type = TYPE_MAIN_VARIANT (type);
2246 t = TYPE_SIZE_UNIT (type);
2250 lang_hooks.types.incomplete_type_error (NULL_TREE, type);
2251 return size_zero_node;
2257 /* Return the size of TYPE (in bytes) as a wide integer
2258 or return -1 if the size can vary or is larger than an integer. */
2261 int_size_in_bytes (const_tree type)
2265 if (type == error_mark_node)
2268 type = TYPE_MAIN_VARIANT (type);
2269 t = TYPE_SIZE_UNIT (type);
2271 || TREE_CODE (t) != INTEGER_CST
2272 || TREE_INT_CST_HIGH (t) != 0
2273 /* If the result would appear negative, it's too big to represent. */
2274 || (HOST_WIDE_INT) TREE_INT_CST_LOW (t) < 0)
2277 return TREE_INT_CST_LOW (t);
2280 /* Return the maximum size of TYPE (in bytes) as a wide integer
2281 or return -1 if the size can vary or is larger than an integer. */
2284 max_int_size_in_bytes (const_tree type)
2286 HOST_WIDE_INT size = -1;
2289 /* If this is an array type, check for a possible MAX_SIZE attached. */
2291 if (TREE_CODE (type) == ARRAY_TYPE)
2293 size_tree = TYPE_ARRAY_MAX_SIZE (type);
2295 if (size_tree && host_integerp (size_tree, 1))
2296 size = tree_low_cst (size_tree, 1);
2299 /* If we still haven't been able to get a size, see if the language
2300 can compute a maximum size. */
2304 size_tree = lang_hooks.types.max_size (type);
2306 if (size_tree && host_integerp (size_tree, 1))
2307 size = tree_low_cst (size_tree, 1);
2313 /* Returns a tree for the size of EXP in bytes. */
2316 tree_expr_size (const_tree exp)
2319 && DECL_SIZE_UNIT (exp) != 0)
2320 return DECL_SIZE_UNIT (exp);
2322 return size_in_bytes (TREE_TYPE (exp));
2325 /* Return the bit position of FIELD, in bits from the start of the record.
2326 This is a tree of type bitsizetype. */
2329 bit_position (const_tree field)
2331 return bit_from_pos (DECL_FIELD_OFFSET (field),
2332 DECL_FIELD_BIT_OFFSET (field));
2335 /* Likewise, but return as an integer. It must be representable in
2336 that way (since it could be a signed value, we don't have the
2337 option of returning -1 like int_size_in_byte can. */
2340 int_bit_position (const_tree field)
2342 return tree_low_cst (bit_position (field), 0);
2345 /* Return the byte position of FIELD, in bytes from the start of the record.
2346 This is a tree of type sizetype. */
2349 byte_position (const_tree field)
2351 return byte_from_pos (DECL_FIELD_OFFSET (field),
2352 DECL_FIELD_BIT_OFFSET (field));
2355 /* Likewise, but return as an integer. It must be representable in
2356 that way (since it could be a signed value, we don't have the
2357 option of returning -1 like int_size_in_byte can. */
2360 int_byte_position (const_tree field)
2362 return tree_low_cst (byte_position (field), 0);
2365 /* Return the strictest alignment, in bits, that T is known to have. */
2368 expr_align (const_tree t)
2370 unsigned int align0, align1;
2372 switch (TREE_CODE (t))
2374 CASE_CONVERT: case NON_LVALUE_EXPR:
2375 /* If we have conversions, we know that the alignment of the
2376 object must meet each of the alignments of the types. */
2377 align0 = expr_align (TREE_OPERAND (t, 0));
2378 align1 = TYPE_ALIGN (TREE_TYPE (t));
2379 return MAX (align0, align1);
2381 case SAVE_EXPR: case COMPOUND_EXPR: case MODIFY_EXPR:
2382 case INIT_EXPR: case TARGET_EXPR: case WITH_CLEANUP_EXPR:
2383 case CLEANUP_POINT_EXPR:
2384 /* These don't change the alignment of an object. */
2385 return expr_align (TREE_OPERAND (t, 0));
2388 /* The best we can do is say that the alignment is the least aligned
2390 align0 = expr_align (TREE_OPERAND (t, 1));
2391 align1 = expr_align (TREE_OPERAND (t, 2));
2392 return MIN (align0, align1);
2394 /* FIXME: LABEL_DECL and CONST_DECL never have DECL_ALIGN set
2395 meaningfully, it's always 1. */
2396 case LABEL_DECL: case CONST_DECL:
2397 case VAR_DECL: case PARM_DECL: case RESULT_DECL:
2399 gcc_assert (DECL_ALIGN (t) != 0);
2400 return DECL_ALIGN (t);
2406 /* Otherwise take the alignment from that of the type. */
2407 return TYPE_ALIGN (TREE_TYPE (t));
2410 /* Return, as a tree node, the number of elements for TYPE (which is an
2411 ARRAY_TYPE) minus one. This counts only elements of the top array. */
2414 array_type_nelts (const_tree type)
2416 tree index_type, min, max;
2418 /* If they did it with unspecified bounds, then we should have already
2419 given an error about it before we got here. */
2420 if (! TYPE_DOMAIN (type))
2421 return error_mark_node;
2423 index_type = TYPE_DOMAIN (type);
2424 min = TYPE_MIN_VALUE (index_type);
2425 max = TYPE_MAX_VALUE (index_type);
2427 return (integer_zerop (min)
2429 : fold_build2 (MINUS_EXPR, TREE_TYPE (max), max, min));
2432 /* If arg is static -- a reference to an object in static storage -- then
2433 return the object. This is not the same as the C meaning of `static'.
2434 If arg isn't static, return NULL. */
2439 switch (TREE_CODE (arg))
2442 /* Nested functions are static, even though taking their address will
2443 involve a trampoline as we unnest the nested function and create
2444 the trampoline on the tree level. */
2448 return ((TREE_STATIC (arg) || DECL_EXTERNAL (arg))
2449 && ! DECL_THREAD_LOCAL_P (arg)
2450 && ! DECL_DLLIMPORT_P (arg)
2454 return ((TREE_STATIC (arg) || DECL_EXTERNAL (arg))
2458 return TREE_STATIC (arg) ? arg : NULL;
2465 /* If the thing being referenced is not a field, then it is
2466 something language specific. */
2467 gcc_assert (TREE_CODE (TREE_OPERAND (arg, 1)) == FIELD_DECL);
2469 /* If we are referencing a bitfield, we can't evaluate an
2470 ADDR_EXPR at compile time and so it isn't a constant. */
2471 if (DECL_BIT_FIELD (TREE_OPERAND (arg, 1)))
2474 return staticp (TREE_OPERAND (arg, 0));
2480 return TREE_CONSTANT (TREE_OPERAND (arg, 0)) ? arg : NULL;
2483 case ARRAY_RANGE_REF:
2484 if (TREE_CODE (TYPE_SIZE (TREE_TYPE (arg))) == INTEGER_CST
2485 && TREE_CODE (TREE_OPERAND (arg, 1)) == INTEGER_CST)
2486 return staticp (TREE_OPERAND (arg, 0));
2490 case COMPOUND_LITERAL_EXPR:
2491 return TREE_STATIC (COMPOUND_LITERAL_EXPR_DECL (arg)) ? arg : NULL;
2501 /* Return whether OP is a DECL whose address is function-invariant. */
2504 decl_address_invariant_p (const_tree op)
2506 /* The conditions below are slightly less strict than the one in
2509 switch (TREE_CODE (op))
2518 if ((TREE_STATIC (op) || DECL_EXTERNAL (op))
2519 || DECL_THREAD_LOCAL_P (op)
2520 || DECL_CONTEXT (op) == current_function_decl
2521 || decl_function_context (op) == current_function_decl)
2526 if ((TREE_STATIC (op) || DECL_EXTERNAL (op))
2527 || decl_function_context (op) == current_function_decl)
2538 /* Return whether OP is a DECL whose address is interprocedural-invariant. */
2541 decl_address_ip_invariant_p (const_tree op)
2543 /* The conditions below are slightly less strict than the one in
2546 switch (TREE_CODE (op))
2554 if (((TREE_STATIC (op) || DECL_EXTERNAL (op))
2555 && !DECL_DLLIMPORT_P (op))
2556 || DECL_THREAD_LOCAL_P (op))
2561 if ((TREE_STATIC (op) || DECL_EXTERNAL (op)))
2573 /* Return true if T is function-invariant (internal function, does
2574 not handle arithmetic; that's handled in skip_simple_arithmetic and
2575 tree_invariant_p). */
2577 static bool tree_invariant_p (tree t);
2580 tree_invariant_p_1 (tree t)
2584 if (TREE_CONSTANT (t)
2585 || (TREE_READONLY (t) && !TREE_SIDE_EFFECTS (t)))
2588 switch (TREE_CODE (t))
2594 op = TREE_OPERAND (t, 0);
2595 while (handled_component_p (op))
2597 switch (TREE_CODE (op))
2600 case ARRAY_RANGE_REF:
2601 if (!tree_invariant_p (TREE_OPERAND (op, 1))
2602 || TREE_OPERAND (op, 2) != NULL_TREE
2603 || TREE_OPERAND (op, 3) != NULL_TREE)
2608 if (TREE_OPERAND (op, 2) != NULL_TREE)
2614 op = TREE_OPERAND (op, 0);
2617 return CONSTANT_CLASS_P (op) || decl_address_invariant_p (op);
2626 /* Return true if T is function-invariant. */
2629 tree_invariant_p (tree t)
2631 tree inner = skip_simple_arithmetic (t);
2632 return tree_invariant_p_1 (inner);
2635 /* Wrap a SAVE_EXPR around EXPR, if appropriate.
2636 Do this to any expression which may be used in more than one place,
2637 but must be evaluated only once.
2639 Normally, expand_expr would reevaluate the expression each time.
2640 Calling save_expr produces something that is evaluated and recorded
2641 the first time expand_expr is called on it. Subsequent calls to
2642 expand_expr just reuse the recorded value.
2644 The call to expand_expr that generates code that actually computes
2645 the value is the first call *at compile time*. Subsequent calls
2646 *at compile time* generate code to use the saved value.
2647 This produces correct result provided that *at run time* control
2648 always flows through the insns made by the first expand_expr
2649 before reaching the other places where the save_expr was evaluated.
2650 You, the caller of save_expr, must make sure this is so.
2652 Constants, and certain read-only nodes, are returned with no
2653 SAVE_EXPR because that is safe. Expressions containing placeholders
2654 are not touched; see tree.def for an explanation of what these
2658 save_expr (tree expr)
2660 tree t = fold (expr);
2663 /* If the tree evaluates to a constant, then we don't want to hide that
2664 fact (i.e. this allows further folding, and direct checks for constants).
2665 However, a read-only object that has side effects cannot be bypassed.
2666 Since it is no problem to reevaluate literals, we just return the
2668 inner = skip_simple_arithmetic (t);
2669 if (TREE_CODE (inner) == ERROR_MARK)
2672 if (tree_invariant_p_1 (inner))
2675 /* If INNER contains a PLACEHOLDER_EXPR, we must evaluate it each time, since
2676 it means that the size or offset of some field of an object depends on
2677 the value within another field.
2679 Note that it must not be the case that T contains both a PLACEHOLDER_EXPR
2680 and some variable since it would then need to be both evaluated once and
2681 evaluated more than once. Front-ends must assure this case cannot
2682 happen by surrounding any such subexpressions in their own SAVE_EXPR
2683 and forcing evaluation at the proper time. */
2684 if (contains_placeholder_p (inner))
2687 t = build1 (SAVE_EXPR, TREE_TYPE (expr), t);
2688 SET_EXPR_LOCATION (t, EXPR_LOCATION (expr));
2690 /* This expression might be placed ahead of a jump to ensure that the
2691 value was computed on both sides of the jump. So make sure it isn't
2692 eliminated as dead. */
2693 TREE_SIDE_EFFECTS (t) = 1;
2697 /* Look inside EXPR and into any simple arithmetic operations. Return
2698 the innermost non-arithmetic node. */
2701 skip_simple_arithmetic (tree expr)
2705 /* We don't care about whether this can be used as an lvalue in this
2707 while (TREE_CODE (expr) == NON_LVALUE_EXPR)
2708 expr = TREE_OPERAND (expr, 0);
2710 /* If we have simple operations applied to a SAVE_EXPR or to a SAVE_EXPR and
2711 a constant, it will be more efficient to not make another SAVE_EXPR since
2712 it will allow better simplification and GCSE will be able to merge the
2713 computations if they actually occur. */
2717 if (UNARY_CLASS_P (inner))
2718 inner = TREE_OPERAND (inner, 0);
2719 else if (BINARY_CLASS_P (inner))
2721 if (tree_invariant_p (TREE_OPERAND (inner, 1)))
2722 inner = TREE_OPERAND (inner, 0);
2723 else if (tree_invariant_p (TREE_OPERAND (inner, 0)))
2724 inner = TREE_OPERAND (inner, 1);
2736 /* Return which tree structure is used by T. */
2738 enum tree_node_structure_enum
2739 tree_node_structure (const_tree t)
2741 const enum tree_code code = TREE_CODE (t);
2742 return tree_node_structure_for_code (code);
2745 /* Set various status flags when building a CALL_EXPR object T. */
2748 process_call_operands (tree t)
2750 bool side_effects = TREE_SIDE_EFFECTS (t);
2751 bool read_only = false;
2752 int i = call_expr_flags (t);
2754 /* Calls have side-effects, except those to const or pure functions. */
2755 if ((i & ECF_LOOPING_CONST_OR_PURE) || !(i & (ECF_CONST | ECF_PURE)))
2756 side_effects = true;
2757 /* Propagate TREE_READONLY of arguments for const functions. */
2761 if (!side_effects || read_only)
2762 for (i = 1; i < TREE_OPERAND_LENGTH (t); i++)
2764 tree op = TREE_OPERAND (t, i);
2765 if (op && TREE_SIDE_EFFECTS (op))
2766 side_effects = true;
2767 if (op && !TREE_READONLY (op) && !CONSTANT_CLASS_P (op))
2771 TREE_SIDE_EFFECTS (t) = side_effects;
2772 TREE_READONLY (t) = read_only;
2775 /* Return 1 if EXP contains a PLACEHOLDER_EXPR; i.e., if it represents a size
2776 or offset that depends on a field within a record. */
2779 contains_placeholder_p (const_tree exp)
2781 enum tree_code code;
2786 code = TREE_CODE (exp);
2787 if (code == PLACEHOLDER_EXPR)
2790 switch (TREE_CODE_CLASS (code))
2793 /* Don't look at any PLACEHOLDER_EXPRs that might be in index or bit
2794 position computations since they will be converted into a
2795 WITH_RECORD_EXPR involving the reference, which will assume
2796 here will be valid. */
2797 return CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 0));
2799 case tcc_exceptional:
2800 if (code == TREE_LIST)
2801 return (CONTAINS_PLACEHOLDER_P (TREE_VALUE (exp))
2802 || CONTAINS_PLACEHOLDER_P (TREE_CHAIN (exp)));
2807 case tcc_comparison:
2808 case tcc_expression:
2812 /* Ignoring the first operand isn't quite right, but works best. */
2813 return CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 1));
2816 return (CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 0))
2817 || CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 1))
2818 || CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 2)));
2821 /* The save_expr function never wraps anything containing
2822 a PLACEHOLDER_EXPR. */
2829 switch (TREE_CODE_LENGTH (code))
2832 return CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 0));
2834 return (CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 0))
2835 || CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 1)));
2846 const_call_expr_arg_iterator iter;
2847 FOR_EACH_CONST_CALL_EXPR_ARG (arg, iter, exp)
2848 if (CONTAINS_PLACEHOLDER_P (arg))
2862 /* Return true if any part of the computation of TYPE involves a
2863 PLACEHOLDER_EXPR. This includes size, bounds, qualifiers
2864 (for QUAL_UNION_TYPE) and field positions. */
2867 type_contains_placeholder_1 (const_tree type)
2869 /* If the size contains a placeholder or the parent type (component type in
2870 the case of arrays) type involves a placeholder, this type does. */
2871 if (CONTAINS_PLACEHOLDER_P (TYPE_SIZE (type))
2872 || CONTAINS_PLACEHOLDER_P (TYPE_SIZE_UNIT (type))
2873 || (TREE_TYPE (type) != 0
2874 && type_contains_placeholder_p (TREE_TYPE (type))))
2877 /* Now do type-specific checks. Note that the last part of the check above
2878 greatly limits what we have to do below. */
2879 switch (TREE_CODE (type))
2887 case REFERENCE_TYPE:
2895 case FIXED_POINT_TYPE:
2896 /* Here we just check the bounds. */
2897 return (CONTAINS_PLACEHOLDER_P (TYPE_MIN_VALUE (type))
2898 || CONTAINS_PLACEHOLDER_P (TYPE_MAX_VALUE (type)));
2901 /* We're already checked the component type (TREE_TYPE), so just check
2903 return type_contains_placeholder_p (TYPE_DOMAIN (type));
2907 case QUAL_UNION_TYPE:
2911 for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
2912 if (TREE_CODE (field) == FIELD_DECL
2913 && (CONTAINS_PLACEHOLDER_P (DECL_FIELD_OFFSET (field))
2914 || (TREE_CODE (type) == QUAL_UNION_TYPE
2915 && CONTAINS_PLACEHOLDER_P (DECL_QUALIFIER (field)))
2916 || type_contains_placeholder_p (TREE_TYPE (field))))
2928 type_contains_placeholder_p (tree type)
2932 /* If the contains_placeholder_bits field has been initialized,
2933 then we know the answer. */
2934 if (TYPE_CONTAINS_PLACEHOLDER_INTERNAL (type) > 0)
2935 return TYPE_CONTAINS_PLACEHOLDER_INTERNAL (type) - 1;
2937 /* Indicate that we've seen this type node, and the answer is false.
2938 This is what we want to return if we run into recursion via fields. */
2939 TYPE_CONTAINS_PLACEHOLDER_INTERNAL (type) = 1;
2941 /* Compute the real value. */
2942 result = type_contains_placeholder_1 (type);
2944 /* Store the real value. */
2945 TYPE_CONTAINS_PLACEHOLDER_INTERNAL (type) = result + 1;
2950 /* Push tree EXP onto vector QUEUE if it is not already present. */
2953 push_without_duplicates (tree exp, VEC (tree, heap) **queue)
2958 FOR_EACH_VEC_ELT (tree, *queue, i, iter)
2959 if (simple_cst_equal (iter, exp) == 1)
2963 VEC_safe_push (tree, heap, *queue, exp);
2966 /* Given a tree EXP, find all occurences of references to fields
2967 in a PLACEHOLDER_EXPR and place them in vector REFS without
2968 duplicates. Also record VAR_DECLs and CONST_DECLs. Note that
2969 we assume here that EXP contains only arithmetic expressions
2970 or CALL_EXPRs with PLACEHOLDER_EXPRs occurring only in their
2974 find_placeholder_in_expr (tree exp, VEC (tree, heap) **refs)
2976 enum tree_code code = TREE_CODE (exp);
2980 /* We handle TREE_LIST and COMPONENT_REF separately. */
2981 if (code == TREE_LIST)
2983 FIND_PLACEHOLDER_IN_EXPR (TREE_CHAIN (exp), refs);
2984 FIND_PLACEHOLDER_IN_EXPR (TREE_VALUE (exp), refs);
2986 else if (code == COMPONENT_REF)
2988 for (inner = TREE_OPERAND (exp, 0);
2989 REFERENCE_CLASS_P (inner);
2990 inner = TREE_OPERAND (inner, 0))
2993 if (TREE_CODE (inner) == PLACEHOLDER_EXPR)
2994 push_without_duplicates (exp, refs);
2996 FIND_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 0), refs);
2999 switch (TREE_CODE_CLASS (code))
3004 case tcc_declaration:
3005 /* Variables allocated to static storage can stay. */
3006 if (!TREE_STATIC (exp))
3007 push_without_duplicates (exp, refs);
3010 case tcc_expression:
3011 /* This is the pattern built in ada/make_aligning_type. */
3012 if (code == ADDR_EXPR
3013 && TREE_CODE (TREE_OPERAND (exp, 0)) == PLACEHOLDER_EXPR)
3015 push_without_duplicates (exp, refs);
3019 /* Fall through... */
3021 case tcc_exceptional:
3024 case tcc_comparison:
3026 for (i = 0; i < TREE_CODE_LENGTH (code); i++)
3027 FIND_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, i), refs);
3031 for (i = 1; i < TREE_OPERAND_LENGTH (exp); i++)
3032 FIND_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, i), refs);
3040 /* Given a tree EXP, a FIELD_DECL F, and a replacement value R,
3041 return a tree with all occurrences of references to F in a
3042 PLACEHOLDER_EXPR replaced by R. Also handle VAR_DECLs and
3043 CONST_DECLs. Note that we assume here that EXP contains only
3044 arithmetic expressions or CALL_EXPRs with PLACEHOLDER_EXPRs
3045 occurring only in their argument list. */
3048 substitute_in_expr (tree exp, tree f, tree r)
3050 enum tree_code code = TREE_CODE (exp);
3051 tree op0, op1, op2, op3;
3054 /* We handle TREE_LIST and COMPONENT_REF separately. */
3055 if (code == TREE_LIST)
3057 op0 = SUBSTITUTE_IN_EXPR (TREE_CHAIN (exp), f, r);
3058 op1 = SUBSTITUTE_IN_EXPR (TREE_VALUE (exp), f, r);
3059 if (op0 == TREE_CHAIN (exp) && op1 == TREE_VALUE (exp))
3062 return tree_cons (TREE_PURPOSE (exp), op1, op0);
3064 else if (code == COMPONENT_REF)
3068 /* If this expression is getting a value from a PLACEHOLDER_EXPR
3069 and it is the right field, replace it with R. */
3070 for (inner = TREE_OPERAND (exp, 0);
3071 REFERENCE_CLASS_P (inner);
3072 inner = TREE_OPERAND (inner, 0))
3076 op1 = TREE_OPERAND (exp, 1);
3078 if (TREE_CODE (inner) == PLACEHOLDER_EXPR && op1 == f)
3081 /* If this expression hasn't been completed let, leave it alone. */
3082 if (TREE_CODE (inner) == PLACEHOLDER_EXPR && !TREE_TYPE (inner))
3085 op0 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 0), f, r);
3086 if (op0 == TREE_OPERAND (exp, 0))
3090 = fold_build3 (COMPONENT_REF, TREE_TYPE (exp), op0, op1, NULL_TREE);
3093 switch (TREE_CODE_CLASS (code))
3098 case tcc_declaration:
3104 case tcc_expression:
3108 /* Fall through... */
3110 case tcc_exceptional:
3113 case tcc_comparison:
3115 switch (TREE_CODE_LENGTH (code))
3121 op0 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 0), f, r);
3122 if (op0 == TREE_OPERAND (exp, 0))
3125 new_tree = fold_build1 (code, TREE_TYPE (exp), op0);
3129 op0 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 0), f, r);
3130 op1 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 1), f, r);
3132 if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1))
3135 new_tree = fold_build2 (code, TREE_TYPE (exp), op0, op1);
3139 op0 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 0), f, r);
3140 op1 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 1), f, r);
3141 op2 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 2), f, r);
3143 if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1)
3144 && op2 == TREE_OPERAND (exp, 2))
3147 new_tree = fold_build3 (code, TREE_TYPE (exp), op0, op1, op2);
3151 op0 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 0), f, r);
3152 op1 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 1), f, r);
3153 op2 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 2), f, r);
3154 op3 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 3), f, r);
3156 if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1)
3157 && op2 == TREE_OPERAND (exp, 2)
3158 && op3 == TREE_OPERAND (exp, 3))
3162 = fold (build4 (code, TREE_TYPE (exp), op0, op1, op2, op3));
3174 new_tree = NULL_TREE;
3176 /* If we are trying to replace F with a constant, inline back
3177 functions which do nothing else than computing a value from
3178 the arguments they are passed. This makes it possible to
3179 fold partially or entirely the replacement expression. */
3180 if (CONSTANT_CLASS_P (r) && code == CALL_EXPR)
3182 tree t = maybe_inline_call_in_expr (exp);
3184 return SUBSTITUTE_IN_EXPR (t, f, r);
3187 for (i = 1; i < TREE_OPERAND_LENGTH (exp); i++)
3189 tree op = TREE_OPERAND (exp, i);
3190 tree new_op = SUBSTITUTE_IN_EXPR (op, f, r);
3194 new_tree = copy_node (exp);
3195 TREE_OPERAND (new_tree, i) = new_op;
3201 new_tree = fold (new_tree);
3202 if (TREE_CODE (new_tree) == CALL_EXPR)
3203 process_call_operands (new_tree);
3214 TREE_READONLY (new_tree) |= TREE_READONLY (exp);
3216 if (code == INDIRECT_REF || code == ARRAY_REF || code == ARRAY_RANGE_REF)
3217 TREE_THIS_NOTRAP (new_tree) |= TREE_THIS_NOTRAP (exp);
3222 /* Similar, but look for a PLACEHOLDER_EXPR in EXP and find a replacement
3223 for it within OBJ, a tree that is an object or a chain of references. */
3226 substitute_placeholder_in_expr (tree exp, tree obj)
3228 enum tree_code code = TREE_CODE (exp);
3229 tree op0, op1, op2, op3;
3232 /* If this is a PLACEHOLDER_EXPR, see if we find a corresponding type
3233 in the chain of OBJ. */
3234 if (code == PLACEHOLDER_EXPR)
3236 tree need_type = TYPE_MAIN_VARIANT (TREE_TYPE (exp));
3239 for (elt = obj; elt != 0;
3240 elt = ((TREE_CODE (elt) == COMPOUND_EXPR
3241 || TREE_CODE (elt) == COND_EXPR)
3242 ? TREE_OPERAND (elt, 1)
3243 : (REFERENCE_CLASS_P (elt)
3244 || UNARY_CLASS_P (elt)
3245 || BINARY_CLASS_P (elt)
3246 || VL_EXP_CLASS_P (elt)
3247 || EXPRESSION_CLASS_P (elt))
3248 ? TREE_OPERAND (elt, 0) : 0))
3249 if (TYPE_MAIN_VARIANT (TREE_TYPE (elt)) == need_type)
3252 for (elt = obj; elt != 0;
3253 elt = ((TREE_CODE (elt) == COMPOUND_EXPR
3254 || TREE_CODE (elt) == COND_EXPR)
3255 ? TREE_OPERAND (elt, 1)
3256 : (REFERENCE_CLASS_P (elt)
3257 || UNARY_CLASS_P (elt)
3258 || BINARY_CLASS_P (elt)
3259 || VL_EXP_CLASS_P (elt)
3260 || EXPRESSION_CLASS_P (elt))
3261 ? TREE_OPERAND (elt, 0) : 0))
3262 if (POINTER_TYPE_P (TREE_TYPE (elt))
3263 && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (elt)))
3265 return fold_build1 (INDIRECT_REF, need_type, elt);
3267 /* If we didn't find it, return the original PLACEHOLDER_EXPR. If it
3268 survives until RTL generation, there will be an error. */
3272 /* TREE_LIST is special because we need to look at TREE_VALUE
3273 and TREE_CHAIN, not TREE_OPERANDS. */
3274 else if (code == TREE_LIST)
3276 op0 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_CHAIN (exp), obj);
3277 op1 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_VALUE (exp), obj);
3278 if (op0 == TREE_CHAIN (exp) && op1 == TREE_VALUE (exp))
3281 return tree_cons (TREE_PURPOSE (exp), op1, op0);
3284 switch (TREE_CODE_CLASS (code))
3287 case tcc_declaration:
3290 case tcc_exceptional:
3293 case tcc_comparison:
3294 case tcc_expression:
3297 switch (TREE_CODE_LENGTH (code))
3303 op0 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 0), obj);
3304 if (op0 == TREE_OPERAND (exp, 0))
3307 new_tree = fold_build1 (code, TREE_TYPE (exp), op0);
3311 op0 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 0), obj);
3312 op1 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 1), obj);
3314 if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1))
3317 new_tree = fold_build2 (code, TREE_TYPE (exp), op0, op1);
3321 op0 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 0), obj);
3322 op1 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 1), obj);
3323 op2 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 2), obj);
3325 if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1)
3326 && op2 == TREE_OPERAND (exp, 2))
3329 new_tree = fold_build3 (code, TREE_TYPE (exp), op0, op1, op2);
3333 op0 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 0), obj);
3334 op1 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 1), obj);
3335 op2 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 2), obj);
3336 op3 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 3), obj);
3338 if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1)
3339 && op2 == TREE_OPERAND (exp, 2)
3340 && op3 == TREE_OPERAND (exp, 3))
3344 = fold (build4 (code, TREE_TYPE (exp), op0, op1, op2, op3));
3356 new_tree = NULL_TREE;
3358 for (i = 1; i < TREE_OPERAND_LENGTH (exp); i++)
3360 tree op = TREE_OPERAND (exp, i);
3361 tree new_op = SUBSTITUTE_PLACEHOLDER_IN_EXPR (op, obj);
3365 new_tree = copy_node (exp);
3366 TREE_OPERAND (new_tree, i) = new_op;
3372 new_tree = fold (new_tree);
3373 if (TREE_CODE (new_tree) == CALL_EXPR)
3374 process_call_operands (new_tree);
3385 TREE_READONLY (new_tree) |= TREE_READONLY (exp);
3387 if (code == INDIRECT_REF || code == ARRAY_REF || code == ARRAY_RANGE_REF)
3388 TREE_THIS_NOTRAP (new_tree) |= TREE_THIS_NOTRAP (exp);
3393 /* Stabilize a reference so that we can use it any number of times
3394 without causing its operands to be evaluated more than once.
3395 Returns the stabilized reference. This works by means of save_expr,
3396 so see the caveats in the comments about save_expr.
3398 Also allows conversion expressions whose operands are references.
3399 Any other kind of expression is returned unchanged. */
3402 stabilize_reference (tree ref)
3405 enum tree_code code = TREE_CODE (ref);
3412 /* No action is needed in this case. */
3417 case FIX_TRUNC_EXPR:
3418 result = build_nt (code, stabilize_reference (TREE_OPERAND (ref, 0)));
3422 result = build_nt (INDIRECT_REF,
3423 stabilize_reference_1 (TREE_OPERAND (ref, 0)));
3427 result = build_nt (COMPONENT_REF,
3428 stabilize_reference (TREE_OPERAND (ref, 0)),
3429 TREE_OPERAND (ref, 1), NULL_TREE);
3433 result = build_nt (BIT_FIELD_REF,
3434 stabilize_reference (TREE_OPERAND (ref, 0)),
3435 stabilize_reference_1 (TREE_OPERAND (ref, 1)),
3436 stabilize_reference_1 (TREE_OPERAND (ref, 2)));
3440 result = build_nt (ARRAY_REF,
3441 stabilize_reference (TREE_OPERAND (ref, 0)),
3442 stabilize_reference_1 (TREE_OPERAND (ref, 1)),
3443 TREE_OPERAND (ref, 2), TREE_OPERAND (ref, 3));
3446 case ARRAY_RANGE_REF:
3447 result = build_nt (ARRAY_RANGE_REF,
3448 stabilize_reference (TREE_OPERAND (ref, 0)),
3449 stabilize_reference_1 (TREE_OPERAND (ref, 1)),
3450 TREE_OPERAND (ref, 2), TREE_OPERAND (ref, 3));
3454 /* We cannot wrap the first expression in a SAVE_EXPR, as then
3455 it wouldn't be ignored. This matters when dealing with
3457 return stabilize_reference_1 (ref);
3459 /* If arg isn't a kind of lvalue we recognize, make no change.
3460 Caller should recognize the error for an invalid lvalue. */
3465 return error_mark_node;
3468 TREE_TYPE (result) = TREE_TYPE (ref);
3469 TREE_READONLY (result) = TREE_READONLY (ref);
3470 TREE_SIDE_EFFECTS (result) = TREE_SIDE_EFFECTS (ref);
3471 TREE_THIS_VOLATILE (result) = TREE_THIS_VOLATILE (ref);
3476 /* Subroutine of stabilize_reference; this is called for subtrees of
3477 references. Any expression with side-effects must be put in a SAVE_EXPR
3478 to ensure that it is only evaluated once.
3480 We don't put SAVE_EXPR nodes around everything, because assigning very
3481 simple expressions to temporaries causes us to miss good opportunities
3482 for optimizations. Among other things, the opportunity to fold in the
3483 addition of a constant into an addressing mode often gets lost, e.g.
3484 "y[i+1] += x;". In general, we take the approach that we should not make
3485 an assignment unless we are forced into it - i.e., that any non-side effect
3486 operator should be allowed, and that cse should take care of coalescing
3487 multiple utterances of the same expression should that prove fruitful. */
3490 stabilize_reference_1 (tree e)
3493 enum tree_code code = TREE_CODE (e);
3495 /* We cannot ignore const expressions because it might be a reference
3496 to a const array but whose index contains side-effects. But we can
3497 ignore things that are actual constant or that already have been
3498 handled by this function. */
3500 if (tree_invariant_p (e))
3503 switch (TREE_CODE_CLASS (code))
3505 case tcc_exceptional:
3507 case tcc_declaration:
3508 case tcc_comparison:
3510 case tcc_expression:
3513 /* If the expression has side-effects, then encase it in a SAVE_EXPR
3514 so that it will only be evaluated once. */
3515 /* The reference (r) and comparison (<) classes could be handled as
3516 below, but it is generally faster to only evaluate them once. */
3517 if (TREE_SIDE_EFFECTS (e))
3518 return save_expr (e);
3522 /* Constants need no processing. In fact, we should never reach
3527 /* Division is slow and tends to be compiled with jumps,
3528 especially the division by powers of 2 that is often
3529 found inside of an array reference. So do it just once. */
3530 if (code == TRUNC_DIV_EXPR || code == TRUNC_MOD_EXPR
3531 || code == FLOOR_DIV_EXPR || code == FLOOR_MOD_EXPR
3532 || code == CEIL_DIV_EXPR || code == CEIL_MOD_EXPR
3533 || code == ROUND_DIV_EXPR || code == ROUND_MOD_EXPR)
3534 return save_expr (e);
3535 /* Recursively stabilize each operand. */
3536 result = build_nt (code, stabilize_reference_1 (TREE_OPERAND (e, 0)),
3537 stabilize_reference_1 (TREE_OPERAND (e, 1)));
3541 /* Recursively stabilize each operand. */
3542 result = build_nt (code, stabilize_reference_1 (TREE_OPERAND (e, 0)));
3549 TREE_TYPE (result) = TREE_TYPE (e);
3550 TREE_READONLY (result) = TREE_READONLY (e);
3551 TREE_SIDE_EFFECTS (result) = TREE_SIDE_EFFECTS (e);
3552 TREE_THIS_VOLATILE (result) = TREE_THIS_VOLATILE (e);
3557 /* Low-level constructors for expressions. */
3559 /* A helper function for build1 and constant folders. Set TREE_CONSTANT,
3560 and TREE_SIDE_EFFECTS for an ADDR_EXPR. */
3563 recompute_tree_invariant_for_addr_expr (tree t)
3566 bool tc = true, se = false;
3568 /* We started out assuming this address is both invariant and constant, but
3569 does not have side effects. Now go down any handled components and see if
3570 any of them involve offsets that are either non-constant or non-invariant.
3571 Also check for side-effects.
3573 ??? Note that this code makes no attempt to deal with the case where
3574 taking the address of something causes a copy due to misalignment. */
3576 #define UPDATE_FLAGS(NODE) \
3577 do { tree _node = (NODE); \
3578 if (_node && !TREE_CONSTANT (_node)) tc = false; \
3579 if (_node && TREE_SIDE_EFFECTS (_node)) se = true; } while (0)
3581 for (node = TREE_OPERAND (t, 0); handled_component_p (node);
3582 node = TREE_OPERAND (node, 0))
3584 /* If the first operand doesn't have an ARRAY_TYPE, this is a bogus
3585 array reference (probably made temporarily by the G++ front end),
3586 so ignore all the operands. */
3587 if ((TREE_CODE (node) == ARRAY_REF
3588 || TREE_CODE (node) == ARRAY_RANGE_REF)
3589 && TREE_CODE (TREE_TYPE (TREE_OPERAND (node, 0))) == ARRAY_TYPE)
3591 UPDATE_FLAGS (TREE_OPERAND (node, 1));
3592 if (TREE_OPERAND (node, 2))
3593 UPDATE_FLAGS (TREE_OPERAND (node, 2));
3594 if (TREE_OPERAND (node, 3))
3595 UPDATE_FLAGS (TREE_OPERAND (node, 3));
3597 /* Likewise, just because this is a COMPONENT_REF doesn't mean we have a
3598 FIELD_DECL, apparently. The G++ front end can put something else
3599 there, at least temporarily. */
3600 else if (TREE_CODE (node) == COMPONENT_REF
3601 && TREE_CODE (TREE_OPERAND (node, 1)) == FIELD_DECL)
3603 if (TREE_OPERAND (node, 2))
3604 UPDATE_FLAGS (TREE_OPERAND (node, 2));
3606 else if (TREE_CODE (node) == BIT_FIELD_REF)
3607 UPDATE_FLAGS (TREE_OPERAND (node, 2));
3610 node = lang_hooks.expr_to_decl (node, &tc, &se);
3612 /* Now see what's inside. If it's an INDIRECT_REF, copy our properties from
3613 the address, since &(*a)->b is a form of addition. If it's a constant, the
3614 address is constant too. If it's a decl, its address is constant if the
3615 decl is static. Everything else is not constant and, furthermore,
3616 taking the address of a volatile variable is not volatile. */
3617 if (TREE_CODE (node) == INDIRECT_REF
3618 || TREE_CODE (node) == MEM_REF)
3619 UPDATE_FLAGS (TREE_OPERAND (node, 0));
3620 else if (CONSTANT_CLASS_P (node))
3622 else if (DECL_P (node))
3623 tc &= (staticp (node) != NULL_TREE);
3627 se |= TREE_SIDE_EFFECTS (node);
3631 TREE_CONSTANT (t) = tc;
3632 TREE_SIDE_EFFECTS (t) = se;
3636 /* Build an expression of code CODE, data type TYPE, and operands as
3637 specified. Expressions and reference nodes can be created this way.
3638 Constants, decls, types and misc nodes cannot be.
3640 We define 5 non-variadic functions, from 0 to 4 arguments. This is
3641 enough for all extant tree codes. */
3644 build0_stat (enum tree_code code, tree tt MEM_STAT_DECL)
3648 gcc_assert (TREE_CODE_LENGTH (code) == 0);
3650 t = make_node_stat (code PASS_MEM_STAT);
3657 build1_stat (enum tree_code code, tree type, tree node MEM_STAT_DECL)
3659 int length = sizeof (struct tree_exp);
3660 #ifdef GATHER_STATISTICS
3661 tree_node_kind kind;
3665 #ifdef GATHER_STATISTICS
3666 switch (TREE_CODE_CLASS (code))
3668 case tcc_statement: /* an expression with side effects */
3671 case tcc_reference: /* a reference */
3679 tree_node_counts[(int) kind]++;
3680 tree_node_sizes[(int) kind] += length;
3683 gcc_assert (TREE_CODE_LENGTH (code) == 1);
3685 t = ggc_alloc_zone_tree_node_stat (&tree_zone, length PASS_MEM_STAT);
3687 memset (t, 0, sizeof (struct tree_common));
3689 TREE_SET_CODE (t, code);
3691 TREE_TYPE (t) = type;
3692 SET_EXPR_LOCATION (t, UNKNOWN_LOCATION);
3693 TREE_OPERAND (t, 0) = node;
3694 TREE_BLOCK (t) = NULL_TREE;
3695 if (node && !TYPE_P (node))
3697 TREE_SIDE_EFFECTS (t) = TREE_SIDE_EFFECTS (node);
3698 TREE_READONLY (t) = TREE_READONLY (node);
3701 if (TREE_CODE_CLASS (code) == tcc_statement)
3702 TREE_SIDE_EFFECTS (t) = 1;
3706 /* All of these have side-effects, no matter what their
3708 TREE_SIDE_EFFECTS (t) = 1;
3709 TREE_READONLY (t) = 0;
3713 /* Whether a dereference is readonly has nothing to do with whether
3714 its operand is readonly. */
3715 TREE_READONLY (t) = 0;
3720 recompute_tree_invariant_for_addr_expr (t);
3724 if ((TREE_CODE_CLASS (code) == tcc_unary || code == VIEW_CONVERT_EXPR)
3725 && node && !TYPE_P (node)
3726 && TREE_CONSTANT (node))
3727 TREE_CONSTANT (t) = 1;
3728 if (TREE_CODE_CLASS (code) == tcc_reference
3729 && node && TREE_THIS_VOLATILE (node))
3730 TREE_THIS_VOLATILE (t) = 1;
3737 #define PROCESS_ARG(N) \
3739 TREE_OPERAND (t, N) = arg##N; \
3740 if (arg##N &&!TYPE_P (arg##N)) \
3742 if (TREE_SIDE_EFFECTS (arg##N)) \
3744 if (!TREE_READONLY (arg##N) \
3745 && !CONSTANT_CLASS_P (arg##N)) \
3746 (void) (read_only = 0); \
3747 if (!TREE_CONSTANT (arg##N)) \
3748 (void) (constant = 0); \
3753 build2_stat (enum tree_code code, tree tt, tree arg0, tree arg1 MEM_STAT_DECL)
3755 bool constant, read_only, side_effects;
3758 gcc_assert (TREE_CODE_LENGTH (code) == 2);
3760 if ((code == MINUS_EXPR || code == PLUS_EXPR || code == MULT_EXPR)
3761 && arg0 && arg1 && tt && POINTER_TYPE_P (tt)
3762 /* When sizetype precision doesn't match that of pointers
3763 we need to be able to build explicit extensions or truncations
3764 of the offset argument. */
3765 && TYPE_PRECISION (sizetype) == TYPE_PRECISION (tt))
3766 gcc_assert (TREE_CODE (arg0) == INTEGER_CST
3767 && TREE_CODE (arg1) == INTEGER_CST);
3769 if (code == POINTER_PLUS_EXPR && arg0 && arg1 && tt)
3770 gcc_assert (POINTER_TYPE_P (tt) && POINTER_TYPE_P (TREE_TYPE (arg0))
3771 && INTEGRAL_TYPE_P (TREE_TYPE (arg1))
3772 && useless_type_conversion_p (sizetype, TREE_TYPE (arg1)));
3774 t = make_node_stat (code PASS_MEM_STAT);
3777 /* Below, we automatically set TREE_SIDE_EFFECTS and TREE_READONLY for the
3778 result based on those same flags for the arguments. But if the
3779 arguments aren't really even `tree' expressions, we shouldn't be trying
3782 /* Expressions without side effects may be constant if their
3783 arguments are as well. */
3784 constant = (TREE_CODE_CLASS (code) == tcc_comparison
3785 || TREE_CODE_CLASS (code) == tcc_binary);
3787 side_effects = TREE_SIDE_EFFECTS (t);
3792 TREE_READONLY (t) = read_only;
3793 TREE_CONSTANT (t) = constant;
3794 TREE_SIDE_EFFECTS (t) = side_effects;
3795 TREE_THIS_VOLATILE (t)
3796 = (TREE_CODE_CLASS (code) == tcc_reference
3797 && arg0 && TREE_THIS_VOLATILE (arg0));
3804 build3_stat (enum tree_code code, tree tt, tree arg0, tree arg1,
3805 tree arg2 MEM_STAT_DECL)
3807 bool constant, read_only, side_effects;
3810 gcc_assert (TREE_CODE_LENGTH (code) == 3);
3811 gcc_assert (TREE_CODE_CLASS (code) != tcc_vl_exp);
3813 t = make_node_stat (code PASS_MEM_STAT);
3818 /* As a special exception, if COND_EXPR has NULL branches, we
3819 assume that it is a gimple statement and always consider
3820 it to have side effects. */
3821 if (code == COND_EXPR
3822 && tt == void_type_node
3823 && arg1 == NULL_TREE
3824 && arg2 == NULL_TREE)
3825 side_effects = true;
3827 side_effects = TREE_SIDE_EFFECTS (t);
3833 if (code == COND_EXPR)
3834 TREE_READONLY (t) = read_only;
3836 TREE_SIDE_EFFECTS (t) = side_effects;
3837 TREE_THIS_VOLATILE (t)
3838 = (TREE_CODE_CLASS (code) == tcc_reference
3839 && arg0 && TREE_THIS_VOLATILE (arg0));
3845 build4_stat (enum tree_code code, tree tt, tree arg0, tree arg1,
3846 tree arg2, tree arg3 MEM_STAT_DECL)
3848 bool constant, read_only, side_effects;
3851 gcc_assert (TREE_CODE_LENGTH (code) == 4);
3853 t = make_node_stat (code PASS_MEM_STAT);
3856 side_effects = TREE_SIDE_EFFECTS (t);
3863 TREE_SIDE_EFFECTS (t) = side_effects;
3864 TREE_THIS_VOLATILE (t)
3865 = (TREE_CODE_CLASS (code) == tcc_reference
3866 && arg0 && TREE_THIS_VOLATILE (arg0));
3872 build5_stat (enum tree_code code, tree tt, tree arg0, tree arg1,
3873 tree arg2, tree arg3, tree arg4 MEM_STAT_DECL)
3875 bool constant, read_only, side_effects;
3878 gcc_assert (TREE_CODE_LENGTH (code) == 5);
3880 t = make_node_stat (code PASS_MEM_STAT);
3883 side_effects = TREE_SIDE_EFFECTS (t);
3891 TREE_SIDE_EFFECTS (t) = side_effects;
3892 TREE_THIS_VOLATILE (t)
3893 = (TREE_CODE_CLASS (code) == tcc_reference
3894 && arg0 && TREE_THIS_VOLATILE (arg0));
3900 build6_stat (enum tree_code code, tree tt, tree arg0, tree arg1,
3901 tree arg2, tree arg3, tree arg4, tree arg5 MEM_STAT_DECL)
3903 bool constant, read_only, side_effects;
3906 gcc_assert (code == TARGET_MEM_REF);
3908 t = make_node_stat (code PASS_MEM_STAT);
3911 side_effects = TREE_SIDE_EFFECTS (t);
3918 if (code == TARGET_MEM_REF)
3922 TREE_SIDE_EFFECTS (t) = side_effects;
3923 TREE_THIS_VOLATILE (t)
3924 = (code == TARGET_MEM_REF
3925 && arg5 && TREE_THIS_VOLATILE (arg5));
3930 /* Build a simple MEM_REF tree with the sematics of a plain INDIRECT_REF
3931 on the pointer PTR. */
3934 build_simple_mem_ref_loc (location_t loc, tree ptr)
3936 HOST_WIDE_INT offset = 0;
3937 tree ptype = TREE_TYPE (ptr);
3939 /* For convenience allow addresses that collapse to a simple base
3941 if (TREE_CODE (ptr) == ADDR_EXPR
3942 && (handled_component_p (TREE_OPERAND (ptr, 0))
3943 || TREE_CODE (TREE_OPERAND (ptr, 0)) == MEM_REF))
3945 ptr = get_addr_base_and_unit_offset (TREE_OPERAND (ptr, 0), &offset);
3947 ptr = build_fold_addr_expr (ptr);
3948 gcc_assert (is_gimple_reg (ptr) || is_gimple_min_invariant (ptr));
3950 tem = build2 (MEM_REF, TREE_TYPE (ptype),
3951 ptr, build_int_cst (ptype, offset));
3952 SET_EXPR_LOCATION (tem, loc);
3956 /* Return the constant offset of a MEM_REF or TARGET_MEM_REF tree T. */
3959 mem_ref_offset (const_tree t)
3961 tree toff = TREE_OPERAND (t, 1);
3962 return double_int_sext (tree_to_double_int (toff),
3963 TYPE_PRECISION (TREE_TYPE (toff)));
3966 /* Return the pointer-type relevant for TBAA purposes from the
3967 gimple memory reference tree T. This is the type to be used for
3968 the offset operand of MEM_REF or TARGET_MEM_REF replacements of T. */
3971 reference_alias_ptr_type (const_tree t)
3973 const_tree base = t;
3974 while (handled_component_p (base))
3975 base = TREE_OPERAND (base, 0);
3976 if (TREE_CODE (base) == MEM_REF)
3977 return TREE_TYPE (TREE_OPERAND (base, 1));
3978 else if (TREE_CODE (base) == TARGET_MEM_REF)
3979 return TREE_TYPE (TMR_OFFSET (base));
3981 return build_pointer_type (TYPE_MAIN_VARIANT (TREE_TYPE (base)));
3984 /* Similar except don't specify the TREE_TYPE
3985 and leave the TREE_SIDE_EFFECTS as 0.
3986 It is permissible for arguments to be null,
3987 or even garbage if their values do not matter. */
3990 build_nt (enum tree_code code, ...)
3997 gcc_assert (TREE_CODE_CLASS (code) != tcc_vl_exp);
4001 t = make_node (code);
4002 length = TREE_CODE_LENGTH (code);
4004 for (i = 0; i < length; i++)
4005 TREE_OPERAND (t, i) = va_arg (p, tree);
4011 /* Similar to build_nt, but for creating a CALL_EXPR object with a
4015 build_nt_call_vec (tree fn, VEC(tree,gc) *args)
4020 ret = build_vl_exp (CALL_EXPR, VEC_length (tree, args) + 3);
4021 CALL_EXPR_FN (ret) = fn;
4022 CALL_EXPR_STATIC_CHAIN (ret) = NULL_TREE;
4023 FOR_EACH_VEC_ELT (tree, args, ix, t)
4024 CALL_EXPR_ARG (ret, ix) = t;
4028 /* Create a DECL_... node of code CODE, name NAME and data type TYPE.
4029 We do NOT enter this node in any sort of symbol table.
4031 LOC is the location of the decl.
4033 layout_decl is used to set up the decl's storage layout.
4034 Other slots are initialized to 0 or null pointers. */
4037 build_decl_stat (location_t loc, enum tree_code code, tree name,
4038 tree type MEM_STAT_DECL)
4042 t = make_node_stat (code PASS_MEM_STAT);
4043 DECL_SOURCE_LOCATION (t) = loc;
4045 /* if (type == error_mark_node)
4046 type = integer_type_node; */
4047 /* That is not done, deliberately, so that having error_mark_node
4048 as the type can suppress useless errors in the use of this variable. */
4050 DECL_NAME (t) = name;
4051 TREE_TYPE (t) = type;
4053 if (code == VAR_DECL || code == PARM_DECL || code == RESULT_DECL)
4059 /* Builds and returns function declaration with NAME and TYPE. */
4062 build_fn_decl (const char *name, tree type)
4064 tree id = get_identifier (name);
4065 tree decl = build_decl (input_location, FUNCTION_DECL, id, type);
4067 DECL_EXTERNAL (decl) = 1;
4068 TREE_PUBLIC (decl) = 1;
4069 DECL_ARTIFICIAL (decl) = 1;
4070 TREE_NOTHROW (decl) = 1;
4075 VEC(tree,gc) *all_translation_units;
4077 /* Builds a new translation-unit decl with name NAME, queues it in the
4078 global list of translation-unit decls and returns it. */
4081 build_translation_unit_decl (tree name)
4083 tree tu = build_decl (UNKNOWN_LOCATION, TRANSLATION_UNIT_DECL,
4085 TRANSLATION_UNIT_LANGUAGE (tu) = lang_hooks.name;
4086 VEC_safe_push (tree, gc, all_translation_units, tu);
4091 /* BLOCK nodes are used to represent the structure of binding contours
4092 and declarations, once those contours have been exited and their contents
4093 compiled. This information is used for outputting debugging info. */
4096 build_block (tree vars, tree subblocks, tree supercontext, tree chain)
4098 tree block = make_node (BLOCK);
4100 BLOCK_VARS (block) = vars;
4101 BLOCK_SUBBLOCKS (block) = subblocks;
4102 BLOCK_SUPERCONTEXT (block) = supercontext;
4103 BLOCK_CHAIN (block) = chain;
4108 /* Like SET_EXPR_LOCATION, but make sure the tree can have a location.
4110 LOC is the location to use in tree T. */
4113 protected_set_expr_location (tree t, location_t loc)
4115 if (t && CAN_HAVE_LOCATION_P (t))
4116 SET_EXPR_LOCATION (t, loc);
4119 /* Return a declaration like DDECL except that its DECL_ATTRIBUTES
4123 build_decl_attribute_variant (tree ddecl, tree attribute)
4125 DECL_ATTRIBUTES (ddecl) = attribute;
4129 /* Borrowed from hashtab.c iterative_hash implementation. */
4130 #define mix(a,b,c) \
4132 a -= b; a -= c; a ^= (c>>13); \
4133 b -= c; b -= a; b ^= (a<< 8); \
4134 c -= a; c -= b; c ^= ((b&0xffffffff)>>13); \
4135 a -= b; a -= c; a ^= ((c&0xffffffff)>>12); \
4136 b -= c; b -= a; b = (b ^ (a<<16)) & 0xffffffff; \
4137 c -= a; c -= b; c = (c ^ (b>> 5)) & 0xffffffff; \
4138 a -= b; a -= c; a = (a ^ (c>> 3)) & 0xffffffff; \
4139 b -= c; b -= a; b = (b ^ (a<<10)) & 0xffffffff; \
4140 c -= a; c -= b; c = (c ^ (b>>15)) & 0xffffffff; \
4144 /* Produce good hash value combining VAL and VAL2. */
4146 iterative_hash_hashval_t (hashval_t val, hashval_t val2)
4148 /* the golden ratio; an arbitrary value. */
4149 hashval_t a = 0x9e3779b9;
4155 /* Produce good hash value combining VAL and VAL2. */
4157 iterative_hash_host_wide_int (HOST_WIDE_INT val, hashval_t val2)
4159 if (sizeof (HOST_WIDE_INT) == sizeof (hashval_t))
4160 return iterative_hash_hashval_t (val, val2);
4163 hashval_t a = (hashval_t) val;
4164 /* Avoid warnings about shifting of more than the width of the type on
4165 hosts that won't execute this path. */
4167 hashval_t b = (hashval_t) (val >> (sizeof (hashval_t) * 8 + zero));
4169 if (sizeof (HOST_WIDE_INT) > 2 * sizeof (hashval_t))
4171 hashval_t a = (hashval_t) (val >> (sizeof (hashval_t) * 16 + zero));
4172 hashval_t b = (hashval_t) (val >> (sizeof (hashval_t) * 24 + zero));
4179 /* Return a type like TTYPE except that its TYPE_ATTRIBUTE
4180 is ATTRIBUTE and its qualifiers are QUALS.
4182 Record such modified types already made so we don't make duplicates. */
4185 build_type_attribute_qual_variant (tree ttype, tree attribute, int quals)
4187 if (! attribute_list_equal (TYPE_ATTRIBUTES (ttype), attribute))
4189 hashval_t hashcode = 0;
4191 enum tree_code code = TREE_CODE (ttype);
4193 /* Building a distinct copy of a tagged type is inappropriate; it
4194 causes breakage in code that expects there to be a one-to-one
4195 relationship between a struct and its fields.
4196 build_duplicate_type is another solution (as used in
4197 handle_transparent_union_attribute), but that doesn't play well
4198 with the stronger C++ type identity model. */
4199 if (TREE_CODE (ttype) == RECORD_TYPE
4200 || TREE_CODE (ttype) == UNION_TYPE
4201 || TREE_CODE (ttype) == QUAL_UNION_TYPE
4202 || TREE_CODE (ttype) == ENUMERAL_TYPE)
4204 warning (OPT_Wattributes,
4205 "ignoring attributes applied to %qT after definition",
4206 TYPE_MAIN_VARIANT (ttype));
4207 return build_qualified_type (ttype, quals);
4210 ttype = build_qualified_type (ttype, TYPE_UNQUALIFIED);
4211 ntype = build_distinct_type_copy (ttype);
4213 TYPE_ATTRIBUTES (ntype) = attribute;
4215 hashcode = iterative_hash_object (code, hashcode);
4216 if (TREE_TYPE (ntype))
4217 hashcode = iterative_hash_object (TYPE_HASH (TREE_TYPE (ntype)),
4219 hashcode = attribute_hash_list (attribute, hashcode);
4221 switch (TREE_CODE (ntype))
4224 hashcode = type_hash_list (TYPE_ARG_TYPES (ntype), hashcode);
4227 if (TYPE_DOMAIN (ntype))
4228 hashcode = iterative_hash_object (TYPE_HASH (TYPE_DOMAIN (ntype)),
4232 hashcode = iterative_hash_object
4233 (TREE_INT_CST_LOW (TYPE_MAX_VALUE (ntype)), hashcode);
4234 hashcode = iterative_hash_object
4235 (TREE_INT_CST_HIGH (TYPE_MAX_VALUE (ntype)), hashcode);
4238 case FIXED_POINT_TYPE:
4240 unsigned int precision = TYPE_PRECISION (ntype);
4241 hashcode = iterative_hash_object (precision, hashcode);
4248 ntype = type_hash_canon (hashcode, ntype);
4250 /* If the target-dependent attributes make NTYPE different from
4251 its canonical type, we will need to use structural equality
4252 checks for this type. */
4253 if (TYPE_STRUCTURAL_EQUALITY_P (ttype)
4254 || !targetm.comp_type_attributes (ntype, ttype))
4255 SET_TYPE_STRUCTURAL_EQUALITY (ntype);
4256 else if (TYPE_CANONICAL (ntype) == ntype)
4257 TYPE_CANONICAL (ntype) = TYPE_CANONICAL (ttype);
4259 ttype = build_qualified_type (ntype, quals);
4261 else if (TYPE_QUALS (ttype) != quals)
4262 ttype = build_qualified_type (ttype, quals);
4268 /* Return a type like TTYPE except that its TYPE_ATTRIBUTE
4271 Record such modified types already made so we don't make duplicates. */
4274 build_type_attribute_variant (tree ttype, tree attribute)
4276 return build_type_attribute_qual_variant (ttype, attribute,
4277 TYPE_QUALS (ttype));
4281 /* Reset the expression *EXPR_P, a size or position.
4283 ??? We could reset all non-constant sizes or positions. But it's cheap
4284 enough to not do so and refrain from adding workarounds to dwarf2out.c.
4286 We need to reset self-referential sizes or positions because they cannot
4287 be gimplified and thus can contain a CALL_EXPR after the gimplification
4288 is finished, which will run afoul of LTO streaming. And they need to be
4289 reset to something essentially dummy but not constant, so as to preserve
4290 the properties of the object they are attached to. */
4293 free_lang_data_in_one_sizepos (tree *expr_p)
4295 tree expr = *expr_p;
4296 if (CONTAINS_PLACEHOLDER_P (expr))
4297 *expr_p = build0 (PLACEHOLDER_EXPR, TREE_TYPE (expr));
4301 /* Reset all the fields in a binfo node BINFO. We only keep
4302 BINFO_VIRTUALS, which is used by gimple_fold_obj_type_ref. */
4305 free_lang_data_in_binfo (tree binfo)
4310 gcc_assert (TREE_CODE (binfo) == TREE_BINFO);
4312 BINFO_VTABLE (binfo) = NULL_TREE;
4313 BINFO_BASE_ACCESSES (binfo) = NULL;
4314 BINFO_INHERITANCE_CHAIN (binfo) = NULL_TREE;
4315 BINFO_SUBVTT_INDEX (binfo) = NULL_TREE;
4317 FOR_EACH_VEC_ELT (tree, BINFO_BASE_BINFOS (binfo), i, t)
4318 free_lang_data_in_binfo (t);
4322 /* Reset all language specific information still present in TYPE. */
4325 free_lang_data_in_type (tree type)
4327 gcc_assert (TYPE_P (type));
4329 /* Give the FE a chance to remove its own data first. */
4330 lang_hooks.free_lang_data (type);
4332 TREE_LANG_FLAG_0 (type) = 0;
4333 TREE_LANG_FLAG_1 (type) = 0;
4334 TREE_LANG_FLAG_2 (type) = 0;
4335 TREE_LANG_FLAG_3 (type) = 0;
4336 TREE_LANG_FLAG_4 (type) = 0;
4337 TREE_LANG_FLAG_5 (type) = 0;
4338 TREE_LANG_FLAG_6 (type) = 0;
4340 if (TREE_CODE (type) == FUNCTION_TYPE)
4342 /* Remove the const and volatile qualifiers from arguments. The
4343 C++ front end removes them, but the C front end does not,
4344 leading to false ODR violation errors when merging two
4345 instances of the same function signature compiled by
4346 different front ends. */
4349 for (p = TYPE_ARG_TYPES (type); p; p = TREE_CHAIN (p))
4351 tree arg_type = TREE_VALUE (p);
4353 if (TYPE_READONLY (arg_type) || TYPE_VOLATILE (arg_type))
4355 int quals = TYPE_QUALS (arg_type)
4357 & ~TYPE_QUAL_VOLATILE;
4358 TREE_VALUE (p) = build_qualified_type (arg_type, quals);
4359 free_lang_data_in_type (TREE_VALUE (p));
4364 /* Remove members that are not actually FIELD_DECLs from the field
4365 list of an aggregate. These occur in C++. */
4366 if (RECORD_OR_UNION_TYPE_P (type))
4370 /* Note that TYPE_FIELDS can be shared across distinct
4371 TREE_TYPEs. Therefore, if the first field of TYPE_FIELDS is
4372 to be removed, we cannot set its TREE_CHAIN to NULL.
4373 Otherwise, we would not be able to find all the other fields
4374 in the other instances of this TREE_TYPE.
4376 This was causing an ICE in testsuite/g++.dg/lto/20080915.C. */
4378 member = TYPE_FIELDS (type);
4381 if (TREE_CODE (member) == FIELD_DECL)
4384 TREE_CHAIN (prev) = member;
4386 TYPE_FIELDS (type) = member;
4390 member = TREE_CHAIN (member);
4394 TREE_CHAIN (prev) = NULL_TREE;
4396 TYPE_FIELDS (type) = NULL_TREE;
4398 TYPE_METHODS (type) = NULL_TREE;
4399 if (TYPE_BINFO (type))
4400 free_lang_data_in_binfo (TYPE_BINFO (type));
4404 /* For non-aggregate types, clear out the language slot (which
4405 overloads TYPE_BINFO). */
4406 TYPE_LANG_SLOT_1 (type) = NULL_TREE;
4408 if (INTEGRAL_TYPE_P (type)
4409 || SCALAR_FLOAT_TYPE_P (type)
4410 || FIXED_POINT_TYPE_P (type))
4412 free_lang_data_in_one_sizepos (&TYPE_MIN_VALUE (type));
4413 free_lang_data_in_one_sizepos (&TYPE_MAX_VALUE (type));
4417 free_lang_data_in_one_sizepos (&TYPE_SIZE (type));
4418 free_lang_data_in_one_sizepos (&TYPE_SIZE_UNIT (type));
4420 if (debug_info_level < DINFO_LEVEL_TERSE
4421 || (TYPE_CONTEXT (type)
4422 && TREE_CODE (TYPE_CONTEXT (type)) != FUNCTION_DECL
4423 && TREE_CODE (TYPE_CONTEXT (type)) != NAMESPACE_DECL))
4424 TYPE_CONTEXT (type) = NULL_TREE;
4426 if (debug_info_level < DINFO_LEVEL_TERSE)
4427 TYPE_STUB_DECL (type) = NULL_TREE;
4431 /* Return true if DECL may need an assembler name to be set. */
4434 need_assembler_name_p (tree decl)
4436 /* Only FUNCTION_DECLs and VAR_DECLs are considered. */
4437 if (TREE_CODE (decl) != FUNCTION_DECL
4438 && TREE_CODE (decl) != VAR_DECL)
4441 /* If DECL already has its assembler name set, it does not need a
4443 if (!HAS_DECL_ASSEMBLER_NAME_P (decl)
4444 || DECL_ASSEMBLER_NAME_SET_P (decl))
4447 /* Abstract decls do not need an assembler name. */
4448 if (DECL_ABSTRACT (decl))
4451 /* For VAR_DECLs, only static, public and external symbols need an
4453 if (TREE_CODE (decl) == VAR_DECL
4454 && !TREE_STATIC (decl)
4455 && !TREE_PUBLIC (decl)
4456 && !DECL_EXTERNAL (decl))
4459 if (TREE_CODE (decl) == FUNCTION_DECL)
4461 /* Do not set assembler name on builtins. Allow RTL expansion to
4462 decide whether to expand inline or via a regular call. */
4463 if (DECL_BUILT_IN (decl)
4464 && DECL_BUILT_IN_CLASS (decl) != BUILT_IN_FRONTEND)
4467 /* Functions represented in the callgraph need an assembler name. */
4468 if (cgraph_get_node (decl) != NULL)
4471 /* Unused and not public functions don't need an assembler name. */
4472 if (!TREE_USED (decl) && !TREE_PUBLIC (decl))
4480 /* Reset all language specific information still present in symbol
4484 free_lang_data_in_decl (tree decl)
4486 gcc_assert (DECL_P (decl));
4488 /* Give the FE a chance to remove its own data first. */
4489 lang_hooks.free_lang_data (decl);
4491 TREE_LANG_FLAG_0 (decl) = 0;
4492 TREE_LANG_FLAG_1 (decl) = 0;
4493 TREE_LANG_FLAG_2 (decl) = 0;
4494 TREE_LANG_FLAG_3 (decl) = 0;
4495 TREE_LANG_FLAG_4 (decl) = 0;
4496 TREE_LANG_FLAG_5 (decl) = 0;
4497 TREE_LANG_FLAG_6 (decl) = 0;
4499 /* Identifiers need not have a type. */
4500 if (DECL_NAME (decl))
4501 TREE_TYPE (DECL_NAME (decl)) = NULL_TREE;
4503 free_lang_data_in_one_sizepos (&DECL_SIZE (decl));
4504 free_lang_data_in_one_sizepos (&DECL_SIZE_UNIT (decl));
4505 if (TREE_CODE (decl) == FIELD_DECL)
4506 free_lang_data_in_one_sizepos (&DECL_FIELD_OFFSET (decl));
4508 /* DECL_FCONTEXT is only used for debug info generation. */
4509 if (TREE_CODE (decl) == FIELD_DECL
4510 && debug_info_level < DINFO_LEVEL_TERSE)
4511 DECL_FCONTEXT (decl) = NULL_TREE;
4513 if (TREE_CODE (decl) == FUNCTION_DECL)
4515 if (gimple_has_body_p (decl))
4519 /* If DECL has a gimple body, then the context for its
4520 arguments must be DECL. Otherwise, it doesn't really
4521 matter, as we will not be emitting any code for DECL. In
4522 general, there may be other instances of DECL created by
4523 the front end and since PARM_DECLs are generally shared,
4524 their DECL_CONTEXT changes as the replicas of DECL are
4525 created. The only time where DECL_CONTEXT is important
4526 is for the FUNCTION_DECLs that have a gimple body (since
4527 the PARM_DECL will be used in the function's body). */
4528 for (t = DECL_ARGUMENTS (decl); t; t = TREE_CHAIN (t))
4529 DECL_CONTEXT (t) = decl;
4532 /* DECL_SAVED_TREE holds the GENERIC representation for DECL.
4533 At this point, it is not needed anymore. */
4534 DECL_SAVED_TREE (decl) = NULL_TREE;
4536 /* Clear the abstract origin if it refers to a method. Otherwise
4537 dwarf2out.c will ICE as we clear TYPE_METHODS and thus the
4538 origin will not be output correctly. */
4539 if (DECL_ABSTRACT_ORIGIN (decl)
4540 && DECL_CONTEXT (DECL_ABSTRACT_ORIGIN (decl))
4541 && RECORD_OR_UNION_TYPE_P
4542 (DECL_CONTEXT (DECL_ABSTRACT_ORIGIN (decl))))
4543 DECL_ABSTRACT_ORIGIN (decl) = NULL_TREE;
4545 else if (TREE_CODE (decl) == VAR_DECL)
4547 if ((DECL_EXTERNAL (decl)
4548 && (!TREE_STATIC (decl) || !TREE_READONLY (decl)))
4549 || (decl_function_context (decl) && !TREE_STATIC (decl)))
4550 DECL_INITIAL (decl) = NULL_TREE;
4552 else if (TREE_CODE (decl) == TYPE_DECL)
4553 DECL_INITIAL (decl) = NULL_TREE;
4557 /* Data used when collecting DECLs and TYPEs for language data removal. */
4559 struct free_lang_data_d
4561 /* Worklist to avoid excessive recursion. */
4562 VEC(tree,heap) *worklist;
4564 /* Set of traversed objects. Used to avoid duplicate visits. */
4565 struct pointer_set_t *pset;
4567 /* Array of symbols to process with free_lang_data_in_decl. */
4568 VEC(tree,heap) *decls;
4570 /* Array of types to process with free_lang_data_in_type. */
4571 VEC(tree,heap) *types;
4575 /* Save all language fields needed to generate proper debug information
4576 for DECL. This saves most fields cleared out by free_lang_data_in_decl. */
4579 save_debug_info_for_decl (tree t)
4581 /*struct saved_debug_info_d *sdi;*/
4583 gcc_assert (debug_info_level > DINFO_LEVEL_TERSE && t && DECL_P (t));
4585 /* FIXME. Partial implementation for saving debug info removed. */
4589 /* Save all language fields needed to generate proper debug information
4590 for TYPE. This saves most fields cleared out by free_lang_data_in_type. */
4593 save_debug_info_for_type (tree t)
4595 /*struct saved_debug_info_d *sdi;*/
4597 gcc_assert (debug_info_level > DINFO_LEVEL_TERSE && t && TYPE_P (t));
4599 /* FIXME. Partial implementation for saving debug info removed. */
4603 /* Add type or decl T to one of the list of tree nodes that need their
4604 language data removed. The lists are held inside FLD. */
4607 add_tree_to_fld_list (tree t, struct free_lang_data_d *fld)
4611 VEC_safe_push (tree, heap, fld->decls, t);
4612 if (debug_info_level > DINFO_LEVEL_TERSE)
4613 save_debug_info_for_decl (t);
4615 else if (TYPE_P (t))
4617 VEC_safe_push (tree, heap, fld->types, t);
4618 if (debug_info_level > DINFO_LEVEL_TERSE)
4619 save_debug_info_for_type (t);
4625 /* Push tree node T into FLD->WORKLIST. */
4628 fld_worklist_push (tree t, struct free_lang_data_d *fld)
4630 if (t && !is_lang_specific (t) && !pointer_set_contains (fld->pset, t))
4631 VEC_safe_push (tree, heap, fld->worklist, (t));
4635 /* Operand callback helper for free_lang_data_in_node. *TP is the
4636 subtree operand being considered. */
4639 find_decls_types_r (tree *tp, int *ws, void *data)
4642 struct free_lang_data_d *fld = (struct free_lang_data_d *) data;
4644 if (TREE_CODE (t) == TREE_LIST)
4647 /* Language specific nodes will be removed, so there is no need
4648 to gather anything under them. */
4649 if (is_lang_specific (t))
4657 /* Note that walk_tree does not traverse every possible field in
4658 decls, so we have to do our own traversals here. */
4659 add_tree_to_fld_list (t, fld);
4661 fld_worklist_push (DECL_NAME (t), fld);
4662 fld_worklist_push (DECL_CONTEXT (t), fld);
4663 fld_worklist_push (DECL_SIZE (t), fld);
4664 fld_worklist_push (DECL_SIZE_UNIT (t), fld);
4666 /* We are going to remove everything under DECL_INITIAL for
4667 TYPE_DECLs. No point walking them. */
4668 if (TREE_CODE (t) != TYPE_DECL)
4669 fld_worklist_push (DECL_INITIAL (t), fld);
4671 fld_worklist_push (DECL_ATTRIBUTES (t), fld);
4672 fld_worklist_push (DECL_ABSTRACT_ORIGIN (t), fld);
4674 if (TREE_CODE (t) == FUNCTION_DECL)
4676 fld_worklist_push (DECL_ARGUMENTS (t), fld);
4677 fld_worklist_push (DECL_RESULT (t), fld);
4679 else if (TREE_CODE (t) == TYPE_DECL)
4681 fld_worklist_push (DECL_ARGUMENT_FLD (t), fld);
4682 fld_worklist_push (DECL_VINDEX (t), fld);
4684 else if (TREE_CODE (t) == FIELD_DECL)
4686 fld_worklist_push (DECL_FIELD_OFFSET (t), fld);
4687 fld_worklist_push (DECL_BIT_FIELD_TYPE (t), fld);
4688 fld_worklist_push (DECL_QUALIFIER (t), fld);
4689 fld_worklist_push (DECL_FIELD_BIT_OFFSET (t), fld);
4690 fld_worklist_push (DECL_FCONTEXT (t), fld);
4692 else if (TREE_CODE (t) == VAR_DECL)
4694 fld_worklist_push (DECL_SECTION_NAME (t), fld);
4695 fld_worklist_push (DECL_COMDAT_GROUP (t), fld);
4698 if ((TREE_CODE (t) == VAR_DECL || TREE_CODE (t) == PARM_DECL)
4699 && DECL_HAS_VALUE_EXPR_P (t))
4700 fld_worklist_push (DECL_VALUE_EXPR (t), fld);
4702 if (TREE_CODE (t) != FIELD_DECL
4703 && TREE_CODE (t) != TYPE_DECL)
4704 fld_worklist_push (TREE_CHAIN (t), fld);
4707 else if (TYPE_P (t))
4709 /* Note that walk_tree does not traverse every possible field in
4710 types, so we have to do our own traversals here. */
4711 add_tree_to_fld_list (t, fld);
4713 if (!RECORD_OR_UNION_TYPE_P (t))
4714 fld_worklist_push (TYPE_CACHED_VALUES (t), fld);
4715 fld_worklist_push (TYPE_SIZE (t), fld);
4716 fld_worklist_push (TYPE_SIZE_UNIT (t), fld);
4717 fld_worklist_push (TYPE_ATTRIBUTES (t), fld);
4718 fld_worklist_push (TYPE_POINTER_TO (t), fld);
4719 fld_worklist_push (TYPE_REFERENCE_TO (t), fld);
4720 fld_worklist_push (TYPE_NAME (t), fld);
4721 /* Do not walk TYPE_NEXT_PTR_TO or TYPE_NEXT_REF_TO. We do not stream
4722 them and thus do not and want not to reach unused pointer types
4724 if (!POINTER_TYPE_P (t))
4725 fld_worklist_push (TYPE_MINVAL (t), fld);
4726 if (!RECORD_OR_UNION_TYPE_P (t))
4727 fld_worklist_push (TYPE_MAXVAL (t), fld);
4728 fld_worklist_push (TYPE_MAIN_VARIANT (t), fld);
4729 /* Do not walk TYPE_NEXT_VARIANT. We do not stream it and thus
4730 do not and want not to reach unused variants this way. */
4731 fld_worklist_push (TYPE_CONTEXT (t), fld);
4732 /* Do not walk TYPE_CANONICAL. We do not stream it and thus do not
4733 and want not to reach unused types this way. */
4735 if (RECORD_OR_UNION_TYPE_P (t) && TYPE_BINFO (t))
4739 for (i = 0; VEC_iterate (tree, BINFO_BASE_BINFOS (TYPE_BINFO (t)),
4741 fld_worklist_push (TREE_TYPE (tem), fld);
4742 tem = BINFO_VIRTUALS (TYPE_BINFO (t));
4744 /* The Java FE overloads BINFO_VIRTUALS for its own purpose. */
4745 && TREE_CODE (tem) == TREE_LIST)
4748 fld_worklist_push (TREE_VALUE (tem), fld);
4749 tem = TREE_CHAIN (tem);
4753 if (RECORD_OR_UNION_TYPE_P (t))
4756 /* Push all TYPE_FIELDS - there can be interleaving interesting
4757 and non-interesting things. */
4758 tem = TYPE_FIELDS (t);
4761 if (TREE_CODE (tem) == FIELD_DECL)
4762 fld_worklist_push (tem, fld);
4763 tem = TREE_CHAIN (tem);
4767 fld_worklist_push (TREE_CHAIN (t), fld);
4770 else if (TREE_CODE (t) == BLOCK)
4773 for (tem = BLOCK_VARS (t); tem; tem = TREE_CHAIN (tem))
4774 fld_worklist_push (tem, fld);
4775 for (tem = BLOCK_SUBBLOCKS (t); tem; tem = BLOCK_CHAIN (tem))
4776 fld_worklist_push (tem, fld);
4777 fld_worklist_push (BLOCK_ABSTRACT_ORIGIN (t), fld);
4780 fld_worklist_push (TREE_TYPE (t), fld);
4786 /* Find decls and types in T. */
4789 find_decls_types (tree t, struct free_lang_data_d *fld)
4793 if (!pointer_set_contains (fld->pset, t))
4794 walk_tree (&t, find_decls_types_r, fld, fld->pset);
4795 if (VEC_empty (tree, fld->worklist))
4797 t = VEC_pop (tree, fld->worklist);
4801 /* Translate all the types in LIST with the corresponding runtime
4805 get_eh_types_for_runtime (tree list)
4809 if (list == NULL_TREE)
4812 head = build_tree_list (0, lookup_type_for_runtime (TREE_VALUE (list)));
4814 list = TREE_CHAIN (list);
4817 tree n = build_tree_list (0, lookup_type_for_runtime (TREE_VALUE (list)));
4818 TREE_CHAIN (prev) = n;
4819 prev = TREE_CHAIN (prev);
4820 list = TREE_CHAIN (list);
4827 /* Find decls and types referenced in EH region R and store them in
4828 FLD->DECLS and FLD->TYPES. */
4831 find_decls_types_in_eh_region (eh_region r, struct free_lang_data_d *fld)
4842 /* The types referenced in each catch must first be changed to the
4843 EH types used at runtime. This removes references to FE types
4845 for (c = r->u.eh_try.first_catch; c ; c = c->next_catch)
4847 c->type_list = get_eh_types_for_runtime (c->type_list);
4848 walk_tree (&c->type_list, find_decls_types_r, fld, fld->pset);
4853 case ERT_ALLOWED_EXCEPTIONS:
4854 r->u.allowed.type_list
4855 = get_eh_types_for_runtime (r->u.allowed.type_list);
4856 walk_tree (&r->u.allowed.type_list, find_decls_types_r, fld, fld->pset);
4859 case ERT_MUST_NOT_THROW:
4860 walk_tree (&r->u.must_not_throw.failure_decl,
4861 find_decls_types_r, fld, fld->pset);
4867 /* Find decls and types referenced in cgraph node N and store them in
4868 FLD->DECLS and FLD->TYPES. Unlike pass_referenced_vars, this will
4869 look for *every* kind of DECL and TYPE node reachable from N,
4870 including those embedded inside types and decls (i.e,, TYPE_DECLs,
4871 NAMESPACE_DECLs, etc). */
4874 find_decls_types_in_node (struct cgraph_node *n, struct free_lang_data_d *fld)
4877 struct function *fn;
4881 find_decls_types (n->decl, fld);
4883 if (!gimple_has_body_p (n->decl))
4886 gcc_assert (current_function_decl == NULL_TREE && cfun == NULL);
4888 fn = DECL_STRUCT_FUNCTION (n->decl);
4890 /* Traverse locals. */
4891 FOR_EACH_LOCAL_DECL (fn, ix, t)
4892 find_decls_types (t, fld);
4894 /* Traverse EH regions in FN. */
4897 FOR_ALL_EH_REGION_FN (r, fn)
4898 find_decls_types_in_eh_region (r, fld);
4901 /* Traverse every statement in FN. */
4902 FOR_EACH_BB_FN (bb, fn)
4904 gimple_stmt_iterator si;
4907 for (si = gsi_start_phis (bb); !gsi_end_p (si); gsi_next (&si))
4909 gimple phi = gsi_stmt (si);
4911 for (i = 0; i < gimple_phi_num_args (phi); i++)
4913 tree *arg_p = gimple_phi_arg_def_ptr (phi, i);
4914 find_decls_types (*arg_p, fld);
4918 for (si = gsi_start_bb (bb); !gsi_end_p (si); gsi_next (&si))
4920 gimple stmt = gsi_stmt (si);
4922 for (i = 0; i < gimple_num_ops (stmt); i++)
4924 tree arg = gimple_op (stmt, i);
4925 find_decls_types (arg, fld);
4932 /* Find decls and types referenced in varpool node N and store them in
4933 FLD->DECLS and FLD->TYPES. Unlike pass_referenced_vars, this will
4934 look for *every* kind of DECL and TYPE node reachable from N,
4935 including those embedded inside types and decls (i.e,, TYPE_DECLs,
4936 NAMESPACE_DECLs, etc). */
4939 find_decls_types_in_var (struct varpool_node *v, struct free_lang_data_d *fld)
4941 find_decls_types (v->decl, fld);
4944 /* If T needs an assembler name, have one created for it. */
4947 assign_assembler_name_if_neeeded (tree t)
4949 if (need_assembler_name_p (t))
4951 /* When setting DECL_ASSEMBLER_NAME, the C++ mangler may emit
4952 diagnostics that use input_location to show locus
4953 information. The problem here is that, at this point,
4954 input_location is generally anchored to the end of the file
4955 (since the parser is long gone), so we don't have a good
4956 position to pin it to.
4958 To alleviate this problem, this uses the location of T's
4959 declaration. Examples of this are
4960 testsuite/g++.dg/template/cond2.C and
4961 testsuite/g++.dg/template/pr35240.C. */
4962 location_t saved_location = input_location;
4963 input_location = DECL_SOURCE_LOCATION (t);
4965 decl_assembler_name (t);
4967 input_location = saved_location;
4972 /* Free language specific information for every operand and expression
4973 in every node of the call graph. This process operates in three stages:
4975 1- Every callgraph node and varpool node is traversed looking for
4976 decls and types embedded in them. This is a more exhaustive
4977 search than that done by find_referenced_vars, because it will
4978 also collect individual fields, decls embedded in types, etc.
4980 2- All the decls found are sent to free_lang_data_in_decl.
4982 3- All the types found are sent to free_lang_data_in_type.
4984 The ordering between decls and types is important because
4985 free_lang_data_in_decl sets assembler names, which includes
4986 mangling. So types cannot be freed up until assembler names have
4990 free_lang_data_in_cgraph (void)
4992 struct cgraph_node *n;
4993 struct varpool_node *v;
4994 struct free_lang_data_d fld;
4999 /* Initialize sets and arrays to store referenced decls and types. */
5000 fld.pset = pointer_set_create ();
5001 fld.worklist = NULL;
5002 fld.decls = VEC_alloc (tree, heap, 100);
5003 fld.types = VEC_alloc (tree, heap, 100);
5005 /* Find decls and types in the body of every function in the callgraph. */
5006 for (n = cgraph_nodes; n; n = n->next)
5007 find_decls_types_in_node (n, &fld);
5009 FOR_EACH_VEC_ELT (alias_pair, alias_pairs, i, p)
5010 find_decls_types (p->decl, &fld);
5012 /* Find decls and types in every varpool symbol. */
5013 for (v = varpool_nodes; v; v = v->next)
5014 find_decls_types_in_var (v, &fld);
5016 /* Set the assembler name on every decl found. We need to do this
5017 now because free_lang_data_in_decl will invalidate data needed
5018 for mangling. This breaks mangling on interdependent decls. */
5019 FOR_EACH_VEC_ELT (tree, fld.decls, i, t)
5020 assign_assembler_name_if_neeeded (t);
5022 /* Traverse every decl found freeing its language data. */
5023 FOR_EACH_VEC_ELT (tree, fld.decls, i, t)
5024 free_lang_data_in_decl (t);
5026 /* Traverse every type found freeing its language data. */
5027 FOR_EACH_VEC_ELT (tree, fld.types, i, t)
5028 free_lang_data_in_type (t);
5030 pointer_set_destroy (fld.pset);
5031 VEC_free (tree, heap, fld.worklist);
5032 VEC_free (tree, heap, fld.decls);
5033 VEC_free (tree, heap, fld.types);
5037 /* Free resources that are used by FE but are not needed once they are done. */
5040 free_lang_data (void)
5044 /* If we are the LTO frontend we have freed lang-specific data already. */
5046 || !flag_generate_lto)
5049 /* Allocate and assign alias sets to the standard integer types
5050 while the slots are still in the way the frontends generated them. */
5051 for (i = 0; i < itk_none; ++i)
5052 if (integer_types[i])
5053 TYPE_ALIAS_SET (integer_types[i]) = get_alias_set (integer_types[i]);
5055 /* Traverse the IL resetting language specific information for
5056 operands, expressions, etc. */
5057 free_lang_data_in_cgraph ();
5059 /* Create gimple variants for common types. */
5060 ptrdiff_type_node = integer_type_node;
5061 fileptr_type_node = ptr_type_node;
5062 if (TREE_CODE (boolean_type_node) != BOOLEAN_TYPE
5063 || (TYPE_MODE (boolean_type_node)
5064 != mode_for_size (BOOL_TYPE_SIZE, MODE_INT, 0))
5065 || TYPE_PRECISION (boolean_type_node) != 1
5066 || !TYPE_UNSIGNED (boolean_type_node))
5068 boolean_type_node = make_unsigned_type (BOOL_TYPE_SIZE);
5069 TREE_SET_CODE (boolean_type_node, BOOLEAN_TYPE);
5070 TYPE_MAX_VALUE (boolean_type_node) = build_int_cst (boolean_type_node, 1);
5071 TYPE_PRECISION (boolean_type_node) = 1;
5072 boolean_false_node = TYPE_MIN_VALUE (boolean_type_node);
5073 boolean_true_node = TYPE_MAX_VALUE (boolean_type_node);
5076 /* Unify char_type_node with its properly signed variant. */
5077 if (TYPE_UNSIGNED (char_type_node))
5078 unsigned_char_type_node = char_type_node;
5080 signed_char_type_node = char_type_node;
5082 /* Reset some langhooks. Do not reset types_compatible_p, it may
5083 still be used indirectly via the get_alias_set langhook. */
5084 lang_hooks.callgraph.analyze_expr = NULL;
5085 lang_hooks.dwarf_name = lhd_dwarf_name;
5086 lang_hooks.decl_printable_name = gimple_decl_printable_name;
5087 lang_hooks.set_decl_assembler_name = lhd_set_decl_assembler_name;
5089 /* Reset diagnostic machinery. */
5090 diagnostic_starter (global_dc) = default_tree_diagnostic_starter;
5091 diagnostic_finalizer (global_dc) = default_diagnostic_finalizer;
5092 diagnostic_format_decoder (global_dc) = default_tree_printer;
5098 struct simple_ipa_opt_pass pass_ipa_free_lang_data =
5102 "*free_lang_data", /* name */
5104 free_lang_data, /* execute */
5107 0, /* static_pass_number */
5108 TV_IPA_FREE_LANG_DATA, /* tv_id */
5109 0, /* properties_required */
5110 0, /* properties_provided */
5111 0, /* properties_destroyed */
5112 0, /* todo_flags_start */
5113 TODO_ggc_collect /* todo_flags_finish */
5117 /* Return nonzero if IDENT is a valid name for attribute ATTR,
5120 We try both `text' and `__text__', ATTR may be either one. */
5121 /* ??? It might be a reasonable simplification to require ATTR to be only
5122 `text'. One might then also require attribute lists to be stored in
5123 their canonicalized form. */
5126 is_attribute_with_length_p (const char *attr, int attr_len, const_tree ident)
5131 if (TREE_CODE (ident) != IDENTIFIER_NODE)
5134 p = IDENTIFIER_POINTER (ident);
5135 ident_len = IDENTIFIER_LENGTH (ident);
5137 if (ident_len == attr_len
5138 && strcmp (attr, p) == 0)
5141 /* If ATTR is `__text__', IDENT must be `text'; and vice versa. */
5144 gcc_assert (attr[1] == '_');
5145 gcc_assert (attr[attr_len - 2] == '_');
5146 gcc_assert (attr[attr_len - 1] == '_');
5147 if (ident_len == attr_len - 4
5148 && strncmp (attr + 2, p, attr_len - 4) == 0)
5153 if (ident_len == attr_len + 4
5154 && p[0] == '_' && p[1] == '_'
5155 && p[ident_len - 2] == '_' && p[ident_len - 1] == '_'
5156 && strncmp (attr, p + 2, attr_len) == 0)
5163 /* Return nonzero if IDENT is a valid name for attribute ATTR,
5166 We try both `text' and `__text__', ATTR may be either one. */
5169 is_attribute_p (const char *attr, const_tree ident)
5171 return is_attribute_with_length_p (attr, strlen (attr), ident);
5174 /* Given an attribute name and a list of attributes, return a pointer to the
5175 attribute's list element if the attribute is part of the list, or NULL_TREE
5176 if not found. If the attribute appears more than once, this only
5177 returns the first occurrence; the TREE_CHAIN of the return value should
5178 be passed back in if further occurrences are wanted. */
5181 lookup_attribute (const char *attr_name, tree list)
5184 size_t attr_len = strlen (attr_name);
5186 for (l = list; l; l = TREE_CHAIN (l))
5188 gcc_assert (TREE_CODE (TREE_PURPOSE (l)) == IDENTIFIER_NODE);
5189 if (is_attribute_with_length_p (attr_name, attr_len, TREE_PURPOSE (l)))
5195 /* Remove any instances of attribute ATTR_NAME in LIST and return the
5199 remove_attribute (const char *attr_name, tree list)
5202 size_t attr_len = strlen (attr_name);
5204 for (p = &list; *p; )
5207 gcc_assert (TREE_CODE (TREE_PURPOSE (l)) == IDENTIFIER_NODE);
5208 if (is_attribute_with_length_p (attr_name, attr_len, TREE_PURPOSE (l)))
5209 *p = TREE_CHAIN (l);
5211 p = &TREE_CHAIN (l);
5217 /* Return an attribute list that is the union of a1 and a2. */
5220 merge_attributes (tree a1, tree a2)
5224 /* Either one unset? Take the set one. */
5226 if ((attributes = a1) == 0)
5229 /* One that completely contains the other? Take it. */
5231 else if (a2 != 0 && ! attribute_list_contained (a1, a2))
5233 if (attribute_list_contained (a2, a1))
5237 /* Pick the longest list, and hang on the other list. */
5239 if (list_length (a1) < list_length (a2))
5240 attributes = a2, a2 = a1;
5242 for (; a2 != 0; a2 = TREE_CHAIN (a2))
5245 for (a = lookup_attribute (IDENTIFIER_POINTER (TREE_PURPOSE (a2)),
5248 a = lookup_attribute (IDENTIFIER_POINTER (TREE_PURPOSE (a2)),
5251 if (TREE_VALUE (a) != NULL
5252 && TREE_CODE (TREE_VALUE (a)) == TREE_LIST
5253 && TREE_VALUE (a2) != NULL
5254 && TREE_CODE (TREE_VALUE (a2)) == TREE_LIST)
5256 if (simple_cst_list_equal (TREE_VALUE (a),
5257 TREE_VALUE (a2)) == 1)
5260 else if (simple_cst_equal (TREE_VALUE (a),
5261 TREE_VALUE (a2)) == 1)
5266 a1 = copy_node (a2);
5267 TREE_CHAIN (a1) = attributes;
5276 /* Given types T1 and T2, merge their attributes and return
5280 merge_type_attributes (tree t1, tree t2)
5282 return merge_attributes (TYPE_ATTRIBUTES (t1),
5283 TYPE_ATTRIBUTES (t2));
5286 /* Given decls OLDDECL and NEWDECL, merge their attributes and return
5290 merge_decl_attributes (tree olddecl, tree newdecl)
5292 return merge_attributes (DECL_ATTRIBUTES (olddecl),
5293 DECL_ATTRIBUTES (newdecl));
5296 #if TARGET_DLLIMPORT_DECL_ATTRIBUTES
5298 /* Specialization of merge_decl_attributes for various Windows targets.
5300 This handles the following situation:
5302 __declspec (dllimport) int foo;
5305 The second instance of `foo' nullifies the dllimport. */
5308 merge_dllimport_decl_attributes (tree old, tree new_tree)
5311 int delete_dllimport_p = 1;
5313 /* What we need to do here is remove from `old' dllimport if it doesn't
5314 appear in `new'. dllimport behaves like extern: if a declaration is
5315 marked dllimport and a definition appears later, then the object
5316 is not dllimport'd. We also remove a `new' dllimport if the old list
5317 contains dllexport: dllexport always overrides dllimport, regardless
5318 of the order of declaration. */
5319 if (!VAR_OR_FUNCTION_DECL_P (new_tree))
5320 delete_dllimport_p = 0;
5321 else if (DECL_DLLIMPORT_P (new_tree)
5322 && lookup_attribute ("dllexport", DECL_ATTRIBUTES (old)))
5324 DECL_DLLIMPORT_P (new_tree) = 0;
5325 warning (OPT_Wattributes, "%q+D already declared with dllexport attribute: "
5326 "dllimport ignored", new_tree);
5328 else if (DECL_DLLIMPORT_P (old) && !DECL_DLLIMPORT_P (new_tree))
5330 /* Warn about overriding a symbol that has already been used, e.g.:
5331 extern int __attribute__ ((dllimport)) foo;
5332 int* bar () {return &foo;}
5335 if (TREE_USED (old))
5337 warning (0, "%q+D redeclared without dllimport attribute "
5338 "after being referenced with dll linkage", new_tree);
5339 /* If we have used a variable's address with dllimport linkage,
5340 keep the old DECL_DLLIMPORT_P flag: the ADDR_EXPR using the
5341 decl may already have had TREE_CONSTANT computed.
5342 We still remove the attribute so that assembler code refers
5343 to '&foo rather than '_imp__foo'. */
5344 if (TREE_CODE (old) == VAR_DECL && TREE_ADDRESSABLE (old))
5345 DECL_DLLIMPORT_P (new_tree) = 1;
5348 /* Let an inline definition silently override the external reference,
5349 but otherwise warn about attribute inconsistency. */
5350 else if (TREE_CODE (new_tree) == VAR_DECL
5351 || !DECL_DECLARED_INLINE_P (new_tree))
5352 warning (OPT_Wattributes, "%q+D redeclared without dllimport attribute: "
5353 "previous dllimport ignored", new_tree);
5356 delete_dllimport_p = 0;
5358 a = merge_attributes (DECL_ATTRIBUTES (old), DECL_ATTRIBUTES (new_tree));
5360 if (delete_dllimport_p)
5363 const size_t attr_len = strlen ("dllimport");
5365 /* Scan the list for dllimport and delete it. */
5366 for (prev = NULL_TREE, t = a; t; prev = t, t = TREE_CHAIN (t))
5368 if (is_attribute_with_length_p ("dllimport", attr_len,
5371 if (prev == NULL_TREE)
5374 TREE_CHAIN (prev) = TREE_CHAIN (t);
5383 /* Handle a "dllimport" or "dllexport" attribute; arguments as in
5384 struct attribute_spec.handler. */
5387 handle_dll_attribute (tree * pnode, tree name, tree args, int flags,
5393 /* These attributes may apply to structure and union types being created,
5394 but otherwise should pass to the declaration involved. */
5397 if (flags & ((int) ATTR_FLAG_DECL_NEXT | (int) ATTR_FLAG_FUNCTION_NEXT
5398 | (int) ATTR_FLAG_ARRAY_NEXT))
5400 *no_add_attrs = true;
5401 return tree_cons (name, args, NULL_TREE);
5403 if (TREE_CODE (node) == RECORD_TYPE
5404 || TREE_CODE (node) == UNION_TYPE)
5406 node = TYPE_NAME (node);
5412 warning (OPT_Wattributes, "%qE attribute ignored",
5414 *no_add_attrs = true;
5419 if (TREE_CODE (node) != FUNCTION_DECL
5420 && TREE_CODE (node) != VAR_DECL
5421 && TREE_CODE (node) != TYPE_DECL)
5423 *no_add_attrs = true;
5424 warning (OPT_Wattributes, "%qE attribute ignored",
5429 if (TREE_CODE (node) == TYPE_DECL
5430 && TREE_CODE (TREE_TYPE (node)) != RECORD_TYPE
5431 && TREE_CODE (TREE_TYPE (node)) != UNION_TYPE)
5433 *no_add_attrs = true;
5434 warning (OPT_Wattributes, "%qE attribute ignored",
5439 is_dllimport = is_attribute_p ("dllimport", name);
5441 /* Report error on dllimport ambiguities seen now before they cause
5445 /* Honor any target-specific overrides. */
5446 if (!targetm.valid_dllimport_attribute_p (node))
5447 *no_add_attrs = true;
5449 else if (TREE_CODE (node) == FUNCTION_DECL
5450 && DECL_DECLARED_INLINE_P (node))
5452 warning (OPT_Wattributes, "inline function %q+D declared as "
5453 " dllimport: attribute ignored", node);
5454 *no_add_attrs = true;
5456 /* Like MS, treat definition of dllimported variables and
5457 non-inlined functions on declaration as syntax errors. */
5458 else if (TREE_CODE (node) == FUNCTION_DECL && DECL_INITIAL (node))
5460 error ("function %q+D definition is marked dllimport", node);
5461 *no_add_attrs = true;
5464 else if (TREE_CODE (node) == VAR_DECL)
5466 if (DECL_INITIAL (node))
5468 error ("variable %q+D definition is marked dllimport",
5470 *no_add_attrs = true;
5473 /* `extern' needn't be specified with dllimport.
5474 Specify `extern' now and hope for the best. Sigh. */
5475 DECL_EXTERNAL (node) = 1;
5476 /* Also, implicitly give dllimport'd variables declared within
5477 a function global scope, unless declared static. */
5478 if (current_function_decl != NULL_TREE && !TREE_STATIC (node))
5479 TREE_PUBLIC (node) = 1;
5482 if (*no_add_attrs == false)
5483 DECL_DLLIMPORT_P (node) = 1;
5485 else if (TREE_CODE (node) == FUNCTION_DECL
5486 && DECL_DECLARED_INLINE_P (node))
5487 /* An exported function, even if inline, must be emitted. */
5488 DECL_EXTERNAL (node) = 0;
5490 /* Report error if symbol is not accessible at global scope. */
5491 if (!TREE_PUBLIC (node)
5492 && (TREE_CODE (node) == VAR_DECL
5493 || TREE_CODE (node) == FUNCTION_DECL))
5495 error ("external linkage required for symbol %q+D because of "
5496 "%qE attribute", node, name);
5497 *no_add_attrs = true;
5500 /* A dllexport'd entity must have default visibility so that other
5501 program units (shared libraries or the main executable) can see
5502 it. A dllimport'd entity must have default visibility so that
5503 the linker knows that undefined references within this program
5504 unit can be resolved by the dynamic linker. */
5507 if (DECL_VISIBILITY_SPECIFIED (node)
5508 && DECL_VISIBILITY (node) != VISIBILITY_DEFAULT)
5509 error ("%qE implies default visibility, but %qD has already "
5510 "been declared with a different visibility",
5512 DECL_VISIBILITY (node) = VISIBILITY_DEFAULT;
5513 DECL_VISIBILITY_SPECIFIED (node) = 1;
5519 #endif /* TARGET_DLLIMPORT_DECL_ATTRIBUTES */
5521 /* Set the type qualifiers for TYPE to TYPE_QUALS, which is a bitmask
5522 of the various TYPE_QUAL values. */
5525 set_type_quals (tree type, int type_quals)
5527 TYPE_READONLY (type) = (type_quals & TYPE_QUAL_CONST) != 0;
5528 TYPE_VOLATILE (type) = (type_quals & TYPE_QUAL_VOLATILE) != 0;
5529 TYPE_RESTRICT (type) = (type_quals & TYPE_QUAL_RESTRICT) != 0;
5530 TYPE_ADDR_SPACE (type) = DECODE_QUAL_ADDR_SPACE (type_quals);
5533 /* Returns true iff CAND is equivalent to BASE with TYPE_QUALS. */
5536 check_qualified_type (const_tree cand, const_tree base, int type_quals)
5538 return (TYPE_QUALS (cand) == type_quals
5539 && TYPE_NAME (cand) == TYPE_NAME (base)
5540 /* Apparently this is needed for Objective-C. */
5541 && TYPE_CONTEXT (cand) == TYPE_CONTEXT (base)
5542 /* Check alignment. */
5543 && TYPE_ALIGN (cand) == TYPE_ALIGN (base)
5544 && attribute_list_equal (TYPE_ATTRIBUTES (cand),
5545 TYPE_ATTRIBUTES (base)));
5548 /* Returns true iff CAND is equivalent to BASE with ALIGN. */
5551 check_aligned_type (const_tree cand, const_tree base, unsigned int align)
5553 return (TYPE_QUALS (cand) == TYPE_QUALS (base)
5554 && TYPE_NAME (cand) == TYPE_NAME (base)
5555 /* Apparently this is needed for Objective-C. */
5556 && TYPE_CONTEXT (cand) == TYPE_CONTEXT (base)
5557 /* Check alignment. */
5558 && TYPE_ALIGN (cand) == align
5559 && attribute_list_equal (TYPE_ATTRIBUTES (cand),
5560 TYPE_ATTRIBUTES (base)));
5563 /* Return a version of the TYPE, qualified as indicated by the
5564 TYPE_QUALS, if one exists. If no qualified version exists yet,
5565 return NULL_TREE. */
5568 get_qualified_type (tree type, int type_quals)
5572 if (TYPE_QUALS (type) == type_quals)
5575 /* Search the chain of variants to see if there is already one there just
5576 like the one we need to have. If so, use that existing one. We must
5577 preserve the TYPE_NAME, since there is code that depends on this. */
5578 for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
5579 if (check_qualified_type (t, type, type_quals))
5585 /* Like get_qualified_type, but creates the type if it does not
5586 exist. This function never returns NULL_TREE. */
5589 build_qualified_type (tree type, int type_quals)
5593 /* See if we already have the appropriate qualified variant. */
5594 t = get_qualified_type (type, type_quals);
5596 /* If not, build it. */
5599 t = build_variant_type_copy (type);
5600 set_type_quals (t, type_quals);
5602 if (TYPE_STRUCTURAL_EQUALITY_P (type))
5603 /* Propagate structural equality. */
5604 SET_TYPE_STRUCTURAL_EQUALITY (t);
5605 else if (TYPE_CANONICAL (type) != type)
5606 /* Build the underlying canonical type, since it is different
5608 TYPE_CANONICAL (t) = build_qualified_type (TYPE_CANONICAL (type),
5611 /* T is its own canonical type. */
5612 TYPE_CANONICAL (t) = t;
5619 /* Create a variant of type T with alignment ALIGN. */
5622 build_aligned_type (tree type, unsigned int align)
5626 if (TYPE_PACKED (type)
5627 || TYPE_ALIGN (type) == align)
5630 for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
5631 if (check_aligned_type (t, type, align))
5634 t = build_variant_type_copy (type);
5635 TYPE_ALIGN (t) = align;
5640 /* Create a new distinct copy of TYPE. The new type is made its own
5641 MAIN_VARIANT. If TYPE requires structural equality checks, the
5642 resulting type requires structural equality checks; otherwise, its
5643 TYPE_CANONICAL points to itself. */
5646 build_distinct_type_copy (tree type)
5648 tree t = copy_node (type);
5650 TYPE_POINTER_TO (t) = 0;
5651 TYPE_REFERENCE_TO (t) = 0;
5653 /* Set the canonical type either to a new equivalence class, or
5654 propagate the need for structural equality checks. */
5655 if (TYPE_STRUCTURAL_EQUALITY_P (type))
5656 SET_TYPE_STRUCTURAL_EQUALITY (t);
5658 TYPE_CANONICAL (t) = t;
5660 /* Make it its own variant. */
5661 TYPE_MAIN_VARIANT (t) = t;
5662 TYPE_NEXT_VARIANT (t) = 0;
5664 /* Note that it is now possible for TYPE_MIN_VALUE to be a value
5665 whose TREE_TYPE is not t. This can also happen in the Ada
5666 frontend when using subtypes. */
5671 /* Create a new variant of TYPE, equivalent but distinct. This is so
5672 the caller can modify it. TYPE_CANONICAL for the return type will
5673 be equivalent to TYPE_CANONICAL of TYPE, indicating that the types
5674 are considered equal by the language itself (or that both types
5675 require structural equality checks). */
5678 build_variant_type_copy (tree type)
5680 tree t, m = TYPE_MAIN_VARIANT (type);
5682 t = build_distinct_type_copy (type);
5684 /* Since we're building a variant, assume that it is a non-semantic
5685 variant. This also propagates TYPE_STRUCTURAL_EQUALITY_P. */
5686 TYPE_CANONICAL (t) = TYPE_CANONICAL (type);
5688 /* Add the new type to the chain of variants of TYPE. */
5689 TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (m);
5690 TYPE_NEXT_VARIANT (m) = t;
5691 TYPE_MAIN_VARIANT (t) = m;
5696 /* Return true if the from tree in both tree maps are equal. */
5699 tree_map_base_eq (const void *va, const void *vb)
5701 const struct tree_map_base *const a = (const struct tree_map_base *) va,
5702 *const b = (const struct tree_map_base *) vb;
5703 return (a->from == b->from);
5706 /* Hash a from tree in a tree_base_map. */
5709 tree_map_base_hash (const void *item)
5711 return htab_hash_pointer (((const struct tree_map_base *)item)->from);
5714 /* Return true if this tree map structure is marked for garbage collection
5715 purposes. We simply return true if the from tree is marked, so that this
5716 structure goes away when the from tree goes away. */
5719 tree_map_base_marked_p (const void *p)
5721 return ggc_marked_p (((const struct tree_map_base *) p)->from);
5724 /* Hash a from tree in a tree_map. */
5727 tree_map_hash (const void *item)
5729 return (((const struct tree_map *) item)->hash);
5732 /* Hash a from tree in a tree_decl_map. */
5735 tree_decl_map_hash (const void *item)
5737 return DECL_UID (((const struct tree_decl_map *) item)->base.from);
5740 /* Return the initialization priority for DECL. */
5743 decl_init_priority_lookup (tree decl)
5745 struct tree_priority_map *h;
5746 struct tree_map_base in;
5748 gcc_assert (VAR_OR_FUNCTION_DECL_P (decl));
5750 h = (struct tree_priority_map *) htab_find (init_priority_for_decl, &in);
5751 return h ? h->init : DEFAULT_INIT_PRIORITY;
5754 /* Return the finalization priority for DECL. */
5757 decl_fini_priority_lookup (tree decl)
5759 struct tree_priority_map *h;
5760 struct tree_map_base in;
5762 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL);
5764 h = (struct tree_priority_map *) htab_find (init_priority_for_decl, &in);
5765 return h ? h->fini : DEFAULT_INIT_PRIORITY;
5768 /* Return the initialization and finalization priority information for
5769 DECL. If there is no previous priority information, a freshly
5770 allocated structure is returned. */
5772 static struct tree_priority_map *
5773 decl_priority_info (tree decl)
5775 struct tree_priority_map in;
5776 struct tree_priority_map *h;
5779 in.base.from = decl;
5780 loc = htab_find_slot (init_priority_for_decl, &in, INSERT);
5781 h = (struct tree_priority_map *) *loc;
5784 h = ggc_alloc_cleared_tree_priority_map ();
5786 h->base.from = decl;
5787 h->init = DEFAULT_INIT_PRIORITY;
5788 h->fini = DEFAULT_INIT_PRIORITY;
5794 /* Set the initialization priority for DECL to PRIORITY. */
5797 decl_init_priority_insert (tree decl, priority_type priority)
5799 struct tree_priority_map *h;
5801 gcc_assert (VAR_OR_FUNCTION_DECL_P (decl));
5802 h = decl_priority_info (decl);
5806 /* Set the finalization priority for DECL to PRIORITY. */
5809 decl_fini_priority_insert (tree decl, priority_type priority)
5811 struct tree_priority_map *h;
5813 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL);
5814 h = decl_priority_info (decl);
5818 /* Print out the statistics for the DECL_DEBUG_EXPR hash table. */
5821 print_debug_expr_statistics (void)
5823 fprintf (stderr, "DECL_DEBUG_EXPR hash: size %ld, %ld elements, %f collisions\n",
5824 (long) htab_size (debug_expr_for_decl),
5825 (long) htab_elements (debug_expr_for_decl),
5826 htab_collisions (debug_expr_for_decl));
5829 /* Print out the statistics for the DECL_VALUE_EXPR hash table. */
5832 print_value_expr_statistics (void)
5834 fprintf (stderr, "DECL_VALUE_EXPR hash: size %ld, %ld elements, %f collisions\n",
5835 (long) htab_size (value_expr_for_decl),
5836 (long) htab_elements (value_expr_for_decl),
5837 htab_collisions (value_expr_for_decl));
5840 /* Lookup a debug expression for FROM, and return it if we find one. */
5843 decl_debug_expr_lookup (tree from)
5845 struct tree_decl_map *h, in;
5846 in.base.from = from;
5848 h = (struct tree_decl_map *)
5849 htab_find_with_hash (debug_expr_for_decl, &in, DECL_UID (from));
5855 /* Insert a mapping FROM->TO in the debug expression hashtable. */
5858 decl_debug_expr_insert (tree from, tree to)
5860 struct tree_decl_map *h;
5863 h = ggc_alloc_tree_decl_map ();
5864 h->base.from = from;
5866 loc = htab_find_slot_with_hash (debug_expr_for_decl, h, DECL_UID (from),
5868 *(struct tree_decl_map **) loc = h;
5871 /* Lookup a value expression for FROM, and return it if we find one. */
5874 decl_value_expr_lookup (tree from)
5876 struct tree_decl_map *h, in;
5877 in.base.from = from;
5879 h = (struct tree_decl_map *)
5880 htab_find_with_hash (value_expr_for_decl, &in, DECL_UID (from));
5886 /* Insert a mapping FROM->TO in the value expression hashtable. */
5889 decl_value_expr_insert (tree from, tree to)
5891 struct tree_decl_map *h;
5894 h = ggc_alloc_tree_decl_map ();
5895 h->base.from = from;
5897 loc = htab_find_slot_with_hash (value_expr_for_decl, h, DECL_UID (from),
5899 *(struct tree_decl_map **) loc = h;
5902 /* Hashing of types so that we don't make duplicates.
5903 The entry point is `type_hash_canon'. */
5905 /* Compute a hash code for a list of types (chain of TREE_LIST nodes
5906 with types in the TREE_VALUE slots), by adding the hash codes
5907 of the individual types. */
5910 type_hash_list (const_tree list, hashval_t hashcode)
5914 for (tail = list; tail; tail = TREE_CHAIN (tail))
5915 if (TREE_VALUE (tail) != error_mark_node)
5916 hashcode = iterative_hash_object (TYPE_HASH (TREE_VALUE (tail)),
5922 /* These are the Hashtable callback functions. */
5924 /* Returns true iff the types are equivalent. */
5927 type_hash_eq (const void *va, const void *vb)
5929 const struct type_hash *const a = (const struct type_hash *) va,
5930 *const b = (const struct type_hash *) vb;
5932 /* First test the things that are the same for all types. */
5933 if (a->hash != b->hash
5934 || TREE_CODE (a->type) != TREE_CODE (b->type)
5935 || TREE_TYPE (a->type) != TREE_TYPE (b->type)
5936 || !attribute_list_equal (TYPE_ATTRIBUTES (a->type),
5937 TYPE_ATTRIBUTES (b->type))
5938 || TYPE_ALIGN (a->type) != TYPE_ALIGN (b->type)
5939 || TYPE_MODE (a->type) != TYPE_MODE (b->type)
5940 || (TREE_CODE (a->type) != COMPLEX_TYPE
5941 && TYPE_NAME (a->type) != TYPE_NAME (b->type)))
5944 switch (TREE_CODE (a->type))
5949 case REFERENCE_TYPE:
5953 return TYPE_VECTOR_SUBPARTS (a->type) == TYPE_VECTOR_SUBPARTS (b->type);
5956 if (TYPE_VALUES (a->type) != TYPE_VALUES (b->type)
5957 && !(TYPE_VALUES (a->type)
5958 && TREE_CODE (TYPE_VALUES (a->type)) == TREE_LIST
5959 && TYPE_VALUES (b->type)
5960 && TREE_CODE (TYPE_VALUES (b->type)) == TREE_LIST
5961 && type_list_equal (TYPE_VALUES (a->type),
5962 TYPE_VALUES (b->type))))
5965 /* ... fall through ... */
5970 return ((TYPE_MAX_VALUE (a->type) == TYPE_MAX_VALUE (b->type)
5971 || tree_int_cst_equal (TYPE_MAX_VALUE (a->type),
5972 TYPE_MAX_VALUE (b->type)))
5973 && (TYPE_MIN_VALUE (a->type) == TYPE_MIN_VALUE (b->type)
5974 || tree_int_cst_equal (TYPE_MIN_VALUE (a->type),
5975 TYPE_MIN_VALUE (b->type))));
5977 case FIXED_POINT_TYPE:
5978 return TYPE_SATURATING (a->type) == TYPE_SATURATING (b->type);
5981 return TYPE_OFFSET_BASETYPE (a->type) == TYPE_OFFSET_BASETYPE (b->type);
5984 return (TYPE_METHOD_BASETYPE (a->type) == TYPE_METHOD_BASETYPE (b->type)
5985 && (TYPE_ARG_TYPES (a->type) == TYPE_ARG_TYPES (b->type)
5986 || (TYPE_ARG_TYPES (a->type)
5987 && TREE_CODE (TYPE_ARG_TYPES (a->type)) == TREE_LIST
5988 && TYPE_ARG_TYPES (b->type)
5989 && TREE_CODE (TYPE_ARG_TYPES (b->type)) == TREE_LIST
5990 && type_list_equal (TYPE_ARG_TYPES (a->type),
5991 TYPE_ARG_TYPES (b->type)))));
5994 return TYPE_DOMAIN (a->type) == TYPE_DOMAIN (b->type);
5998 case QUAL_UNION_TYPE:
5999 return (TYPE_FIELDS (a->type) == TYPE_FIELDS (b->type)
6000 || (TYPE_FIELDS (a->type)
6001 && TREE_CODE (TYPE_FIELDS (a->type)) == TREE_LIST
6002 && TYPE_FIELDS (b->type)
6003 && TREE_CODE (TYPE_FIELDS (b->type)) == TREE_LIST
6004 && type_list_equal (TYPE_FIELDS (a->type),
6005 TYPE_FIELDS (b->type))));
6008 if (TYPE_ARG_TYPES (a->type) == TYPE_ARG_TYPES (b->type)
6009 || (TYPE_ARG_TYPES (a->type)
6010 && TREE_CODE (TYPE_ARG_TYPES (a->type)) == TREE_LIST
6011 && TYPE_ARG_TYPES (b->type)
6012 && TREE_CODE (TYPE_ARG_TYPES (b->type)) == TREE_LIST
6013 && type_list_equal (TYPE_ARG_TYPES (a->type),
6014 TYPE_ARG_TYPES (b->type))))
6022 if (lang_hooks.types.type_hash_eq != NULL)
6023 return lang_hooks.types.type_hash_eq (a->type, b->type);
6028 /* Return the cached hash value. */
6031 type_hash_hash (const void *item)
6033 return ((const struct type_hash *) item)->hash;
6036 /* Look in the type hash table for a type isomorphic to TYPE.
6037 If one is found, return it. Otherwise return 0. */
6040 type_hash_lookup (hashval_t hashcode, tree type)
6042 struct type_hash *h, in;
6044 /* The TYPE_ALIGN field of a type is set by layout_type(), so we
6045 must call that routine before comparing TYPE_ALIGNs. */
6051 h = (struct type_hash *) htab_find_with_hash (type_hash_table, &in,
6058 /* Add an entry to the type-hash-table
6059 for a type TYPE whose hash code is HASHCODE. */
6062 type_hash_add (hashval_t hashcode, tree type)
6064 struct type_hash *h;
6067 h = ggc_alloc_type_hash ();
6070 loc = htab_find_slot_with_hash (type_hash_table, h, hashcode, INSERT);
6074 /* Given TYPE, and HASHCODE its hash code, return the canonical
6075 object for an identical type if one already exists.
6076 Otherwise, return TYPE, and record it as the canonical object.
6078 To use this function, first create a type of the sort you want.
6079 Then compute its hash code from the fields of the type that
6080 make it different from other similar types.
6081 Then call this function and use the value. */
6084 type_hash_canon (unsigned int hashcode, tree type)
6088 /* The hash table only contains main variants, so ensure that's what we're
6090 gcc_assert (TYPE_MAIN_VARIANT (type) == type);
6092 /* See if the type is in the hash table already. If so, return it.
6093 Otherwise, add the type. */
6094 t1 = type_hash_lookup (hashcode, type);
6097 #ifdef GATHER_STATISTICS
6098 tree_node_counts[(int) t_kind]--;
6099 tree_node_sizes[(int) t_kind] -= sizeof (struct tree_type);
6105 type_hash_add (hashcode, type);
6110 /* See if the data pointed to by the type hash table is marked. We consider
6111 it marked if the type is marked or if a debug type number or symbol
6112 table entry has been made for the type. */
6115 type_hash_marked_p (const void *p)
6117 const_tree const type = ((const struct type_hash *) p)->type;
6119 return ggc_marked_p (type);
6123 print_type_hash_statistics (void)
6125 fprintf (stderr, "Type hash: size %ld, %ld elements, %f collisions\n",
6126 (long) htab_size (type_hash_table),
6127 (long) htab_elements (type_hash_table),
6128 htab_collisions (type_hash_table));
6131 /* Compute a hash code for a list of attributes (chain of TREE_LIST nodes
6132 with names in the TREE_PURPOSE slots and args in the TREE_VALUE slots),
6133 by adding the hash codes of the individual attributes. */
6136 attribute_hash_list (const_tree list, hashval_t hashcode)
6140 for (tail = list; tail; tail = TREE_CHAIN (tail))
6141 /* ??? Do we want to add in TREE_VALUE too? */
6142 hashcode = iterative_hash_object
6143 (IDENTIFIER_HASH_VALUE (TREE_PURPOSE (tail)), hashcode);
6147 /* Given two lists of attributes, return true if list l2 is
6148 equivalent to l1. */
6151 attribute_list_equal (const_tree l1, const_tree l2)
6153 return attribute_list_contained (l1, l2)
6154 && attribute_list_contained (l2, l1);
6157 /* Given two lists of attributes, return true if list L2 is
6158 completely contained within L1. */
6159 /* ??? This would be faster if attribute names were stored in a canonicalized
6160 form. Otherwise, if L1 uses `foo' and L2 uses `__foo__', the long method
6161 must be used to show these elements are equivalent (which they are). */
6162 /* ??? It's not clear that attributes with arguments will always be handled
6166 attribute_list_contained (const_tree l1, const_tree l2)
6170 /* First check the obvious, maybe the lists are identical. */
6174 /* Maybe the lists are similar. */
6175 for (t1 = l1, t2 = l2;
6177 && TREE_PURPOSE (t1) == TREE_PURPOSE (t2)
6178 && TREE_VALUE (t1) == TREE_VALUE (t2);
6179 t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2));
6181 /* Maybe the lists are equal. */
6182 if (t1 == 0 && t2 == 0)
6185 for (; t2 != 0; t2 = TREE_CHAIN (t2))
6188 /* This CONST_CAST is okay because lookup_attribute does not
6189 modify its argument and the return value is assigned to a
6191 for (attr = lookup_attribute (IDENTIFIER_POINTER (TREE_PURPOSE (t2)),
6192 CONST_CAST_TREE(l1));
6194 attr = lookup_attribute (IDENTIFIER_POINTER (TREE_PURPOSE (t2)),
6197 if (TREE_VALUE (t2) != NULL
6198 && TREE_CODE (TREE_VALUE (t2)) == TREE_LIST
6199 && TREE_VALUE (attr) != NULL
6200 && TREE_CODE (TREE_VALUE (attr)) == TREE_LIST)
6202 if (simple_cst_list_equal (TREE_VALUE (t2),
6203 TREE_VALUE (attr)) == 1)
6206 else if (simple_cst_equal (TREE_VALUE (t2), TREE_VALUE (attr)) == 1)
6217 /* Given two lists of types
6218 (chains of TREE_LIST nodes with types in the TREE_VALUE slots)
6219 return 1 if the lists contain the same types in the same order.
6220 Also, the TREE_PURPOSEs must match. */
6223 type_list_equal (const_tree l1, const_tree l2)
6227 for (t1 = l1, t2 = l2; t1 && t2; t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2))
6228 if (TREE_VALUE (t1) != TREE_VALUE (t2)
6229 || (TREE_PURPOSE (t1) != TREE_PURPOSE (t2)
6230 && ! (1 == simple_cst_equal (TREE_PURPOSE (t1), TREE_PURPOSE (t2))
6231 && (TREE_TYPE (TREE_PURPOSE (t1))
6232 == TREE_TYPE (TREE_PURPOSE (t2))))))
6238 /* Returns the number of arguments to the FUNCTION_TYPE or METHOD_TYPE
6239 given by TYPE. If the argument list accepts variable arguments,
6240 then this function counts only the ordinary arguments. */
6243 type_num_arguments (const_tree type)
6248 for (t = TYPE_ARG_TYPES (type); t; t = TREE_CHAIN (t))
6249 /* If the function does not take a variable number of arguments,
6250 the last element in the list will have type `void'. */
6251 if (VOID_TYPE_P (TREE_VALUE (t)))
6259 /* Nonzero if integer constants T1 and T2
6260 represent the same constant value. */
6263 tree_int_cst_equal (const_tree t1, const_tree t2)
6268 if (t1 == 0 || t2 == 0)
6271 if (TREE_CODE (t1) == INTEGER_CST
6272 && TREE_CODE (t2) == INTEGER_CST
6273 && TREE_INT_CST_LOW (t1) == TREE_INT_CST_LOW (t2)
6274 && TREE_INT_CST_HIGH (t1) == TREE_INT_CST_HIGH (t2))
6280 /* Nonzero if integer constants T1 and T2 represent values that satisfy <.
6281 The precise way of comparison depends on their data type. */
6284 tree_int_cst_lt (const_tree t1, const_tree t2)
6289 if (TYPE_UNSIGNED (TREE_TYPE (t1)) != TYPE_UNSIGNED (TREE_TYPE (t2)))
6291 int t1_sgn = tree_int_cst_sgn (t1);
6292 int t2_sgn = tree_int_cst_sgn (t2);
6294 if (t1_sgn < t2_sgn)
6296 else if (t1_sgn > t2_sgn)
6298 /* Otherwise, both are non-negative, so we compare them as
6299 unsigned just in case one of them would overflow a signed
6302 else if (!TYPE_UNSIGNED (TREE_TYPE (t1)))
6303 return INT_CST_LT (t1, t2);
6305 return INT_CST_LT_UNSIGNED (t1, t2);
6308 /* Returns -1 if T1 < T2, 0 if T1 == T2, and 1 if T1 > T2. */
6311 tree_int_cst_compare (const_tree t1, const_tree t2)
6313 if (tree_int_cst_lt (t1, t2))
6315 else if (tree_int_cst_lt (t2, t1))
6321 /* Return 1 if T is an INTEGER_CST that can be manipulated efficiently on
6322 the host. If POS is zero, the value can be represented in a single
6323 HOST_WIDE_INT. If POS is nonzero, the value must be non-negative and can
6324 be represented in a single unsigned HOST_WIDE_INT. */
6327 host_integerp (const_tree t, int pos)
6332 return (TREE_CODE (t) == INTEGER_CST
6333 && ((TREE_INT_CST_HIGH (t) == 0
6334 && (HOST_WIDE_INT) TREE_INT_CST_LOW (t) >= 0)
6335 || (! pos && TREE_INT_CST_HIGH (t) == -1
6336 && (HOST_WIDE_INT) TREE_INT_CST_LOW (t) < 0
6337 && (!TYPE_UNSIGNED (TREE_TYPE (t))
6338 || (TREE_CODE (TREE_TYPE (t)) == INTEGER_TYPE
6339 && TYPE_IS_SIZETYPE (TREE_TYPE (t)))))
6340 || (pos && TREE_INT_CST_HIGH (t) == 0)));
6343 /* Return the HOST_WIDE_INT least significant bits of T if it is an
6344 INTEGER_CST and there is no overflow. POS is nonzero if the result must
6345 be non-negative. We must be able to satisfy the above conditions. */
6348 tree_low_cst (const_tree t, int pos)
6350 gcc_assert (host_integerp (t, pos));
6351 return TREE_INT_CST_LOW (t);
6354 /* Return the most significant bit of the integer constant T. */
6357 tree_int_cst_msb (const_tree t)
6361 unsigned HOST_WIDE_INT l;
6363 /* Note that using TYPE_PRECISION here is wrong. We care about the
6364 actual bits, not the (arbitrary) range of the type. */
6365 prec = GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (t))) - 1;
6366 rshift_double (TREE_INT_CST_LOW (t), TREE_INT_CST_HIGH (t), prec,
6367 2 * HOST_BITS_PER_WIDE_INT, &l, &h, 0);
6368 return (l & 1) == 1;
6371 /* Return an indication of the sign of the integer constant T.
6372 The return value is -1 if T < 0, 0 if T == 0, and 1 if T > 0.
6373 Note that -1 will never be returned if T's type is unsigned. */
6376 tree_int_cst_sgn (const_tree t)
6378 if (TREE_INT_CST_LOW (t) == 0 && TREE_INT_CST_HIGH (t) == 0)
6380 else if (TYPE_UNSIGNED (TREE_TYPE (t)))
6382 else if (TREE_INT_CST_HIGH (t) < 0)
6388 /* Return the minimum number of bits needed to represent VALUE in a
6389 signed or unsigned type, UNSIGNEDP says which. */
6392 tree_int_cst_min_precision (tree value, bool unsignedp)
6396 /* If the value is negative, compute its negative minus 1. The latter
6397 adjustment is because the absolute value of the largest negative value
6398 is one larger than the largest positive value. This is equivalent to
6399 a bit-wise negation, so use that operation instead. */
6401 if (tree_int_cst_sgn (value) < 0)
6402 value = fold_build1 (BIT_NOT_EXPR, TREE_TYPE (value), value);
6404 /* Return the number of bits needed, taking into account the fact
6405 that we need one more bit for a signed than unsigned type. */
6407 if (integer_zerop (value))
6410 log = tree_floor_log2 (value);
6412 return log + 1 + !unsignedp;
6415 /* Compare two constructor-element-type constants. Return 1 if the lists
6416 are known to be equal; otherwise return 0. */
6419 simple_cst_list_equal (const_tree l1, const_tree l2)
6421 while (l1 != NULL_TREE && l2 != NULL_TREE)
6423 if (simple_cst_equal (TREE_VALUE (l1), TREE_VALUE (l2)) != 1)
6426 l1 = TREE_CHAIN (l1);
6427 l2 = TREE_CHAIN (l2);
6433 /* Return truthvalue of whether T1 is the same tree structure as T2.
6434 Return 1 if they are the same.
6435 Return 0 if they are understandably different.
6436 Return -1 if either contains tree structure not understood by
6440 simple_cst_equal (const_tree t1, const_tree t2)
6442 enum tree_code code1, code2;
6448 if (t1 == 0 || t2 == 0)
6451 code1 = TREE_CODE (t1);
6452 code2 = TREE_CODE (t2);
6454 if (CONVERT_EXPR_CODE_P (code1) || code1 == NON_LVALUE_EXPR)
6456 if (CONVERT_EXPR_CODE_P (code2)
6457 || code2 == NON_LVALUE_EXPR)
6458 return simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
6460 return simple_cst_equal (TREE_OPERAND (t1, 0), t2);
6463 else if (CONVERT_EXPR_CODE_P (code2)
6464 || code2 == NON_LVALUE_EXPR)
6465 return simple_cst_equal (t1, TREE_OPERAND (t2, 0));
6473 return (TREE_INT_CST_LOW (t1) == TREE_INT_CST_LOW (t2)
6474 && TREE_INT_CST_HIGH (t1) == TREE_INT_CST_HIGH (t2));
6477 return REAL_VALUES_IDENTICAL (TREE_REAL_CST (t1), TREE_REAL_CST (t2));
6480 return FIXED_VALUES_IDENTICAL (TREE_FIXED_CST (t1), TREE_FIXED_CST (t2));
6483 return (TREE_STRING_LENGTH (t1) == TREE_STRING_LENGTH (t2)
6484 && ! memcmp (TREE_STRING_POINTER (t1), TREE_STRING_POINTER (t2),
6485 TREE_STRING_LENGTH (t1)));
6489 unsigned HOST_WIDE_INT idx;
6490 VEC(constructor_elt, gc) *v1 = CONSTRUCTOR_ELTS (t1);
6491 VEC(constructor_elt, gc) *v2 = CONSTRUCTOR_ELTS (t2);
6493 if (VEC_length (constructor_elt, v1) != VEC_length (constructor_elt, v2))
6496 for (idx = 0; idx < VEC_length (constructor_elt, v1); ++idx)
6497 /* ??? Should we handle also fields here? */
6498 if (!simple_cst_equal (VEC_index (constructor_elt, v1, idx)->value,
6499 VEC_index (constructor_elt, v2, idx)->value))
6505 return simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
6508 cmp = simple_cst_equal (CALL_EXPR_FN (t1), CALL_EXPR_FN (t2));
6511 if (call_expr_nargs (t1) != call_expr_nargs (t2))
6514 const_tree arg1, arg2;
6515 const_call_expr_arg_iterator iter1, iter2;
6516 for (arg1 = first_const_call_expr_arg (t1, &iter1),
6517 arg2 = first_const_call_expr_arg (t2, &iter2);
6519 arg1 = next_const_call_expr_arg (&iter1),
6520 arg2 = next_const_call_expr_arg (&iter2))
6522 cmp = simple_cst_equal (arg1, arg2);
6526 return arg1 == arg2;
6530 /* Special case: if either target is an unallocated VAR_DECL,
6531 it means that it's going to be unified with whatever the
6532 TARGET_EXPR is really supposed to initialize, so treat it
6533 as being equivalent to anything. */
6534 if ((TREE_CODE (TREE_OPERAND (t1, 0)) == VAR_DECL
6535 && DECL_NAME (TREE_OPERAND (t1, 0)) == NULL_TREE
6536 && !DECL_RTL_SET_P (TREE_OPERAND (t1, 0)))
6537 || (TREE_CODE (TREE_OPERAND (t2, 0)) == VAR_DECL
6538 && DECL_NAME (TREE_OPERAND (t2, 0)) == NULL_TREE
6539 && !DECL_RTL_SET_P (TREE_OPERAND (t2, 0))))
6542 cmp = simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
6547 return simple_cst_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1));
6549 case WITH_CLEANUP_EXPR:
6550 cmp = simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
6554 return simple_cst_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t1, 1));
6557 if (TREE_OPERAND (t1, 1) == TREE_OPERAND (t2, 1))
6558 return simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
6572 /* This general rule works for most tree codes. All exceptions should be
6573 handled above. If this is a language-specific tree code, we can't
6574 trust what might be in the operand, so say we don't know
6576 if ((int) code1 >= (int) LAST_AND_UNUSED_TREE_CODE)
6579 switch (TREE_CODE_CLASS (code1))
6583 case tcc_comparison:
6584 case tcc_expression:
6588 for (i = 0; i < TREE_CODE_LENGTH (code1); i++)
6590 cmp = simple_cst_equal (TREE_OPERAND (t1, i), TREE_OPERAND (t2, i));
6602 /* Compare the value of T, an INTEGER_CST, with U, an unsigned integer value.
6603 Return -1, 0, or 1 if the value of T is less than, equal to, or greater
6604 than U, respectively. */
6607 compare_tree_int (const_tree t, unsigned HOST_WIDE_INT u)
6609 if (tree_int_cst_sgn (t) < 0)
6611 else if (TREE_INT_CST_HIGH (t) != 0)
6613 else if (TREE_INT_CST_LOW (t) == u)
6615 else if (TREE_INT_CST_LOW (t) < u)
6621 /* Return true if CODE represents an associative tree code. Otherwise
6624 associative_tree_code (enum tree_code code)
6643 /* Return true if CODE represents a commutative tree code. Otherwise
6646 commutative_tree_code (enum tree_code code)
6659 case UNORDERED_EXPR:
6663 case TRUTH_AND_EXPR:
6664 case TRUTH_XOR_EXPR:
6674 /* Return true if CODE represents a ternary tree code for which the
6675 first two operands are commutative. Otherwise return false. */
6677 commutative_ternary_tree_code (enum tree_code code)
6681 case WIDEN_MULT_PLUS_EXPR:
6682 case WIDEN_MULT_MINUS_EXPR:
6691 /* Generate a hash value for an expression. This can be used iteratively
6692 by passing a previous result as the VAL argument.
6694 This function is intended to produce the same hash for expressions which
6695 would compare equal using operand_equal_p. */
6698 iterative_hash_expr (const_tree t, hashval_t val)
6701 enum tree_code code;
6705 return iterative_hash_hashval_t (0, val);
6707 code = TREE_CODE (t);
6711 /* Alas, constants aren't shared, so we can't rely on pointer
6714 val = iterative_hash_host_wide_int (TREE_INT_CST_LOW (t), val);
6715 return iterative_hash_host_wide_int (TREE_INT_CST_HIGH (t), val);
6718 unsigned int val2 = real_hash (TREE_REAL_CST_PTR (t));
6720 return iterative_hash_hashval_t (val2, val);
6724 unsigned int val2 = fixed_hash (TREE_FIXED_CST_PTR (t));
6726 return iterative_hash_hashval_t (val2, val);
6729 return iterative_hash (TREE_STRING_POINTER (t),
6730 TREE_STRING_LENGTH (t), val);
6732 val = iterative_hash_expr (TREE_REALPART (t), val);
6733 return iterative_hash_expr (TREE_IMAGPART (t), val);
6735 return iterative_hash_expr (TREE_VECTOR_CST_ELTS (t), val);
6737 /* We can just compare by pointer. */
6738 return iterative_hash_host_wide_int (SSA_NAME_VERSION (t), val);
6739 case PLACEHOLDER_EXPR:
6740 /* The node itself doesn't matter. */
6743 /* A list of expressions, for a CALL_EXPR or as the elements of a
6745 for (; t; t = TREE_CHAIN (t))
6746 val = iterative_hash_expr (TREE_VALUE (t), val);
6750 unsigned HOST_WIDE_INT idx;
6752 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t), idx, field, value)
6754 val = iterative_hash_expr (field, val);
6755 val = iterative_hash_expr (value, val);
6761 /* The type of the second operand is relevant, except for
6762 its top-level qualifiers. */
6763 tree type = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_OPERAND (t, 1)));
6765 val = iterative_hash_object (TYPE_HASH (type), val);
6767 /* We could use the standard hash computation from this point
6769 val = iterative_hash_object (code, val);
6770 val = iterative_hash_expr (TREE_OPERAND (t, 1), val);
6771 val = iterative_hash_expr (TREE_OPERAND (t, 0), val);
6775 /* When referring to a built-in FUNCTION_DECL, use the __builtin__ form.
6776 Otherwise nodes that compare equal according to operand_equal_p might
6777 get different hash codes. However, don't do this for machine specific
6778 or front end builtins, since the function code is overloaded in those
6780 if (DECL_BUILT_IN_CLASS (t) == BUILT_IN_NORMAL
6781 && built_in_decls[DECL_FUNCTION_CODE (t)])
6783 t = built_in_decls[DECL_FUNCTION_CODE (t)];
6784 code = TREE_CODE (t);
6788 tclass = TREE_CODE_CLASS (code);
6790 if (tclass == tcc_declaration)
6792 /* DECL's have a unique ID */
6793 val = iterative_hash_host_wide_int (DECL_UID (t), val);
6797 gcc_assert (IS_EXPR_CODE_CLASS (tclass));
6799 val = iterative_hash_object (code, val);
6801 /* Don't hash the type, that can lead to having nodes which
6802 compare equal according to operand_equal_p, but which
6803 have different hash codes. */
6804 if (CONVERT_EXPR_CODE_P (code)
6805 || code == NON_LVALUE_EXPR)
6807 /* Make sure to include signness in the hash computation. */
6808 val += TYPE_UNSIGNED (TREE_TYPE (t));
6809 val = iterative_hash_expr (TREE_OPERAND (t, 0), val);
6812 else if (commutative_tree_code (code))
6814 /* It's a commutative expression. We want to hash it the same
6815 however it appears. We do this by first hashing both operands
6816 and then rehashing based on the order of their independent
6818 hashval_t one = iterative_hash_expr (TREE_OPERAND (t, 0), 0);
6819 hashval_t two = iterative_hash_expr (TREE_OPERAND (t, 1), 0);
6823 t = one, one = two, two = t;
6825 val = iterative_hash_hashval_t (one, val);
6826 val = iterative_hash_hashval_t (two, val);
6829 for (i = TREE_OPERAND_LENGTH (t) - 1; i >= 0; --i)
6830 val = iterative_hash_expr (TREE_OPERAND (t, i), val);
6837 /* Generate a hash value for a pair of expressions. This can be used
6838 iteratively by passing a previous result as the VAL argument.
6840 The same hash value is always returned for a given pair of expressions,
6841 regardless of the order in which they are presented. This is useful in
6842 hashing the operands of commutative functions. */
6845 iterative_hash_exprs_commutative (const_tree t1,
6846 const_tree t2, hashval_t val)
6848 hashval_t one = iterative_hash_expr (t1, 0);
6849 hashval_t two = iterative_hash_expr (t2, 0);
6853 t = one, one = two, two = t;
6854 val = iterative_hash_hashval_t (one, val);
6855 val = iterative_hash_hashval_t (two, val);
6860 /* Constructors for pointer, array and function types.
6861 (RECORD_TYPE, UNION_TYPE and ENUMERAL_TYPE nodes are
6862 constructed by language-dependent code, not here.) */
6864 /* Construct, lay out and return the type of pointers to TO_TYPE with
6865 mode MODE. If CAN_ALIAS_ALL is TRUE, indicate this type can
6866 reference all of memory. If such a type has already been
6867 constructed, reuse it. */
6870 build_pointer_type_for_mode (tree to_type, enum machine_mode mode,
6875 if (to_type == error_mark_node)
6876 return error_mark_node;
6878 /* If the pointed-to type has the may_alias attribute set, force
6879 a TYPE_REF_CAN_ALIAS_ALL pointer to be generated. */
6880 if (lookup_attribute ("may_alias", TYPE_ATTRIBUTES (to_type)))
6881 can_alias_all = true;
6883 /* In some cases, languages will have things that aren't a POINTER_TYPE
6884 (such as a RECORD_TYPE for fat pointers in Ada) as TYPE_POINTER_TO.
6885 In that case, return that type without regard to the rest of our
6888 ??? This is a kludge, but consistent with the way this function has
6889 always operated and there doesn't seem to be a good way to avoid this
6891 if (TYPE_POINTER_TO (to_type) != 0
6892 && TREE_CODE (TYPE_POINTER_TO (to_type)) != POINTER_TYPE)
6893 return TYPE_POINTER_TO (to_type);
6895 /* First, if we already have a type for pointers to TO_TYPE and it's
6896 the proper mode, use it. */
6897 for (t = TYPE_POINTER_TO (to_type); t; t = TYPE_NEXT_PTR_TO (t))
6898 if (TYPE_MODE (t) == mode && TYPE_REF_CAN_ALIAS_ALL (t) == can_alias_all)
6901 t = make_node (POINTER_TYPE);
6903 TREE_TYPE (t) = to_type;
6904 SET_TYPE_MODE (t, mode);
6905 TYPE_REF_CAN_ALIAS_ALL (t) = can_alias_all;
6906 TYPE_NEXT_PTR_TO (t) = TYPE_POINTER_TO (to_type);
6907 TYPE_POINTER_TO (to_type) = t;
6909 if (TYPE_STRUCTURAL_EQUALITY_P (to_type))
6910 SET_TYPE_STRUCTURAL_EQUALITY (t);
6911 else if (TYPE_CANONICAL (to_type) != to_type)
6913 = build_pointer_type_for_mode (TYPE_CANONICAL (to_type),
6914 mode, can_alias_all);
6916 /* Lay out the type. This function has many callers that are concerned
6917 with expression-construction, and this simplifies them all. */
6923 /* By default build pointers in ptr_mode. */
6926 build_pointer_type (tree to_type)
6928 addr_space_t as = to_type == error_mark_node? ADDR_SPACE_GENERIC
6929 : TYPE_ADDR_SPACE (to_type);
6930 enum machine_mode pointer_mode = targetm.addr_space.pointer_mode (as);
6931 return build_pointer_type_for_mode (to_type, pointer_mode, false);
6934 /* Same as build_pointer_type_for_mode, but for REFERENCE_TYPE. */
6937 build_reference_type_for_mode (tree to_type, enum machine_mode mode,
6942 if (to_type == error_mark_node)
6943 return error_mark_node;
6945 /* If the pointed-to type has the may_alias attribute set, force
6946 a TYPE_REF_CAN_ALIAS_ALL pointer to be generated. */
6947 if (lookup_attribute ("may_alias", TYPE_ATTRIBUTES (to_type)))
6948 can_alias_all = true;
6950 /* In some cases, languages will have things that aren't a REFERENCE_TYPE
6951 (such as a RECORD_TYPE for fat pointers in Ada) as TYPE_REFERENCE_TO.
6952 In that case, return that type without regard to the rest of our
6955 ??? This is a kludge, but consistent with the way this function has
6956 always operated and there doesn't seem to be a good way to avoid this
6958 if (TYPE_REFERENCE_TO (to_type) != 0
6959 && TREE_CODE (TYPE_REFERENCE_TO (to_type)) != REFERENCE_TYPE)
6960 return TYPE_REFERENCE_TO (to_type);
6962 /* First, if we already have a type for pointers to TO_TYPE and it's
6963 the proper mode, use it. */
6964 for (t = TYPE_REFERENCE_TO (to_type); t; t = TYPE_NEXT_REF_TO (t))
6965 if (TYPE_MODE (t) == mode && TYPE_REF_CAN_ALIAS_ALL (t) == can_alias_all)
6968 t = make_node (REFERENCE_TYPE);
6970 TREE_TYPE (t) = to_type;
6971 SET_TYPE_MODE (t, mode);
6972 TYPE_REF_CAN_ALIAS_ALL (t) = can_alias_all;
6973 TYPE_NEXT_REF_TO (t) = TYPE_REFERENCE_TO (to_type);
6974 TYPE_REFERENCE_TO (to_type) = t;
6976 if (TYPE_STRUCTURAL_EQUALITY_P (to_type))
6977 SET_TYPE_STRUCTURAL_EQUALITY (t);
6978 else if (TYPE_CANONICAL (to_type) != to_type)
6980 = build_reference_type_for_mode (TYPE_CANONICAL (to_type),
6981 mode, can_alias_all);
6989 /* Build the node for the type of references-to-TO_TYPE by default
6993 build_reference_type (tree to_type)
6995 addr_space_t as = to_type == error_mark_node? ADDR_SPACE_GENERIC
6996 : TYPE_ADDR_SPACE (to_type);
6997 enum machine_mode pointer_mode = targetm.addr_space.pointer_mode (as);
6998 return build_reference_type_for_mode (to_type, pointer_mode, false);
7001 /* Build a type that is compatible with t but has no cv quals anywhere
7004 const char *const *const * -> char ***. */
7007 build_type_no_quals (tree t)
7009 switch (TREE_CODE (t))
7012 return build_pointer_type_for_mode (build_type_no_quals (TREE_TYPE (t)),
7014 TYPE_REF_CAN_ALIAS_ALL (t));
7015 case REFERENCE_TYPE:
7017 build_reference_type_for_mode (build_type_no_quals (TREE_TYPE (t)),
7019 TYPE_REF_CAN_ALIAS_ALL (t));
7021 return TYPE_MAIN_VARIANT (t);
7025 #define MAX_INT_CACHED_PREC \
7026 (HOST_BITS_PER_WIDE_INT > 64 ? HOST_BITS_PER_WIDE_INT : 64)
7027 static GTY(()) tree nonstandard_integer_type_cache[2 * MAX_INT_CACHED_PREC + 2];
7029 /* Builds a signed or unsigned integer type of precision PRECISION.
7030 Used for C bitfields whose precision does not match that of
7031 built-in target types. */
7033 build_nonstandard_integer_type (unsigned HOST_WIDE_INT precision,
7039 unsignedp = MAX_INT_CACHED_PREC + 1;
7041 if (precision <= MAX_INT_CACHED_PREC)
7043 itype = nonstandard_integer_type_cache[precision + unsignedp];
7048 itype = make_node (INTEGER_TYPE);
7049 TYPE_PRECISION (itype) = precision;
7052 fixup_unsigned_type (itype);
7054 fixup_signed_type (itype);
7057 if (host_integerp (TYPE_MAX_VALUE (itype), 1))
7058 ret = type_hash_canon (tree_low_cst (TYPE_MAX_VALUE (itype), 1), itype);
7059 if (precision <= MAX_INT_CACHED_PREC)
7060 nonstandard_integer_type_cache[precision + unsignedp] = ret;
7065 /* Create a range of some discrete type TYPE (an INTEGER_TYPE, ENUMERAL_TYPE
7066 or BOOLEAN_TYPE) with low bound LOWVAL and high bound HIGHVAL. If SHARED
7067 is true, reuse such a type that has already been constructed. */
7070 build_range_type_1 (tree type, tree lowval, tree highval, bool shared)
7072 tree itype = make_node (INTEGER_TYPE);
7074 TREE_TYPE (itype) = type;
7076 TYPE_MIN_VALUE (itype) = fold_convert (type, lowval);
7077 TYPE_MAX_VALUE (itype) = highval ? fold_convert (type, highval) : NULL;
7079 TYPE_PRECISION (itype) = TYPE_PRECISION (type);
7080 SET_TYPE_MODE (itype, TYPE_MODE (type));
7081 TYPE_SIZE (itype) = TYPE_SIZE (type);
7082 TYPE_SIZE_UNIT (itype) = TYPE_SIZE_UNIT (type);
7083 TYPE_ALIGN (itype) = TYPE_ALIGN (type);
7084 TYPE_USER_ALIGN (itype) = TYPE_USER_ALIGN (type);
7086 if ((TYPE_MIN_VALUE (itype)
7087 && TREE_CODE (TYPE_MIN_VALUE (itype)) != INTEGER_CST)
7088 || (TYPE_MAX_VALUE (itype)
7089 && TREE_CODE (TYPE_MAX_VALUE (itype)) != INTEGER_CST))
7091 /* Since we cannot reliably merge this type, we need to compare it using
7092 structural equality checks. */
7093 SET_TYPE_STRUCTURAL_EQUALITY (itype);
7099 hashval_t hash = iterative_hash_expr (TYPE_MIN_VALUE (itype), 0);
7100 hash = iterative_hash_expr (TYPE_MAX_VALUE (itype), hash);
7101 hash = iterative_hash_hashval_t (TYPE_HASH (type), hash);
7102 itype = type_hash_canon (hash, itype);
7108 /* Wrapper around build_range_type_1 with SHARED set to true. */
7111 build_range_type (tree type, tree lowval, tree highval)
7113 return build_range_type_1 (type, lowval, highval, true);
7116 /* Wrapper around build_range_type_1 with SHARED set to false. */
7119 build_nonshared_range_type (tree type, tree lowval, tree highval)
7121 return build_range_type_1 (type, lowval, highval, false);
7124 /* Create a type of integers to be the TYPE_DOMAIN of an ARRAY_TYPE.
7125 MAXVAL should be the maximum value in the domain
7126 (one less than the length of the array).
7128 The maximum value that MAXVAL can have is INT_MAX for a HOST_WIDE_INT.
7129 We don't enforce this limit, that is up to caller (e.g. language front end).
7130 The limit exists because the result is a signed type and we don't handle
7131 sizes that use more than one HOST_WIDE_INT. */
7134 build_index_type (tree maxval)
7136 return build_range_type (sizetype, size_zero_node, maxval);
7139 /* Return true if the debug information for TYPE, a subtype, should be emitted
7140 as a subrange type. If so, set LOWVAL to the low bound and HIGHVAL to the
7141 high bound, respectively. Sometimes doing so unnecessarily obfuscates the
7142 debug info and doesn't reflect the source code. */
7145 subrange_type_for_debug_p (const_tree type, tree *lowval, tree *highval)
7147 tree base_type = TREE_TYPE (type), low, high;
7149 /* Subrange types have a base type which is an integral type. */
7150 if (!INTEGRAL_TYPE_P (base_type))
7153 /* Get the real bounds of the subtype. */
7154 if (lang_hooks.types.get_subrange_bounds)
7155 lang_hooks.types.get_subrange_bounds (type, &low, &high);
7158 low = TYPE_MIN_VALUE (type);
7159 high = TYPE_MAX_VALUE (type);
7162 /* If the type and its base type have the same representation and the same
7163 name, then the type is not a subrange but a copy of the base type. */
7164 if ((TREE_CODE (base_type) == INTEGER_TYPE
7165 || TREE_CODE (base_type) == BOOLEAN_TYPE)
7166 && int_size_in_bytes (type) == int_size_in_bytes (base_type)
7167 && tree_int_cst_equal (low, TYPE_MIN_VALUE (base_type))
7168 && tree_int_cst_equal (high, TYPE_MAX_VALUE (base_type)))
7170 tree type_name = TYPE_NAME (type);
7171 tree base_type_name = TYPE_NAME (base_type);
7173 if (type_name && TREE_CODE (type_name) == TYPE_DECL)
7174 type_name = DECL_NAME (type_name);
7176 if (base_type_name && TREE_CODE (base_type_name) == TYPE_DECL)
7177 base_type_name = DECL_NAME (base_type_name);
7179 if (type_name == base_type_name)
7190 /* Construct, lay out and return the type of arrays of elements with ELT_TYPE
7191 and number of elements specified by the range of values of INDEX_TYPE.
7192 If SHARED is true, reuse such a type that has already been constructed. */
7195 build_array_type_1 (tree elt_type, tree index_type, bool shared)
7199 if (TREE_CODE (elt_type) == FUNCTION_TYPE)
7201 error ("arrays of functions are not meaningful");
7202 elt_type = integer_type_node;
7205 t = make_node (ARRAY_TYPE);
7206 TREE_TYPE (t) = elt_type;
7207 TYPE_DOMAIN (t) = index_type;
7208 TYPE_ADDR_SPACE (t) = TYPE_ADDR_SPACE (elt_type);
7211 /* If the element type is incomplete at this point we get marked for
7212 structural equality. Do not record these types in the canonical
7214 if (TYPE_STRUCTURAL_EQUALITY_P (t))
7219 hashval_t hashcode = iterative_hash_object (TYPE_HASH (elt_type), 0);
7221 hashcode = iterative_hash_object (TYPE_HASH (index_type), hashcode);
7222 t = type_hash_canon (hashcode, t);
7225 if (TYPE_CANONICAL (t) == t)
7227 if (TYPE_STRUCTURAL_EQUALITY_P (elt_type)
7228 || (index_type && TYPE_STRUCTURAL_EQUALITY_P (index_type)))
7229 SET_TYPE_STRUCTURAL_EQUALITY (t);
7230 else if (TYPE_CANONICAL (elt_type) != elt_type
7231 || (index_type && TYPE_CANONICAL (index_type) != index_type))
7233 = build_array_type_1 (TYPE_CANONICAL (elt_type),
7235 ? TYPE_CANONICAL (index_type) : NULL_TREE,
7242 /* Wrapper around build_array_type_1 with SHARED set to true. */
7245 build_array_type (tree elt_type, tree index_type)
7247 return build_array_type_1 (elt_type, index_type, true);
7250 /* Wrapper around build_array_type_1 with SHARED set to false. */
7253 build_nonshared_array_type (tree elt_type, tree index_type)
7255 return build_array_type_1 (elt_type, index_type, false);
7258 /* Recursively examines the array elements of TYPE, until a non-array
7259 element type is found. */
7262 strip_array_types (tree type)
7264 while (TREE_CODE (type) == ARRAY_TYPE)
7265 type = TREE_TYPE (type);
7270 /* Computes the canonical argument types from the argument type list
7273 Upon return, *ANY_STRUCTURAL_P will be true iff either it was true
7274 on entry to this function, or if any of the ARGTYPES are
7277 Upon return, *ANY_NONCANONICAL_P will be true iff either it was
7278 true on entry to this function, or if any of the ARGTYPES are
7281 Returns a canonical argument list, which may be ARGTYPES when the
7282 canonical argument list is unneeded (i.e., *ANY_STRUCTURAL_P is
7283 true) or would not differ from ARGTYPES. */
7286 maybe_canonicalize_argtypes(tree argtypes,
7287 bool *any_structural_p,
7288 bool *any_noncanonical_p)
7291 bool any_noncanonical_argtypes_p = false;
7293 for (arg = argtypes; arg && !(*any_structural_p); arg = TREE_CHAIN (arg))
7295 if (!TREE_VALUE (arg) || TREE_VALUE (arg) == error_mark_node)
7296 /* Fail gracefully by stating that the type is structural. */
7297 *any_structural_p = true;
7298 else if (TYPE_STRUCTURAL_EQUALITY_P (TREE_VALUE (arg)))
7299 *any_structural_p = true;
7300 else if (TYPE_CANONICAL (TREE_VALUE (arg)) != TREE_VALUE (arg)
7301 || TREE_PURPOSE (arg))
7302 /* If the argument has a default argument, we consider it
7303 non-canonical even though the type itself is canonical.
7304 That way, different variants of function and method types
7305 with default arguments will all point to the variant with
7306 no defaults as their canonical type. */
7307 any_noncanonical_argtypes_p = true;
7310 if (*any_structural_p)
7313 if (any_noncanonical_argtypes_p)
7315 /* Build the canonical list of argument types. */
7316 tree canon_argtypes = NULL_TREE;
7317 bool is_void = false;
7319 for (arg = argtypes; arg; arg = TREE_CHAIN (arg))
7321 if (arg == void_list_node)
7324 canon_argtypes = tree_cons (NULL_TREE,
7325 TYPE_CANONICAL (TREE_VALUE (arg)),
7329 canon_argtypes = nreverse (canon_argtypes);
7331 canon_argtypes = chainon (canon_argtypes, void_list_node);
7333 /* There is a non-canonical type. */
7334 *any_noncanonical_p = true;
7335 return canon_argtypes;
7338 /* The canonical argument types are the same as ARGTYPES. */
7342 /* Construct, lay out and return
7343 the type of functions returning type VALUE_TYPE
7344 given arguments of types ARG_TYPES.
7345 ARG_TYPES is a chain of TREE_LIST nodes whose TREE_VALUEs
7346 are data type nodes for the arguments of the function.
7347 If such a type has already been constructed, reuse it. */
7350 build_function_type (tree value_type, tree arg_types)
7353 hashval_t hashcode = 0;
7354 bool any_structural_p, any_noncanonical_p;
7355 tree canon_argtypes;
7357 if (TREE_CODE (value_type) == FUNCTION_TYPE)
7359 error ("function return type cannot be function");
7360 value_type = integer_type_node;
7363 /* Make a node of the sort we want. */
7364 t = make_node (FUNCTION_TYPE);
7365 TREE_TYPE (t) = value_type;
7366 TYPE_ARG_TYPES (t) = arg_types;
7368 /* If we already have such a type, use the old one. */
7369 hashcode = iterative_hash_object (TYPE_HASH (value_type), hashcode);
7370 hashcode = type_hash_list (arg_types, hashcode);
7371 t = type_hash_canon (hashcode, t);
7373 /* Set up the canonical type. */
7374 any_structural_p = TYPE_STRUCTURAL_EQUALITY_P (value_type);
7375 any_noncanonical_p = TYPE_CANONICAL (value_type) != value_type;
7376 canon_argtypes = maybe_canonicalize_argtypes (arg_types,
7378 &any_noncanonical_p);
7379 if (any_structural_p)
7380 SET_TYPE_STRUCTURAL_EQUALITY (t);
7381 else if (any_noncanonical_p)
7382 TYPE_CANONICAL (t) = build_function_type (TYPE_CANONICAL (value_type),
7385 if (!COMPLETE_TYPE_P (t))
7390 /* Build variant of function type ORIG_TYPE skipping ARGS_TO_SKIP. */
7393 build_function_type_skip_args (tree orig_type, bitmap args_to_skip)
7395 tree new_type = NULL;
7396 tree args, new_args = NULL, t;
7400 for (args = TYPE_ARG_TYPES (orig_type); args && args != void_list_node;
7401 args = TREE_CHAIN (args), i++)
7402 if (!bitmap_bit_p (args_to_skip, i))
7403 new_args = tree_cons (NULL_TREE, TREE_VALUE (args), new_args);
7405 new_reversed = nreverse (new_args);
7409 TREE_CHAIN (new_args) = void_list_node;
7411 new_reversed = void_list_node;
7414 /* Use copy_node to preserve as much as possible from original type
7415 (debug info, attribute lists etc.)
7416 Exception is METHOD_TYPEs must have THIS argument.
7417 When we are asked to remove it, we need to build new FUNCTION_TYPE
7419 if (TREE_CODE (orig_type) != METHOD_TYPE
7420 || !bitmap_bit_p (args_to_skip, 0))
7422 new_type = build_distinct_type_copy (orig_type);
7423 TYPE_ARG_TYPES (new_type) = new_reversed;
7428 = build_distinct_type_copy (build_function_type (TREE_TYPE (orig_type),
7430 TYPE_CONTEXT (new_type) = TYPE_CONTEXT (orig_type);
7433 /* This is a new type, not a copy of an old type. Need to reassociate
7434 variants. We can handle everything except the main variant lazily. */
7435 t = TYPE_MAIN_VARIANT (orig_type);
7438 TYPE_MAIN_VARIANT (new_type) = t;
7439 TYPE_NEXT_VARIANT (new_type) = TYPE_NEXT_VARIANT (t);
7440 TYPE_NEXT_VARIANT (t) = new_type;
7444 TYPE_MAIN_VARIANT (new_type) = new_type;
7445 TYPE_NEXT_VARIANT (new_type) = NULL;
7450 /* Build variant of function type ORIG_TYPE skipping ARGS_TO_SKIP.
7452 Arguments from DECL_ARGUMENTS list can't be removed now, since they are
7453 linked by TREE_CHAIN directly. The caller is responsible for eliminating
7454 them when they are being duplicated (i.e. copy_arguments_for_versioning). */
7457 build_function_decl_skip_args (tree orig_decl, bitmap args_to_skip)
7459 tree new_decl = copy_node (orig_decl);
7462 new_type = TREE_TYPE (orig_decl);
7463 if (prototype_p (new_type))
7464 new_type = build_function_type_skip_args (new_type, args_to_skip);
7465 TREE_TYPE (new_decl) = new_type;
7467 /* For declarations setting DECL_VINDEX (i.e. methods)
7468 we expect first argument to be THIS pointer. */
7469 if (bitmap_bit_p (args_to_skip, 0))
7470 DECL_VINDEX (new_decl) = NULL_TREE;
7472 /* When signature changes, we need to clear builtin info. */
7473 if (DECL_BUILT_IN (new_decl) && !bitmap_empty_p (args_to_skip))
7475 DECL_BUILT_IN_CLASS (new_decl) = NOT_BUILT_IN;
7476 DECL_FUNCTION_CODE (new_decl) = (enum built_in_function) 0;
7481 /* Build a function type. The RETURN_TYPE is the type returned by the
7482 function. If VAARGS is set, no void_type_node is appended to the
7483 the list. ARGP must be always be terminated be a NULL_TREE. */
7486 build_function_type_list_1 (bool vaargs, tree return_type, va_list argp)
7490 t = va_arg (argp, tree);
7491 for (args = NULL_TREE; t != NULL_TREE; t = va_arg (argp, tree))
7492 args = tree_cons (NULL_TREE, t, args);
7497 if (args != NULL_TREE)
7498 args = nreverse (args);
7499 gcc_assert (last != void_list_node);
7501 else if (args == NULL_TREE)
7502 args = void_list_node;
7506 args = nreverse (args);
7507 TREE_CHAIN (last) = void_list_node;
7509 args = build_function_type (return_type, args);
7514 /* Build a function type. The RETURN_TYPE is the type returned by the
7515 function. If additional arguments are provided, they are
7516 additional argument types. The list of argument types must always
7517 be terminated by NULL_TREE. */
7520 build_function_type_list (tree return_type, ...)
7525 va_start (p, return_type);
7526 args = build_function_type_list_1 (false, return_type, p);
7531 /* Build a variable argument function type. The RETURN_TYPE is the
7532 type returned by the function. If additional arguments are provided,
7533 they are additional argument types. The list of argument types must
7534 always be terminated by NULL_TREE. */
7537 build_varargs_function_type_list (tree return_type, ...)
7542 va_start (p, return_type);
7543 args = build_function_type_list_1 (true, return_type, p);
7549 /* Build a METHOD_TYPE for a member of BASETYPE. The RETTYPE (a TYPE)
7550 and ARGTYPES (a TREE_LIST) are the return type and arguments types
7551 for the method. An implicit additional parameter (of type
7552 pointer-to-BASETYPE) is added to the ARGTYPES. */
7555 build_method_type_directly (tree basetype,
7562 bool any_structural_p, any_noncanonical_p;
7563 tree canon_argtypes;
7565 /* Make a node of the sort we want. */
7566 t = make_node (METHOD_TYPE);
7568 TYPE_METHOD_BASETYPE (t) = TYPE_MAIN_VARIANT (basetype);
7569 TREE_TYPE (t) = rettype;
7570 ptype = build_pointer_type (basetype);
7572 /* The actual arglist for this function includes a "hidden" argument
7573 which is "this". Put it into the list of argument types. */
7574 argtypes = tree_cons (NULL_TREE, ptype, argtypes);
7575 TYPE_ARG_TYPES (t) = argtypes;
7577 /* If we already have such a type, use the old one. */
7578 hashcode = iterative_hash_object (TYPE_HASH (basetype), hashcode);
7579 hashcode = iterative_hash_object (TYPE_HASH (rettype), hashcode);
7580 hashcode = type_hash_list (argtypes, hashcode);
7581 t = type_hash_canon (hashcode, t);
7583 /* Set up the canonical type. */
7585 = (TYPE_STRUCTURAL_EQUALITY_P (basetype)
7586 || TYPE_STRUCTURAL_EQUALITY_P (rettype));
7588 = (TYPE_CANONICAL (basetype) != basetype
7589 || TYPE_CANONICAL (rettype) != rettype);
7590 canon_argtypes = maybe_canonicalize_argtypes (TREE_CHAIN (argtypes),
7592 &any_noncanonical_p);
7593 if (any_structural_p)
7594 SET_TYPE_STRUCTURAL_EQUALITY (t);
7595 else if (any_noncanonical_p)
7597 = build_method_type_directly (TYPE_CANONICAL (basetype),
7598 TYPE_CANONICAL (rettype),
7600 if (!COMPLETE_TYPE_P (t))
7606 /* Construct, lay out and return the type of methods belonging to class
7607 BASETYPE and whose arguments and values are described by TYPE.
7608 If that type exists already, reuse it.
7609 TYPE must be a FUNCTION_TYPE node. */
7612 build_method_type (tree basetype, tree type)
7614 gcc_assert (TREE_CODE (type) == FUNCTION_TYPE);
7616 return build_method_type_directly (basetype,
7618 TYPE_ARG_TYPES (type));
7621 /* Construct, lay out and return the type of offsets to a value
7622 of type TYPE, within an object of type BASETYPE.
7623 If a suitable offset type exists already, reuse it. */
7626 build_offset_type (tree basetype, tree type)
7629 hashval_t hashcode = 0;
7631 /* Make a node of the sort we want. */
7632 t = make_node (OFFSET_TYPE);
7634 TYPE_OFFSET_BASETYPE (t) = TYPE_MAIN_VARIANT (basetype);
7635 TREE_TYPE (t) = type;
7637 /* If we already have such a type, use the old one. */
7638 hashcode = iterative_hash_object (TYPE_HASH (basetype), hashcode);
7639 hashcode = iterative_hash_object (TYPE_HASH (type), hashcode);
7640 t = type_hash_canon (hashcode, t);
7642 if (!COMPLETE_TYPE_P (t))
7645 if (TYPE_CANONICAL (t) == t)
7647 if (TYPE_STRUCTURAL_EQUALITY_P (basetype)
7648 || TYPE_STRUCTURAL_EQUALITY_P (type))
7649 SET_TYPE_STRUCTURAL_EQUALITY (t);
7650 else if (TYPE_CANONICAL (TYPE_MAIN_VARIANT (basetype)) != basetype
7651 || TYPE_CANONICAL (type) != type)
7653 = build_offset_type (TYPE_CANONICAL (TYPE_MAIN_VARIANT (basetype)),
7654 TYPE_CANONICAL (type));
7660 /* Create a complex type whose components are COMPONENT_TYPE. */
7663 build_complex_type (tree component_type)
7668 gcc_assert (INTEGRAL_TYPE_P (component_type)
7669 || SCALAR_FLOAT_TYPE_P (component_type)
7670 || FIXED_POINT_TYPE_P (component_type));
7672 /* Make a node of the sort we want. */
7673 t = make_node (COMPLEX_TYPE);
7675 TREE_TYPE (t) = TYPE_MAIN_VARIANT (component_type);
7677 /* If we already have such a type, use the old one. */
7678 hashcode = iterative_hash_object (TYPE_HASH (component_type), 0);
7679 t = type_hash_canon (hashcode, t);
7681 if (!COMPLETE_TYPE_P (t))
7684 if (TYPE_CANONICAL (t) == t)
7686 if (TYPE_STRUCTURAL_EQUALITY_P (component_type))
7687 SET_TYPE_STRUCTURAL_EQUALITY (t);
7688 else if (TYPE_CANONICAL (component_type) != component_type)
7690 = build_complex_type (TYPE_CANONICAL (component_type));
7693 /* We need to create a name, since complex is a fundamental type. */
7694 if (! TYPE_NAME (t))
7697 if (component_type == char_type_node)
7698 name = "complex char";
7699 else if (component_type == signed_char_type_node)
7700 name = "complex signed char";
7701 else if (component_type == unsigned_char_type_node)
7702 name = "complex unsigned char";
7703 else if (component_type == short_integer_type_node)
7704 name = "complex short int";
7705 else if (component_type == short_unsigned_type_node)
7706 name = "complex short unsigned int";
7707 else if (component_type == integer_type_node)
7708 name = "complex int";
7709 else if (component_type == unsigned_type_node)
7710 name = "complex unsigned int";
7711 else if (component_type == long_integer_type_node)
7712 name = "complex long int";
7713 else if (component_type == long_unsigned_type_node)
7714 name = "complex long unsigned int";
7715 else if (component_type == long_long_integer_type_node)
7716 name = "complex long long int";
7717 else if (component_type == long_long_unsigned_type_node)
7718 name = "complex long long unsigned int";
7723 TYPE_NAME (t) = build_decl (UNKNOWN_LOCATION, TYPE_DECL,
7724 get_identifier (name), t);
7727 return build_qualified_type (t, TYPE_QUALS (component_type));
7730 /* If TYPE is a real or complex floating-point type and the target
7731 does not directly support arithmetic on TYPE then return the wider
7732 type to be used for arithmetic on TYPE. Otherwise, return
7736 excess_precision_type (tree type)
7738 if (flag_excess_precision != EXCESS_PRECISION_FAST)
7740 int flt_eval_method = TARGET_FLT_EVAL_METHOD;
7741 switch (TREE_CODE (type))
7744 switch (flt_eval_method)
7747 if (TYPE_MODE (type) == TYPE_MODE (float_type_node))
7748 return double_type_node;
7751 if (TYPE_MODE (type) == TYPE_MODE (float_type_node)
7752 || TYPE_MODE (type) == TYPE_MODE (double_type_node))
7753 return long_double_type_node;
7760 if (TREE_CODE (TREE_TYPE (type)) != REAL_TYPE)
7762 switch (flt_eval_method)
7765 if (TYPE_MODE (TREE_TYPE (type)) == TYPE_MODE (float_type_node))
7766 return complex_double_type_node;
7769 if (TYPE_MODE (TREE_TYPE (type)) == TYPE_MODE (float_type_node)
7770 || (TYPE_MODE (TREE_TYPE (type))
7771 == TYPE_MODE (double_type_node)))
7772 return complex_long_double_type_node;
7785 /* Return OP, stripped of any conversions to wider types as much as is safe.
7786 Converting the value back to OP's type makes a value equivalent to OP.
7788 If FOR_TYPE is nonzero, we return a value which, if converted to
7789 type FOR_TYPE, would be equivalent to converting OP to type FOR_TYPE.
7791 OP must have integer, real or enumeral type. Pointers are not allowed!
7793 There are some cases where the obvious value we could return
7794 would regenerate to OP if converted to OP's type,
7795 but would not extend like OP to wider types.
7796 If FOR_TYPE indicates such extension is contemplated, we eschew such values.
7797 For example, if OP is (unsigned short)(signed char)-1,
7798 we avoid returning (signed char)-1 if FOR_TYPE is int,
7799 even though extending that to an unsigned short would regenerate OP,
7800 since the result of extending (signed char)-1 to (int)
7801 is different from (int) OP. */
7804 get_unwidened (tree op, tree for_type)
7806 /* Set UNS initially if converting OP to FOR_TYPE is a zero-extension. */
7807 tree type = TREE_TYPE (op);
7809 = TYPE_PRECISION (for_type != 0 ? for_type : type);
7811 = (for_type != 0 && for_type != type
7812 && final_prec > TYPE_PRECISION (type)
7813 && TYPE_UNSIGNED (type));
7816 while (CONVERT_EXPR_P (op))
7820 /* TYPE_PRECISION on vector types has different meaning
7821 (TYPE_VECTOR_SUBPARTS) and casts from vectors are view conversions,
7822 so avoid them here. */
7823 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (op, 0))) == VECTOR_TYPE)
7826 bitschange = TYPE_PRECISION (TREE_TYPE (op))
7827 - TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op, 0)));
7829 /* Truncations are many-one so cannot be removed.
7830 Unless we are later going to truncate down even farther. */
7832 && final_prec > TYPE_PRECISION (TREE_TYPE (op)))
7835 /* See what's inside this conversion. If we decide to strip it,
7837 op = TREE_OPERAND (op, 0);
7839 /* If we have not stripped any zero-extensions (uns is 0),
7840 we can strip any kind of extension.
7841 If we have previously stripped a zero-extension,
7842 only zero-extensions can safely be stripped.
7843 Any extension can be stripped if the bits it would produce
7844 are all going to be discarded later by truncating to FOR_TYPE. */
7848 if (! uns || final_prec <= TYPE_PRECISION (TREE_TYPE (op)))
7850 /* TYPE_UNSIGNED says whether this is a zero-extension.
7851 Let's avoid computing it if it does not affect WIN
7852 and if UNS will not be needed again. */
7854 || CONVERT_EXPR_P (op))
7855 && TYPE_UNSIGNED (TREE_TYPE (op)))
7863 /* If we finally reach a constant see if it fits in for_type and
7864 in that case convert it. */
7866 && TREE_CODE (win) == INTEGER_CST
7867 && TREE_TYPE (win) != for_type
7868 && int_fits_type_p (win, for_type))
7869 win = fold_convert (for_type, win);
7874 /* Return OP or a simpler expression for a narrower value
7875 which can be sign-extended or zero-extended to give back OP.
7876 Store in *UNSIGNEDP_PTR either 1 if the value should be zero-extended
7877 or 0 if the value should be sign-extended. */
7880 get_narrower (tree op, int *unsignedp_ptr)
7885 bool integral_p = INTEGRAL_TYPE_P (TREE_TYPE (op));
7887 while (TREE_CODE (op) == NOP_EXPR)
7890 = (TYPE_PRECISION (TREE_TYPE (op))
7891 - TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op, 0))));
7893 /* Truncations are many-one so cannot be removed. */
7897 /* See what's inside this conversion. If we decide to strip it,
7902 op = TREE_OPERAND (op, 0);
7903 /* An extension: the outermost one can be stripped,
7904 but remember whether it is zero or sign extension. */
7906 uns = TYPE_UNSIGNED (TREE_TYPE (op));
7907 /* Otherwise, if a sign extension has been stripped,
7908 only sign extensions can now be stripped;
7909 if a zero extension has been stripped, only zero-extensions. */
7910 else if (uns != TYPE_UNSIGNED (TREE_TYPE (op)))
7914 else /* bitschange == 0 */
7916 /* A change in nominal type can always be stripped, but we must
7917 preserve the unsignedness. */
7919 uns = TYPE_UNSIGNED (TREE_TYPE (op));
7921 op = TREE_OPERAND (op, 0);
7922 /* Keep trying to narrow, but don't assign op to win if it
7923 would turn an integral type into something else. */
7924 if (INTEGRAL_TYPE_P (TREE_TYPE (op)) != integral_p)
7931 if (TREE_CODE (op) == COMPONENT_REF
7932 /* Since type_for_size always gives an integer type. */
7933 && TREE_CODE (TREE_TYPE (op)) != REAL_TYPE
7934 && TREE_CODE (TREE_TYPE (op)) != FIXED_POINT_TYPE
7935 /* Ensure field is laid out already. */
7936 && DECL_SIZE (TREE_OPERAND (op, 1)) != 0
7937 && host_integerp (DECL_SIZE (TREE_OPERAND (op, 1)), 1))
7939 unsigned HOST_WIDE_INT innerprec
7940 = tree_low_cst (DECL_SIZE (TREE_OPERAND (op, 1)), 1);
7941 int unsignedp = (DECL_UNSIGNED (TREE_OPERAND (op, 1))
7942 || TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op, 1))));
7943 tree type = lang_hooks.types.type_for_size (innerprec, unsignedp);
7945 /* We can get this structure field in a narrower type that fits it,
7946 but the resulting extension to its nominal type (a fullword type)
7947 must satisfy the same conditions as for other extensions.
7949 Do this only for fields that are aligned (not bit-fields),
7950 because when bit-field insns will be used there is no
7951 advantage in doing this. */
7953 if (innerprec < TYPE_PRECISION (TREE_TYPE (op))
7954 && ! DECL_BIT_FIELD (TREE_OPERAND (op, 1))
7955 && (first || uns == DECL_UNSIGNED (TREE_OPERAND (op, 1)))
7959 uns = DECL_UNSIGNED (TREE_OPERAND (op, 1));
7960 win = fold_convert (type, op);
7964 *unsignedp_ptr = uns;
7968 /* Returns true if integer constant C has a value that is permissible
7969 for type TYPE (an INTEGER_TYPE). */
7972 int_fits_type_p (const_tree c, const_tree type)
7974 tree type_low_bound, type_high_bound;
7975 bool ok_for_low_bound, ok_for_high_bound, unsc;
7978 dc = tree_to_double_int (c);
7979 unsc = TYPE_UNSIGNED (TREE_TYPE (c));
7981 if (TREE_CODE (TREE_TYPE (c)) == INTEGER_TYPE
7982 && TYPE_IS_SIZETYPE (TREE_TYPE (c))
7984 /* So c is an unsigned integer whose type is sizetype and type is not.
7985 sizetype'd integers are sign extended even though they are
7986 unsigned. If the integer value fits in the lower end word of c,
7987 and if the higher end word has all its bits set to 1, that
7988 means the higher end bits are set to 1 only for sign extension.
7989 So let's convert c into an equivalent zero extended unsigned
7991 dc = double_int_zext (dc, TYPE_PRECISION (TREE_TYPE (c)));
7994 type_low_bound = TYPE_MIN_VALUE (type);
7995 type_high_bound = TYPE_MAX_VALUE (type);
7997 /* If at least one bound of the type is a constant integer, we can check
7998 ourselves and maybe make a decision. If no such decision is possible, but
7999 this type is a subtype, try checking against that. Otherwise, use
8000 double_int_fits_to_tree_p, which checks against the precision.
8002 Compute the status for each possibly constant bound, and return if we see
8003 one does not match. Use ok_for_xxx_bound for this purpose, assigning -1
8004 for "unknown if constant fits", 0 for "constant known *not* to fit" and 1
8005 for "constant known to fit". */
8007 /* Check if c >= type_low_bound. */
8008 if (type_low_bound && TREE_CODE (type_low_bound) == INTEGER_CST)
8010 dd = tree_to_double_int (type_low_bound);
8011 if (TREE_CODE (type) == INTEGER_TYPE
8012 && TYPE_IS_SIZETYPE (type)
8013 && TYPE_UNSIGNED (type))
8014 dd = double_int_zext (dd, TYPE_PRECISION (type));
8015 if (unsc != TYPE_UNSIGNED (TREE_TYPE (type_low_bound)))
8017 int c_neg = (!unsc && double_int_negative_p (dc));
8018 int t_neg = (unsc && double_int_negative_p (dd));
8020 if (c_neg && !t_neg)
8022 if ((c_neg || !t_neg) && double_int_ucmp (dc, dd) < 0)
8025 else if (double_int_cmp (dc, dd, unsc) < 0)
8027 ok_for_low_bound = true;
8030 ok_for_low_bound = false;
8032 /* Check if c <= type_high_bound. */
8033 if (type_high_bound && TREE_CODE (type_high_bound) == INTEGER_CST)
8035 dd = tree_to_double_int (type_high_bound);
8036 if (TREE_CODE (type) == INTEGER_TYPE
8037 && TYPE_IS_SIZETYPE (type)
8038 && TYPE_UNSIGNED (type))
8039 dd = double_int_zext (dd, TYPE_PRECISION (type));
8040 if (unsc != TYPE_UNSIGNED (TREE_TYPE (type_high_bound)))
8042 int c_neg = (!unsc && double_int_negative_p (dc));
8043 int t_neg = (unsc && double_int_negative_p (dd));
8045 if (t_neg && !c_neg)
8047 if ((t_neg || !c_neg) && double_int_ucmp (dc, dd) > 0)
8050 else if (double_int_cmp (dc, dd, unsc) > 0)
8052 ok_for_high_bound = true;
8055 ok_for_high_bound = false;
8057 /* If the constant fits both bounds, the result is known. */
8058 if (ok_for_low_bound && ok_for_high_bound)
8061 /* Perform some generic filtering which may allow making a decision
8062 even if the bounds are not constant. First, negative integers
8063 never fit in unsigned types, */
8064 if (TYPE_UNSIGNED (type) && !unsc && double_int_negative_p (dc))
8067 /* Second, narrower types always fit in wider ones. */
8068 if (TYPE_PRECISION (type) > TYPE_PRECISION (TREE_TYPE (c)))
8071 /* Third, unsigned integers with top bit set never fit signed types. */
8072 if (! TYPE_UNSIGNED (type) && unsc)
8074 int prec = GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (c))) - 1;
8075 if (prec < HOST_BITS_PER_WIDE_INT)
8077 if (((((unsigned HOST_WIDE_INT) 1) << prec) & dc.low) != 0)
8080 else if (((((unsigned HOST_WIDE_INT) 1)
8081 << (prec - HOST_BITS_PER_WIDE_INT)) & dc.high) != 0)
8085 /* If we haven't been able to decide at this point, there nothing more we
8086 can check ourselves here. Look at the base type if we have one and it
8087 has the same precision. */
8088 if (TREE_CODE (type) == INTEGER_TYPE
8089 && TREE_TYPE (type) != 0
8090 && TYPE_PRECISION (type) == TYPE_PRECISION (TREE_TYPE (type)))
8092 type = TREE_TYPE (type);
8096 /* Or to double_int_fits_to_tree_p, if nothing else. */
8097 return double_int_fits_to_tree_p (type, dc);
8100 /* Stores bounds of an integer TYPE in MIN and MAX. If TYPE has non-constant
8101 bounds or is a POINTER_TYPE, the maximum and/or minimum values that can be
8102 represented (assuming two's-complement arithmetic) within the bit
8103 precision of the type are returned instead. */
8106 get_type_static_bounds (const_tree type, mpz_t min, mpz_t max)
8108 if (!POINTER_TYPE_P (type) && TYPE_MIN_VALUE (type)
8109 && TREE_CODE (TYPE_MIN_VALUE (type)) == INTEGER_CST)
8110 mpz_set_double_int (min, tree_to_double_int (TYPE_MIN_VALUE (type)),
8111 TYPE_UNSIGNED (type));
8114 if (TYPE_UNSIGNED (type))
8115 mpz_set_ui (min, 0);
8119 mn = double_int_mask (TYPE_PRECISION (type) - 1);
8120 mn = double_int_sext (double_int_add (mn, double_int_one),
8121 TYPE_PRECISION (type));
8122 mpz_set_double_int (min, mn, false);
8126 if (!POINTER_TYPE_P (type) && TYPE_MAX_VALUE (type)
8127 && TREE_CODE (TYPE_MAX_VALUE (type)) == INTEGER_CST)
8128 mpz_set_double_int (max, tree_to_double_int (TYPE_MAX_VALUE (type)),
8129 TYPE_UNSIGNED (type));
8132 if (TYPE_UNSIGNED (type))
8133 mpz_set_double_int (max, double_int_mask (TYPE_PRECISION (type)),
8136 mpz_set_double_int (max, double_int_mask (TYPE_PRECISION (type) - 1),
8141 /* Return true if VAR is an automatic variable defined in function FN. */
8144 auto_var_in_fn_p (const_tree var, const_tree fn)
8146 return (DECL_P (var) && DECL_CONTEXT (var) == fn
8147 && ((((TREE_CODE (var) == VAR_DECL && ! DECL_EXTERNAL (var))
8148 || TREE_CODE (var) == PARM_DECL)
8149 && ! TREE_STATIC (var))
8150 || TREE_CODE (var) == LABEL_DECL
8151 || TREE_CODE (var) == RESULT_DECL));
8154 /* Subprogram of following function. Called by walk_tree.
8156 Return *TP if it is an automatic variable or parameter of the
8157 function passed in as DATA. */
8160 find_var_from_fn (tree *tp, int *walk_subtrees, void *data)
8162 tree fn = (tree) data;
8167 else if (DECL_P (*tp)
8168 && auto_var_in_fn_p (*tp, fn))
8174 /* Returns true if T is, contains, or refers to a type with variable
8175 size. For METHOD_TYPEs and FUNCTION_TYPEs we exclude the
8176 arguments, but not the return type. If FN is nonzero, only return
8177 true if a modifier of the type or position of FN is a variable or
8178 parameter inside FN.
8180 This concept is more general than that of C99 'variably modified types':
8181 in C99, a struct type is never variably modified because a VLA may not
8182 appear as a structure member. However, in GNU C code like:
8184 struct S { int i[f()]; };
8186 is valid, and other languages may define similar constructs. */
8189 variably_modified_type_p (tree type, tree fn)
8193 /* Test if T is either variable (if FN is zero) or an expression containing
8194 a variable in FN. */
8195 #define RETURN_TRUE_IF_VAR(T) \
8196 do { tree _t = (T); \
8197 if (_t && _t != error_mark_node && TREE_CODE (_t) != INTEGER_CST \
8198 && (!fn || walk_tree (&_t, find_var_from_fn, fn, NULL))) \
8199 return true; } while (0)
8201 if (type == error_mark_node)
8204 /* If TYPE itself has variable size, it is variably modified. */
8205 RETURN_TRUE_IF_VAR (TYPE_SIZE (type));
8206 RETURN_TRUE_IF_VAR (TYPE_SIZE_UNIT (type));
8208 switch (TREE_CODE (type))
8211 case REFERENCE_TYPE:
8213 if (variably_modified_type_p (TREE_TYPE (type), fn))
8219 /* If TYPE is a function type, it is variably modified if the
8220 return type is variably modified. */
8221 if (variably_modified_type_p (TREE_TYPE (type), fn))
8227 case FIXED_POINT_TYPE:
8230 /* Scalar types are variably modified if their end points
8232 RETURN_TRUE_IF_VAR (TYPE_MIN_VALUE (type));
8233 RETURN_TRUE_IF_VAR (TYPE_MAX_VALUE (type));
8238 case QUAL_UNION_TYPE:
8239 /* We can't see if any of the fields are variably-modified by the
8240 definition we normally use, since that would produce infinite
8241 recursion via pointers. */
8242 /* This is variably modified if some field's type is. */
8243 for (t = TYPE_FIELDS (type); t; t = DECL_CHAIN (t))
8244 if (TREE_CODE (t) == FIELD_DECL)
8246 RETURN_TRUE_IF_VAR (DECL_FIELD_OFFSET (t));
8247 RETURN_TRUE_IF_VAR (DECL_SIZE (t));
8248 RETURN_TRUE_IF_VAR (DECL_SIZE_UNIT (t));
8250 if (TREE_CODE (type) == QUAL_UNION_TYPE)
8251 RETURN_TRUE_IF_VAR (DECL_QUALIFIER (t));
8256 /* Do not call ourselves to avoid infinite recursion. This is
8257 variably modified if the element type is. */
8258 RETURN_TRUE_IF_VAR (TYPE_SIZE (TREE_TYPE (type)));
8259 RETURN_TRUE_IF_VAR (TYPE_SIZE_UNIT (TREE_TYPE (type)));
8266 /* The current language may have other cases to check, but in general,
8267 all other types are not variably modified. */
8268 return lang_hooks.tree_inlining.var_mod_type_p (type, fn);
8270 #undef RETURN_TRUE_IF_VAR
8273 /* Given a DECL or TYPE, return the scope in which it was declared, or
8274 NULL_TREE if there is no containing scope. */
8277 get_containing_scope (const_tree t)
8279 return (TYPE_P (t) ? TYPE_CONTEXT (t) : DECL_CONTEXT (t));
8282 /* Return the innermost context enclosing DECL that is
8283 a FUNCTION_DECL, or zero if none. */
8286 decl_function_context (const_tree decl)
8290 if (TREE_CODE (decl) == ERROR_MARK)
8293 /* C++ virtual functions use DECL_CONTEXT for the class of the vtable
8294 where we look up the function at runtime. Such functions always take
8295 a first argument of type 'pointer to real context'.
8297 C++ should really be fixed to use DECL_CONTEXT for the real context,
8298 and use something else for the "virtual context". */
8299 else if (TREE_CODE (decl) == FUNCTION_DECL && DECL_VINDEX (decl))
8302 (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl)))));
8304 context = DECL_CONTEXT (decl);
8306 while (context && TREE_CODE (context) != FUNCTION_DECL)
8308 if (TREE_CODE (context) == BLOCK)
8309 context = BLOCK_SUPERCONTEXT (context);
8311 context = get_containing_scope (context);
8317 /* Return the innermost context enclosing DECL that is
8318 a RECORD_TYPE, UNION_TYPE or QUAL_UNION_TYPE, or zero if none.
8319 TYPE_DECLs and FUNCTION_DECLs are transparent to this function. */
8322 decl_type_context (const_tree decl)
8324 tree context = DECL_CONTEXT (decl);
8327 switch (TREE_CODE (context))
8329 case NAMESPACE_DECL:
8330 case TRANSLATION_UNIT_DECL:
8335 case QUAL_UNION_TYPE:
8340 context = DECL_CONTEXT (context);
8344 context = BLOCK_SUPERCONTEXT (context);
8354 /* CALL is a CALL_EXPR. Return the declaration for the function
8355 called, or NULL_TREE if the called function cannot be
8359 get_callee_fndecl (const_tree call)
8363 if (call == error_mark_node)
8364 return error_mark_node;
8366 /* It's invalid to call this function with anything but a
8368 gcc_assert (TREE_CODE (call) == CALL_EXPR);
8370 /* The first operand to the CALL is the address of the function
8372 addr = CALL_EXPR_FN (call);
8376 /* If this is a readonly function pointer, extract its initial value. */
8377 if (DECL_P (addr) && TREE_CODE (addr) != FUNCTION_DECL
8378 && TREE_READONLY (addr) && ! TREE_THIS_VOLATILE (addr)
8379 && DECL_INITIAL (addr))
8380 addr = DECL_INITIAL (addr);
8382 /* If the address is just `&f' for some function `f', then we know
8383 that `f' is being called. */
8384 if (TREE_CODE (addr) == ADDR_EXPR
8385 && TREE_CODE (TREE_OPERAND (addr, 0)) == FUNCTION_DECL)
8386 return TREE_OPERAND (addr, 0);
8388 /* We couldn't figure out what was being called. */
8392 /* Print debugging information about tree nodes generated during the compile,
8393 and any language-specific information. */
8396 dump_tree_statistics (void)
8398 #ifdef GATHER_STATISTICS
8400 int total_nodes, total_bytes;
8403 fprintf (stderr, "\n??? tree nodes created\n\n");
8404 #ifdef GATHER_STATISTICS
8405 fprintf (stderr, "Kind Nodes Bytes\n");
8406 fprintf (stderr, "---------------------------------------\n");
8407 total_nodes = total_bytes = 0;
8408 for (i = 0; i < (int) all_kinds; i++)
8410 fprintf (stderr, "%-20s %7d %10d\n", tree_node_kind_names[i],
8411 tree_node_counts[i], tree_node_sizes[i]);
8412 total_nodes += tree_node_counts[i];
8413 total_bytes += tree_node_sizes[i];
8415 fprintf (stderr, "---------------------------------------\n");
8416 fprintf (stderr, "%-20s %7d %10d\n", "Total", total_nodes, total_bytes);
8417 fprintf (stderr, "---------------------------------------\n");
8418 ssanames_print_statistics ();
8419 phinodes_print_statistics ();
8421 fprintf (stderr, "(No per-node statistics)\n");
8423 print_type_hash_statistics ();
8424 print_debug_expr_statistics ();
8425 print_value_expr_statistics ();
8426 lang_hooks.print_statistics ();
8429 #define FILE_FUNCTION_FORMAT "_GLOBAL__%s_%s"
8431 /* Generate a crc32 of a string. */
8434 crc32_string (unsigned chksum, const char *string)
8438 unsigned value = *string << 24;
8441 for (ix = 8; ix--; value <<= 1)
8445 feedback = (value ^ chksum) & 0x80000000 ? 0x04c11db7 : 0;
8454 /* P is a string that will be used in a symbol. Mask out any characters
8455 that are not valid in that context. */
8458 clean_symbol_name (char *p)
8462 #ifndef NO_DOLLAR_IN_LABEL /* this for `$'; unlikely, but... -- kr */
8465 #ifndef NO_DOT_IN_LABEL /* this for `.'; unlikely, but... */
8472 /* Generate a name for a special-purpose function function.
8473 The generated name may need to be unique across the whole link.
8474 TYPE is some string to identify the purpose of this function to the
8475 linker or collect2; it must start with an uppercase letter,
8477 I - for constructors
8479 N - for C++ anonymous namespaces
8480 F - for DWARF unwind frame information. */
8483 get_file_function_name (const char *type)
8489 /* If we already have a name we know to be unique, just use that. */
8490 if (first_global_object_name)
8491 p = q = ASTRDUP (first_global_object_name);
8492 /* If the target is handling the constructors/destructors, they
8493 will be local to this file and the name is only necessary for
8494 debugging purposes. */
8495 else if ((type[0] == 'I' || type[0] == 'D') && targetm.have_ctors_dtors)
8497 const char *file = main_input_filename;
8499 file = input_filename;
8500 /* Just use the file's basename, because the full pathname
8501 might be quite long. */
8502 p = strrchr (file, '/');
8507 p = q = ASTRDUP (p);
8511 /* Otherwise, the name must be unique across the entire link.
8512 We don't have anything that we know to be unique to this translation
8513 unit, so use what we do have and throw in some randomness. */
8515 const char *name = weak_global_object_name;
8516 const char *file = main_input_filename;
8521 file = input_filename;
8523 len = strlen (file);
8524 q = (char *) alloca (9 * 2 + len + 1);
8525 memcpy (q, file, len + 1);
8527 sprintf (q + len, "_%08X_%08X", crc32_string (0, name),
8528 crc32_string (0, get_random_seed (false)));
8533 clean_symbol_name (q);
8534 buf = (char *) alloca (sizeof (FILE_FUNCTION_FORMAT) + strlen (p)
8537 /* Set up the name of the file-level functions we may need.
8538 Use a global object (which is already required to be unique over
8539 the program) rather than the file name (which imposes extra
8541 sprintf (buf, FILE_FUNCTION_FORMAT, type, p);
8543 return get_identifier (buf);
8546 #if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
8548 /* Complain that the tree code of NODE does not match the expected 0
8549 terminated list of trailing codes. The trailing code list can be
8550 empty, for a more vague error message. FILE, LINE, and FUNCTION
8551 are of the caller. */
8554 tree_check_failed (const_tree node, const char *file,
8555 int line, const char *function, ...)
8559 unsigned length = 0;
8562 va_start (args, function);
8563 while ((code = va_arg (args, int)))
8564 length += 4 + strlen (tree_code_name[code]);
8569 va_start (args, function);
8570 length += strlen ("expected ");
8571 buffer = tmp = (char *) alloca (length);
8573 while ((code = va_arg (args, int)))
8575 const char *prefix = length ? " or " : "expected ";
8577 strcpy (tmp + length, prefix);
8578 length += strlen (prefix);
8579 strcpy (tmp + length, tree_code_name[code]);
8580 length += strlen (tree_code_name[code]);
8585 buffer = "unexpected node";
8587 internal_error ("tree check: %s, have %s in %s, at %s:%d",
8588 buffer, tree_code_name[TREE_CODE (node)],
8589 function, trim_filename (file), line);
8592 /* Complain that the tree code of NODE does match the expected 0
8593 terminated list of trailing codes. FILE, LINE, and FUNCTION are of
8597 tree_not_check_failed (const_tree node, const char *file,
8598 int line, const char *function, ...)
8602 unsigned length = 0;
8605 va_start (args, function);
8606 while ((code = va_arg (args, int)))
8607 length += 4 + strlen (tree_code_name[code]);
8609 va_start (args, function);
8610 buffer = (char *) alloca (length);
8612 while ((code = va_arg (args, int)))
8616 strcpy (buffer + length, " or ");
8619 strcpy (buffer + length, tree_code_name[code]);
8620 length += strlen (tree_code_name[code]);
8624 internal_error ("tree check: expected none of %s, have %s in %s, at %s:%d",
8625 buffer, tree_code_name[TREE_CODE (node)],
8626 function, trim_filename (file), line);
8629 /* Similar to tree_check_failed, except that we check for a class of tree
8630 code, given in CL. */
8633 tree_class_check_failed (const_tree node, const enum tree_code_class cl,
8634 const char *file, int line, const char *function)
8637 ("tree check: expected class %qs, have %qs (%s) in %s, at %s:%d",
8638 TREE_CODE_CLASS_STRING (cl),
8639 TREE_CODE_CLASS_STRING (TREE_CODE_CLASS (TREE_CODE (node))),
8640 tree_code_name[TREE_CODE (node)], function, trim_filename (file), line);
8643 /* Similar to tree_check_failed, except that instead of specifying a
8644 dozen codes, use the knowledge that they're all sequential. */
8647 tree_range_check_failed (const_tree node, const char *file, int line,
8648 const char *function, enum tree_code c1,
8652 unsigned length = 0;
8655 for (c = c1; c <= c2; ++c)
8656 length += 4 + strlen (tree_code_name[c]);
8658 length += strlen ("expected ");
8659 buffer = (char *) alloca (length);
8662 for (c = c1; c <= c2; ++c)
8664 const char *prefix = length ? " or " : "expected ";
8666 strcpy (buffer + length, prefix);
8667 length += strlen (prefix);
8668 strcpy (buffer + length, tree_code_name[c]);
8669 length += strlen (tree_code_name[c]);
8672 internal_error ("tree check: %s, have %s in %s, at %s:%d",
8673 buffer, tree_code_name[TREE_CODE (node)],
8674 function, trim_filename (file), line);
8678 /* Similar to tree_check_failed, except that we check that a tree does
8679 not have the specified code, given in CL. */
8682 tree_not_class_check_failed (const_tree node, const enum tree_code_class cl,
8683 const char *file, int line, const char *function)
8686 ("tree check: did not expect class %qs, have %qs (%s) in %s, at %s:%d",
8687 TREE_CODE_CLASS_STRING (cl),
8688 TREE_CODE_CLASS_STRING (TREE_CODE_CLASS (TREE_CODE (node))),
8689 tree_code_name[TREE_CODE (node)], function, trim_filename (file), line);
8693 /* Similar to tree_check_failed but applied to OMP_CLAUSE codes. */
8696 omp_clause_check_failed (const_tree node, const char *file, int line,
8697 const char *function, enum omp_clause_code code)
8699 internal_error ("tree check: expected omp_clause %s, have %s in %s, at %s:%d",
8700 omp_clause_code_name[code], tree_code_name[TREE_CODE (node)],
8701 function, trim_filename (file), line);
8705 /* Similar to tree_range_check_failed but applied to OMP_CLAUSE codes. */
8708 omp_clause_range_check_failed (const_tree node, const char *file, int line,
8709 const char *function, enum omp_clause_code c1,
8710 enum omp_clause_code c2)
8713 unsigned length = 0;
8716 for (c = c1; c <= c2; ++c)
8717 length += 4 + strlen (omp_clause_code_name[c]);
8719 length += strlen ("expected ");
8720 buffer = (char *) alloca (length);
8723 for (c = c1; c <= c2; ++c)
8725 const char *prefix = length ? " or " : "expected ";
8727 strcpy (buffer + length, prefix);
8728 length += strlen (prefix);
8729 strcpy (buffer + length, omp_clause_code_name[c]);
8730 length += strlen (omp_clause_code_name[c]);
8733 internal_error ("tree check: %s, have %s in %s, at %s:%d",
8734 buffer, omp_clause_code_name[TREE_CODE (node)],
8735 function, trim_filename (file), line);
8739 #undef DEFTREESTRUCT
8740 #define DEFTREESTRUCT(VAL, NAME) NAME,
8742 static const char *ts_enum_names[] = {
8743 #include "treestruct.def"
8745 #undef DEFTREESTRUCT
8747 #define TS_ENUM_NAME(EN) (ts_enum_names[(EN)])
8749 /* Similar to tree_class_check_failed, except that we check for
8750 whether CODE contains the tree structure identified by EN. */
8753 tree_contains_struct_check_failed (const_tree node,
8754 const enum tree_node_structure_enum en,
8755 const char *file, int line,
8756 const char *function)
8759 ("tree check: expected tree that contains %qs structure, have %qs in %s, at %s:%d",
8761 tree_code_name[TREE_CODE (node)], function, trim_filename (file), line);
8765 /* Similar to above, except that the check is for the bounds of a TREE_VEC's
8766 (dynamically sized) vector. */
8769 tree_vec_elt_check_failed (int idx, int len, const char *file, int line,
8770 const char *function)
8773 ("tree check: accessed elt %d of tree_vec with %d elts in %s, at %s:%d",
8774 idx + 1, len, function, trim_filename (file), line);
8777 /* Similar to above, except that the check is for the bounds of the operand
8778 vector of an expression node EXP. */
8781 tree_operand_check_failed (int idx, const_tree exp, const char *file,
8782 int line, const char *function)
8784 int code = TREE_CODE (exp);
8786 ("tree check: accessed operand %d of %s with %d operands in %s, at %s:%d",
8787 idx + 1, tree_code_name[code], TREE_OPERAND_LENGTH (exp),
8788 function, trim_filename (file), line);
8791 /* Similar to above, except that the check is for the number of
8792 operands of an OMP_CLAUSE node. */
8795 omp_clause_operand_check_failed (int idx, const_tree t, const char *file,
8796 int line, const char *function)
8799 ("tree check: accessed operand %d of omp_clause %s with %d operands "
8800 "in %s, at %s:%d", idx + 1, omp_clause_code_name[OMP_CLAUSE_CODE (t)],
8801 omp_clause_num_ops [OMP_CLAUSE_CODE (t)], function,
8802 trim_filename (file), line);
8804 #endif /* ENABLE_TREE_CHECKING */
8806 /* Create a new vector type node holding SUBPARTS units of type INNERTYPE,
8807 and mapped to the machine mode MODE. Initialize its fields and build
8808 the information necessary for debugging output. */
8811 make_vector_type (tree innertype, int nunits, enum machine_mode mode)
8814 hashval_t hashcode = 0;
8816 t = make_node (VECTOR_TYPE);
8817 TREE_TYPE (t) = TYPE_MAIN_VARIANT (innertype);
8818 SET_TYPE_VECTOR_SUBPARTS (t, nunits);
8819 SET_TYPE_MODE (t, mode);
8821 if (TYPE_STRUCTURAL_EQUALITY_P (innertype))
8822 SET_TYPE_STRUCTURAL_EQUALITY (t);
8823 else if (TYPE_CANONICAL (innertype) != innertype
8824 || mode != VOIDmode)
8826 = make_vector_type (TYPE_CANONICAL (innertype), nunits, VOIDmode);
8830 hashcode = iterative_hash_host_wide_int (VECTOR_TYPE, hashcode);
8831 hashcode = iterative_hash_host_wide_int (nunits, hashcode);
8832 hashcode = iterative_hash_host_wide_int (mode, hashcode);
8833 hashcode = iterative_hash_object (TYPE_HASH (TREE_TYPE (t)), hashcode);
8834 t = type_hash_canon (hashcode, t);
8836 /* We have built a main variant, based on the main variant of the
8837 inner type. Use it to build the variant we return. */
8838 if ((TYPE_ATTRIBUTES (innertype) || TYPE_QUALS (innertype))
8839 && TREE_TYPE (t) != innertype)
8840 return build_type_attribute_qual_variant (t,
8841 TYPE_ATTRIBUTES (innertype),
8842 TYPE_QUALS (innertype));
8848 make_or_reuse_type (unsigned size, int unsignedp)
8850 if (size == INT_TYPE_SIZE)
8851 return unsignedp ? unsigned_type_node : integer_type_node;
8852 if (size == CHAR_TYPE_SIZE)
8853 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
8854 if (size == SHORT_TYPE_SIZE)
8855 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
8856 if (size == LONG_TYPE_SIZE)
8857 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
8858 if (size == LONG_LONG_TYPE_SIZE)
8859 return (unsignedp ? long_long_unsigned_type_node
8860 : long_long_integer_type_node);
8861 if (size == 128 && int128_integer_type_node)
8862 return (unsignedp ? int128_unsigned_type_node
8863 : int128_integer_type_node);
8866 return make_unsigned_type (size);
8868 return make_signed_type (size);
8871 /* Create or reuse a fract type by SIZE, UNSIGNEDP, and SATP. */
8874 make_or_reuse_fract_type (unsigned size, int unsignedp, int satp)
8878 if (size == SHORT_FRACT_TYPE_SIZE)
8879 return unsignedp ? sat_unsigned_short_fract_type_node
8880 : sat_short_fract_type_node;
8881 if (size == FRACT_TYPE_SIZE)
8882 return unsignedp ? sat_unsigned_fract_type_node : sat_fract_type_node;
8883 if (size == LONG_FRACT_TYPE_SIZE)
8884 return unsignedp ? sat_unsigned_long_fract_type_node
8885 : sat_long_fract_type_node;
8886 if (size == LONG_LONG_FRACT_TYPE_SIZE)
8887 return unsignedp ? sat_unsigned_long_long_fract_type_node
8888 : sat_long_long_fract_type_node;
8892 if (size == SHORT_FRACT_TYPE_SIZE)
8893 return unsignedp ? unsigned_short_fract_type_node
8894 : short_fract_type_node;
8895 if (size == FRACT_TYPE_SIZE)
8896 return unsignedp ? unsigned_fract_type_node : fract_type_node;
8897 if (size == LONG_FRACT_TYPE_SIZE)
8898 return unsignedp ? unsigned_long_fract_type_node
8899 : long_fract_type_node;
8900 if (size == LONG_LONG_FRACT_TYPE_SIZE)
8901 return unsignedp ? unsigned_long_long_fract_type_node
8902 : long_long_fract_type_node;
8905 return make_fract_type (size, unsignedp, satp);
8908 /* Create or reuse an accum type by SIZE, UNSIGNEDP, and SATP. */
8911 make_or_reuse_accum_type (unsigned size, int unsignedp, int satp)
8915 if (size == SHORT_ACCUM_TYPE_SIZE)
8916 return unsignedp ? sat_unsigned_short_accum_type_node
8917 : sat_short_accum_type_node;
8918 if (size == ACCUM_TYPE_SIZE)
8919 return unsignedp ? sat_unsigned_accum_type_node : sat_accum_type_node;
8920 if (size == LONG_ACCUM_TYPE_SIZE)
8921 return unsignedp ? sat_unsigned_long_accum_type_node
8922 : sat_long_accum_type_node;
8923 if (size == LONG_LONG_ACCUM_TYPE_SIZE)
8924 return unsignedp ? sat_unsigned_long_long_accum_type_node
8925 : sat_long_long_accum_type_node;
8929 if (size == SHORT_ACCUM_TYPE_SIZE)
8930 return unsignedp ? unsigned_short_accum_type_node
8931 : short_accum_type_node;
8932 if (size == ACCUM_TYPE_SIZE)
8933 return unsignedp ? unsigned_accum_type_node : accum_type_node;
8934 if (size == LONG_ACCUM_TYPE_SIZE)
8935 return unsignedp ? unsigned_long_accum_type_node
8936 : long_accum_type_node;
8937 if (size == LONG_LONG_ACCUM_TYPE_SIZE)
8938 return unsignedp ? unsigned_long_long_accum_type_node
8939 : long_long_accum_type_node;
8942 return make_accum_type (size, unsignedp, satp);
8945 /* Create nodes for all integer types (and error_mark_node) using the sizes
8946 of C datatypes. The caller should call set_sizetype soon after calling
8947 this function to select one of the types as sizetype. */
8950 build_common_tree_nodes (bool signed_char)
8952 error_mark_node = make_node (ERROR_MARK);
8953 TREE_TYPE (error_mark_node) = error_mark_node;
8955 initialize_sizetypes ();
8957 /* Define both `signed char' and `unsigned char'. */
8958 signed_char_type_node = make_signed_type (CHAR_TYPE_SIZE);
8959 TYPE_STRING_FLAG (signed_char_type_node) = 1;
8960 unsigned_char_type_node = make_unsigned_type (CHAR_TYPE_SIZE);
8961 TYPE_STRING_FLAG (unsigned_char_type_node) = 1;
8963 /* Define `char', which is like either `signed char' or `unsigned char'
8964 but not the same as either. */
8967 ? make_signed_type (CHAR_TYPE_SIZE)
8968 : make_unsigned_type (CHAR_TYPE_SIZE));
8969 TYPE_STRING_FLAG (char_type_node) = 1;
8971 short_integer_type_node = make_signed_type (SHORT_TYPE_SIZE);
8972 short_unsigned_type_node = make_unsigned_type (SHORT_TYPE_SIZE);
8973 integer_type_node = make_signed_type (INT_TYPE_SIZE);
8974 unsigned_type_node = make_unsigned_type (INT_TYPE_SIZE);
8975 long_integer_type_node = make_signed_type (LONG_TYPE_SIZE);
8976 long_unsigned_type_node = make_unsigned_type (LONG_TYPE_SIZE);
8977 long_long_integer_type_node = make_signed_type (LONG_LONG_TYPE_SIZE);
8978 long_long_unsigned_type_node = make_unsigned_type (LONG_LONG_TYPE_SIZE);
8979 #if HOST_BITS_PER_WIDE_INT >= 64
8980 /* TODO: This isn't correct, but as logic depends at the moment on
8981 host's instead of target's wide-integer.
8982 If there is a target not supporting TImode, but has an 128-bit
8983 integer-scalar register, this target check needs to be adjusted. */
8984 if (targetm.scalar_mode_supported_p (TImode))
8986 int128_integer_type_node = make_signed_type (128);
8987 int128_unsigned_type_node = make_unsigned_type (128);
8990 /* Define a boolean type. This type only represents boolean values but
8991 may be larger than char depending on the value of BOOL_TYPE_SIZE.
8992 Front ends which want to override this size (i.e. Java) can redefine
8993 boolean_type_node before calling build_common_tree_nodes_2. */
8994 boolean_type_node = make_unsigned_type (BOOL_TYPE_SIZE);
8995 TREE_SET_CODE (boolean_type_node, BOOLEAN_TYPE);
8996 TYPE_MAX_VALUE (boolean_type_node) = build_int_cst (boolean_type_node, 1);
8997 TYPE_PRECISION (boolean_type_node) = 1;
8999 /* Fill in the rest of the sized types. Reuse existing type nodes
9001 intQI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (QImode), 0);
9002 intHI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (HImode), 0);
9003 intSI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (SImode), 0);
9004 intDI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (DImode), 0);
9005 intTI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (TImode), 0);
9007 unsigned_intQI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (QImode), 1);
9008 unsigned_intHI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (HImode), 1);
9009 unsigned_intSI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (SImode), 1);
9010 unsigned_intDI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (DImode), 1);
9011 unsigned_intTI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (TImode), 1);
9013 access_public_node = get_identifier ("public");
9014 access_protected_node = get_identifier ("protected");
9015 access_private_node = get_identifier ("private");
9018 /* Call this function after calling build_common_tree_nodes and set_sizetype.
9019 It will create several other common tree nodes. */
9022 build_common_tree_nodes_2 (int short_double)
9024 /* Define these next since types below may used them. */
9025 integer_zero_node = build_int_cst (integer_type_node, 0);
9026 integer_one_node = build_int_cst (integer_type_node, 1);
9027 integer_three_node = build_int_cst (integer_type_node, 3);
9028 integer_minus_one_node = build_int_cst (integer_type_node, -1);
9030 size_zero_node = size_int (0);
9031 size_one_node = size_int (1);
9032 bitsize_zero_node = bitsize_int (0);
9033 bitsize_one_node = bitsize_int (1);
9034 bitsize_unit_node = bitsize_int (BITS_PER_UNIT);
9036 boolean_false_node = TYPE_MIN_VALUE (boolean_type_node);
9037 boolean_true_node = TYPE_MAX_VALUE (boolean_type_node);
9039 void_type_node = make_node (VOID_TYPE);
9040 layout_type (void_type_node);
9042 /* We are not going to have real types in C with less than byte alignment,
9043 so we might as well not have any types that claim to have it. */
9044 TYPE_ALIGN (void_type_node) = BITS_PER_UNIT;
9045 TYPE_USER_ALIGN (void_type_node) = 0;
9047 null_pointer_node = build_int_cst (build_pointer_type (void_type_node), 0);
9048 layout_type (TREE_TYPE (null_pointer_node));
9050 ptr_type_node = build_pointer_type (void_type_node);
9052 = build_pointer_type (build_type_variant (void_type_node, 1, 0));
9053 fileptr_type_node = ptr_type_node;
9055 float_type_node = make_node (REAL_TYPE);
9056 TYPE_PRECISION (float_type_node) = FLOAT_TYPE_SIZE;
9057 layout_type (float_type_node);
9059 double_type_node = make_node (REAL_TYPE);
9061 TYPE_PRECISION (double_type_node) = FLOAT_TYPE_SIZE;
9063 TYPE_PRECISION (double_type_node) = DOUBLE_TYPE_SIZE;
9064 layout_type (double_type_node);
9066 long_double_type_node = make_node (REAL_TYPE);
9067 TYPE_PRECISION (long_double_type_node) = LONG_DOUBLE_TYPE_SIZE;
9068 layout_type (long_double_type_node);
9070 float_ptr_type_node = build_pointer_type (float_type_node);
9071 double_ptr_type_node = build_pointer_type (double_type_node);
9072 long_double_ptr_type_node = build_pointer_type (long_double_type_node);
9073 integer_ptr_type_node = build_pointer_type (integer_type_node);
9075 /* Fixed size integer types. */
9076 uint32_type_node = build_nonstandard_integer_type (32, true);
9077 uint64_type_node = build_nonstandard_integer_type (64, true);
9079 /* Decimal float types. */
9080 dfloat32_type_node = make_node (REAL_TYPE);
9081 TYPE_PRECISION (dfloat32_type_node) = DECIMAL32_TYPE_SIZE;
9082 layout_type (dfloat32_type_node);
9083 SET_TYPE_MODE (dfloat32_type_node, SDmode);
9084 dfloat32_ptr_type_node = build_pointer_type (dfloat32_type_node);
9086 dfloat64_type_node = make_node (REAL_TYPE);
9087 TYPE_PRECISION (dfloat64_type_node) = DECIMAL64_TYPE_SIZE;
9088 layout_type (dfloat64_type_node);
9089 SET_TYPE_MODE (dfloat64_type_node, DDmode);
9090 dfloat64_ptr_type_node = build_pointer_type (dfloat64_type_node);
9092 dfloat128_type_node = make_node (REAL_TYPE);
9093 TYPE_PRECISION (dfloat128_type_node) = DECIMAL128_TYPE_SIZE;
9094 layout_type (dfloat128_type_node);
9095 SET_TYPE_MODE (dfloat128_type_node, TDmode);
9096 dfloat128_ptr_type_node = build_pointer_type (dfloat128_type_node);
9098 complex_integer_type_node = build_complex_type (integer_type_node);
9099 complex_float_type_node = build_complex_type (float_type_node);
9100 complex_double_type_node = build_complex_type (double_type_node);
9101 complex_long_double_type_node = build_complex_type (long_double_type_node);
9103 /* Make fixed-point nodes based on sat/non-sat and signed/unsigned. */
9104 #define MAKE_FIXED_TYPE_NODE(KIND,SIZE) \
9105 sat_ ## KIND ## _type_node = \
9106 make_sat_signed_ ## KIND ## _type (SIZE); \
9107 sat_unsigned_ ## KIND ## _type_node = \
9108 make_sat_unsigned_ ## KIND ## _type (SIZE); \
9109 KIND ## _type_node = make_signed_ ## KIND ## _type (SIZE); \
9110 unsigned_ ## KIND ## _type_node = \
9111 make_unsigned_ ## KIND ## _type (SIZE);
9113 #define MAKE_FIXED_TYPE_NODE_WIDTH(KIND,WIDTH,SIZE) \
9114 sat_ ## WIDTH ## KIND ## _type_node = \
9115 make_sat_signed_ ## KIND ## _type (SIZE); \
9116 sat_unsigned_ ## WIDTH ## KIND ## _type_node = \
9117 make_sat_unsigned_ ## KIND ## _type (SIZE); \
9118 WIDTH ## KIND ## _type_node = make_signed_ ## KIND ## _type (SIZE); \
9119 unsigned_ ## WIDTH ## KIND ## _type_node = \
9120 make_unsigned_ ## KIND ## _type (SIZE);
9122 /* Make fixed-point type nodes based on four different widths. */
9123 #define MAKE_FIXED_TYPE_NODE_FAMILY(N1,N2) \
9124 MAKE_FIXED_TYPE_NODE_WIDTH (N1, short_, SHORT_ ## N2 ## _TYPE_SIZE) \
9125 MAKE_FIXED_TYPE_NODE (N1, N2 ## _TYPE_SIZE) \
9126 MAKE_FIXED_TYPE_NODE_WIDTH (N1, long_, LONG_ ## N2 ## _TYPE_SIZE) \
9127 MAKE_FIXED_TYPE_NODE_WIDTH (N1, long_long_, LONG_LONG_ ## N2 ## _TYPE_SIZE)
9129 /* Make fixed-point mode nodes based on sat/non-sat and signed/unsigned. */
9130 #define MAKE_FIXED_MODE_NODE(KIND,NAME,MODE) \
9131 NAME ## _type_node = \
9132 make_or_reuse_signed_ ## KIND ## _type (GET_MODE_BITSIZE (MODE ## mode)); \
9133 u ## NAME ## _type_node = \
9134 make_or_reuse_unsigned_ ## KIND ## _type \
9135 (GET_MODE_BITSIZE (U ## MODE ## mode)); \
9136 sat_ ## NAME ## _type_node = \
9137 make_or_reuse_sat_signed_ ## KIND ## _type \
9138 (GET_MODE_BITSIZE (MODE ## mode)); \
9139 sat_u ## NAME ## _type_node = \
9140 make_or_reuse_sat_unsigned_ ## KIND ## _type \
9141 (GET_MODE_BITSIZE (U ## MODE ## mode));
9143 /* Fixed-point type and mode nodes. */
9144 MAKE_FIXED_TYPE_NODE_FAMILY (fract, FRACT)
9145 MAKE_FIXED_TYPE_NODE_FAMILY (accum, ACCUM)
9146 MAKE_FIXED_MODE_NODE (fract, qq, QQ)
9147 MAKE_FIXED_MODE_NODE (fract, hq, HQ)
9148 MAKE_FIXED_MODE_NODE (fract, sq, SQ)
9149 MAKE_FIXED_MODE_NODE (fract, dq, DQ)
9150 MAKE_FIXED_MODE_NODE (fract, tq, TQ)
9151 MAKE_FIXED_MODE_NODE (accum, ha, HA)
9152 MAKE_FIXED_MODE_NODE (accum, sa, SA)
9153 MAKE_FIXED_MODE_NODE (accum, da, DA)
9154 MAKE_FIXED_MODE_NODE (accum, ta, TA)
9157 tree t = targetm.build_builtin_va_list ();
9159 /* Many back-ends define record types without setting TYPE_NAME.
9160 If we copied the record type here, we'd keep the original
9161 record type without a name. This breaks name mangling. So,
9162 don't copy record types and let c_common_nodes_and_builtins()
9163 declare the type to be __builtin_va_list. */
9164 if (TREE_CODE (t) != RECORD_TYPE)
9165 t = build_variant_type_copy (t);
9167 va_list_type_node = t;
9171 /* A subroutine of build_common_builtin_nodes. Define a builtin function. */
9174 local_define_builtin (const char *name, tree type, enum built_in_function code,
9175 const char *library_name, int ecf_flags)
9179 decl = add_builtin_function (name, type, code, BUILT_IN_NORMAL,
9180 library_name, NULL_TREE);
9181 if (ecf_flags & ECF_CONST)
9182 TREE_READONLY (decl) = 1;
9183 if (ecf_flags & ECF_PURE)
9184 DECL_PURE_P (decl) = 1;
9185 if (ecf_flags & ECF_LOOPING_CONST_OR_PURE)
9186 DECL_LOOPING_CONST_OR_PURE_P (decl) = 1;
9187 if (ecf_flags & ECF_NORETURN)
9188 TREE_THIS_VOLATILE (decl) = 1;
9189 if (ecf_flags & ECF_NOTHROW)
9190 TREE_NOTHROW (decl) = 1;
9191 if (ecf_flags & ECF_MALLOC)
9192 DECL_IS_MALLOC (decl) = 1;
9193 if (ecf_flags & ECF_LEAF)
9194 DECL_ATTRIBUTES (decl) = tree_cons (get_identifier ("leaf"),
9195 NULL, DECL_ATTRIBUTES (decl));
9197 built_in_decls[code] = decl;
9198 implicit_built_in_decls[code] = decl;
9201 /* Call this function after instantiating all builtins that the language
9202 front end cares about. This will build the rest of the builtins that
9203 are relied upon by the tree optimizers and the middle-end. */
9206 build_common_builtin_nodes (void)
9210 if (built_in_decls[BUILT_IN_MEMCPY] == NULL
9211 || built_in_decls[BUILT_IN_MEMMOVE] == NULL)
9213 ftype = build_function_type_list (ptr_type_node,
9214 ptr_type_node, const_ptr_type_node,
9215 size_type_node, NULL_TREE);
9217 if (built_in_decls[BUILT_IN_MEMCPY] == NULL)
9218 local_define_builtin ("__builtin_memcpy", ftype, BUILT_IN_MEMCPY,
9219 "memcpy", ECF_NOTHROW | ECF_LEAF);
9220 if (built_in_decls[BUILT_IN_MEMMOVE] == NULL)
9221 local_define_builtin ("__builtin_memmove", ftype, BUILT_IN_MEMMOVE,
9222 "memmove", ECF_NOTHROW | ECF_LEAF);
9225 if (built_in_decls[BUILT_IN_MEMCMP] == NULL)
9227 ftype = build_function_type_list (integer_type_node, const_ptr_type_node,
9228 const_ptr_type_node, size_type_node,
9230 local_define_builtin ("__builtin_memcmp", ftype, BUILT_IN_MEMCMP,
9231 "memcmp", ECF_PURE | ECF_NOTHROW | ECF_LEAF);
9234 if (built_in_decls[BUILT_IN_MEMSET] == NULL)
9236 ftype = build_function_type_list (ptr_type_node,
9237 ptr_type_node, integer_type_node,
9238 size_type_node, NULL_TREE);
9239 local_define_builtin ("__builtin_memset", ftype, BUILT_IN_MEMSET,
9240 "memset", ECF_NOTHROW | ECF_LEAF);
9243 if (built_in_decls[BUILT_IN_ALLOCA] == NULL)
9245 ftype = build_function_type_list (ptr_type_node,
9246 size_type_node, NULL_TREE);
9247 local_define_builtin ("__builtin_alloca", ftype, BUILT_IN_ALLOCA,
9248 "alloca", ECF_MALLOC | ECF_NOTHROW | ECF_LEAF);
9251 /* If we're checking the stack, `alloca' can throw. */
9252 if (flag_stack_check)
9253 TREE_NOTHROW (built_in_decls[BUILT_IN_ALLOCA]) = 0;
9255 ftype = build_function_type_list (void_type_node,
9256 ptr_type_node, ptr_type_node,
9257 ptr_type_node, NULL_TREE);
9258 local_define_builtin ("__builtin_init_trampoline", ftype,
9259 BUILT_IN_INIT_TRAMPOLINE,
9260 "__builtin_init_trampoline", ECF_NOTHROW | ECF_LEAF);
9262 ftype = build_function_type_list (ptr_type_node, ptr_type_node, NULL_TREE);
9263 local_define_builtin ("__builtin_adjust_trampoline", ftype,
9264 BUILT_IN_ADJUST_TRAMPOLINE,
9265 "__builtin_adjust_trampoline",
9266 ECF_CONST | ECF_NOTHROW);
9268 ftype = build_function_type_list (void_type_node,
9269 ptr_type_node, ptr_type_node, NULL_TREE);
9270 local_define_builtin ("__builtin_nonlocal_goto", ftype,
9271 BUILT_IN_NONLOCAL_GOTO,
9272 "__builtin_nonlocal_goto",
9273 ECF_NORETURN | ECF_NOTHROW);
9275 ftype = build_function_type_list (void_type_node,
9276 ptr_type_node, ptr_type_node, NULL_TREE);
9277 local_define_builtin ("__builtin_setjmp_setup", ftype,
9278 BUILT_IN_SETJMP_SETUP,
9279 "__builtin_setjmp_setup", ECF_NOTHROW);
9281 ftype = build_function_type_list (ptr_type_node, ptr_type_node, NULL_TREE);
9282 local_define_builtin ("__builtin_setjmp_dispatcher", ftype,
9283 BUILT_IN_SETJMP_DISPATCHER,
9284 "__builtin_setjmp_dispatcher",
9285 ECF_PURE | ECF_NOTHROW);
9287 ftype = build_function_type_list (void_type_node, ptr_type_node, NULL_TREE);
9288 local_define_builtin ("__builtin_setjmp_receiver", ftype,
9289 BUILT_IN_SETJMP_RECEIVER,
9290 "__builtin_setjmp_receiver", ECF_NOTHROW);
9292 ftype = build_function_type_list (ptr_type_node, NULL_TREE);
9293 local_define_builtin ("__builtin_stack_save", ftype, BUILT_IN_STACK_SAVE,
9294 "__builtin_stack_save", ECF_NOTHROW | ECF_LEAF);
9296 ftype = build_function_type_list (void_type_node, ptr_type_node, NULL_TREE);
9297 local_define_builtin ("__builtin_stack_restore", ftype,
9298 BUILT_IN_STACK_RESTORE,
9299 "__builtin_stack_restore", ECF_NOTHROW | ECF_LEAF);
9301 ftype = build_function_type_list (void_type_node, NULL_TREE);
9302 local_define_builtin ("__builtin_profile_func_enter", ftype,
9303 BUILT_IN_PROFILE_FUNC_ENTER, "profile_func_enter", 0);
9304 local_define_builtin ("__builtin_profile_func_exit", ftype,
9305 BUILT_IN_PROFILE_FUNC_EXIT, "profile_func_exit", 0);
9307 /* If there's a possibility that we might use the ARM EABI, build the
9308 alternate __cxa_end_cleanup node used to resume from C++ and Java. */
9309 if (targetm.arm_eabi_unwinder)
9311 ftype = build_function_type_list (void_type_node, NULL_TREE);
9312 local_define_builtin ("__builtin_cxa_end_cleanup", ftype,
9313 BUILT_IN_CXA_END_CLEANUP,
9314 "__cxa_end_cleanup", ECF_NORETURN | ECF_LEAF);
9317 ftype = build_function_type_list (void_type_node, ptr_type_node, NULL_TREE);
9318 local_define_builtin ("__builtin_unwind_resume", ftype,
9319 BUILT_IN_UNWIND_RESUME,
9320 (targetm.except_unwind_info () == UI_SJLJ
9321 ? "_Unwind_SjLj_Resume" : "_Unwind_Resume"),
9324 /* The exception object and filter values from the runtime. The argument
9325 must be zero before exception lowering, i.e. from the front end. After
9326 exception lowering, it will be the region number for the exception
9327 landing pad. These functions are PURE instead of CONST to prevent
9328 them from being hoisted past the exception edge that will initialize
9329 its value in the landing pad. */
9330 ftype = build_function_type_list (ptr_type_node,
9331 integer_type_node, NULL_TREE);
9332 local_define_builtin ("__builtin_eh_pointer", ftype, BUILT_IN_EH_POINTER,
9333 "__builtin_eh_pointer", ECF_PURE | ECF_NOTHROW | ECF_LEAF);
9335 tmp = lang_hooks.types.type_for_mode (targetm.eh_return_filter_mode (), 0);
9336 ftype = build_function_type_list (tmp, integer_type_node, NULL_TREE);
9337 local_define_builtin ("__builtin_eh_filter", ftype, BUILT_IN_EH_FILTER,
9338 "__builtin_eh_filter", ECF_PURE | ECF_NOTHROW | ECF_LEAF);
9340 ftype = build_function_type_list (void_type_node,
9341 integer_type_node, integer_type_node,
9343 local_define_builtin ("__builtin_eh_copy_values", ftype,
9344 BUILT_IN_EH_COPY_VALUES,
9345 "__builtin_eh_copy_values", ECF_NOTHROW);
9347 /* Complex multiplication and division. These are handled as builtins
9348 rather than optabs because emit_library_call_value doesn't support
9349 complex. Further, we can do slightly better with folding these
9350 beasties if the real and complex parts of the arguments are separate. */
9354 for (mode = MIN_MODE_COMPLEX_FLOAT; mode <= MAX_MODE_COMPLEX_FLOAT; ++mode)
9356 char mode_name_buf[4], *q;
9358 enum built_in_function mcode, dcode;
9359 tree type, inner_type;
9361 type = lang_hooks.types.type_for_mode ((enum machine_mode) mode, 0);
9364 inner_type = TREE_TYPE (type);
9366 ftype = build_function_type_list (type, inner_type, inner_type,
9367 inner_type, inner_type, NULL_TREE);
9369 mcode = ((enum built_in_function)
9370 (BUILT_IN_COMPLEX_MUL_MIN + mode - MIN_MODE_COMPLEX_FLOAT));
9371 dcode = ((enum built_in_function)
9372 (BUILT_IN_COMPLEX_DIV_MIN + mode - MIN_MODE_COMPLEX_FLOAT));
9374 for (p = GET_MODE_NAME (mode), q = mode_name_buf; *p; p++, q++)
9378 built_in_names[mcode] = concat ("__mul", mode_name_buf, "3", NULL);
9379 local_define_builtin (built_in_names[mcode], ftype, mcode,
9380 built_in_names[mcode], ECF_CONST | ECF_NOTHROW | ECF_LEAF);
9382 built_in_names[dcode] = concat ("__div", mode_name_buf, "3", NULL);
9383 local_define_builtin (built_in_names[dcode], ftype, dcode,
9384 built_in_names[dcode], ECF_CONST | ECF_NOTHROW | ECF_LEAF);
9389 /* HACK. GROSS. This is absolutely disgusting. I wish there was a
9392 If we requested a pointer to a vector, build up the pointers that
9393 we stripped off while looking for the inner type. Similarly for
9394 return values from functions.
9396 The argument TYPE is the top of the chain, and BOTTOM is the
9397 new type which we will point to. */
9400 reconstruct_complex_type (tree type, tree bottom)
9404 if (TREE_CODE (type) == POINTER_TYPE)
9406 inner = reconstruct_complex_type (TREE_TYPE (type), bottom);
9407 outer = build_pointer_type_for_mode (inner, TYPE_MODE (type),
9408 TYPE_REF_CAN_ALIAS_ALL (type));
9410 else if (TREE_CODE (type) == REFERENCE_TYPE)
9412 inner = reconstruct_complex_type (TREE_TYPE (type), bottom);
9413 outer = build_reference_type_for_mode (inner, TYPE_MODE (type),
9414 TYPE_REF_CAN_ALIAS_ALL (type));
9416 else if (TREE_CODE (type) == ARRAY_TYPE)
9418 inner = reconstruct_complex_type (TREE_TYPE (type), bottom);
9419 outer = build_array_type (inner, TYPE_DOMAIN (type));
9421 else if (TREE_CODE (type) == FUNCTION_TYPE)
9423 inner = reconstruct_complex_type (TREE_TYPE (type), bottom);
9424 outer = build_function_type (inner, TYPE_ARG_TYPES (type));
9426 else if (TREE_CODE (type) == METHOD_TYPE)
9428 inner = reconstruct_complex_type (TREE_TYPE (type), bottom);
9429 /* The build_method_type_directly() routine prepends 'this' to argument list,
9430 so we must compensate by getting rid of it. */
9432 = build_method_type_directly
9433 (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (type))),
9435 TREE_CHAIN (TYPE_ARG_TYPES (type)));
9437 else if (TREE_CODE (type) == OFFSET_TYPE)
9439 inner = reconstruct_complex_type (TREE_TYPE (type), bottom);
9440 outer = build_offset_type (TYPE_OFFSET_BASETYPE (type), inner);
9445 return build_type_attribute_qual_variant (outer, TYPE_ATTRIBUTES (type),
9449 /* Returns a vector tree node given a mode (integer, vector, or BLKmode) and
9452 build_vector_type_for_mode (tree innertype, enum machine_mode mode)
9456 switch (GET_MODE_CLASS (mode))
9458 case MODE_VECTOR_INT:
9459 case MODE_VECTOR_FLOAT:
9460 case MODE_VECTOR_FRACT:
9461 case MODE_VECTOR_UFRACT:
9462 case MODE_VECTOR_ACCUM:
9463 case MODE_VECTOR_UACCUM:
9464 nunits = GET_MODE_NUNITS (mode);
9468 /* Check that there are no leftover bits. */
9469 gcc_assert (GET_MODE_BITSIZE (mode)
9470 % TREE_INT_CST_LOW (TYPE_SIZE (innertype)) == 0);
9472 nunits = GET_MODE_BITSIZE (mode)
9473 / TREE_INT_CST_LOW (TYPE_SIZE (innertype));
9480 return make_vector_type (innertype, nunits, mode);
9483 /* Similarly, but takes the inner type and number of units, which must be
9487 build_vector_type (tree innertype, int nunits)
9489 return make_vector_type (innertype, nunits, VOIDmode);
9492 /* Similarly, but takes the inner type and number of units, which must be
9496 build_opaque_vector_type (tree innertype, int nunits)
9499 innertype = build_distinct_type_copy (innertype);
9500 t = make_vector_type (innertype, nunits, VOIDmode);
9501 TYPE_VECTOR_OPAQUE (t) = true;
9506 /* Given an initializer INIT, return TRUE if INIT is zero or some
9507 aggregate of zeros. Otherwise return FALSE. */
9509 initializer_zerop (const_tree init)
9515 switch (TREE_CODE (init))
9518 return integer_zerop (init);
9521 /* ??? Note that this is not correct for C4X float formats. There,
9522 a bit pattern of all zeros is 1.0; 0.0 is encoded with the most
9523 negative exponent. */
9524 return real_zerop (init)
9525 && ! REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (init));
9528 return fixed_zerop (init);
9531 return integer_zerop (init)
9532 || (real_zerop (init)
9533 && ! REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (TREE_REALPART (init)))
9534 && ! REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (TREE_IMAGPART (init))));
9537 for (elt = TREE_VECTOR_CST_ELTS (init); elt; elt = TREE_CHAIN (elt))
9538 if (!initializer_zerop (TREE_VALUE (elt)))
9544 unsigned HOST_WIDE_INT idx;
9546 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (init), idx, elt)
9547 if (!initializer_zerop (elt))
9556 /* We need to loop through all elements to handle cases like
9557 "\0" and "\0foobar". */
9558 for (i = 0; i < TREE_STRING_LENGTH (init); ++i)
9559 if (TREE_STRING_POINTER (init)[i] != '\0')
9570 /* Build an empty statement at location LOC. */
9573 build_empty_stmt (location_t loc)
9575 tree t = build1 (NOP_EXPR, void_type_node, size_zero_node);
9576 SET_EXPR_LOCATION (t, loc);
9581 /* Build an OpenMP clause with code CODE. LOC is the location of the
9585 build_omp_clause (location_t loc, enum omp_clause_code code)
9590 length = omp_clause_num_ops[code];
9591 size = (sizeof (struct tree_omp_clause) + (length - 1) * sizeof (tree));
9593 t = ggc_alloc_tree_node (size);
9594 memset (t, 0, size);
9595 TREE_SET_CODE (t, OMP_CLAUSE);
9596 OMP_CLAUSE_SET_CODE (t, code);
9597 OMP_CLAUSE_LOCATION (t) = loc;
9599 #ifdef GATHER_STATISTICS
9600 tree_node_counts[(int) omp_clause_kind]++;
9601 tree_node_sizes[(int) omp_clause_kind] += size;
9607 /* Build a tcc_vl_exp object with code CODE and room for LEN operands. LEN
9608 includes the implicit operand count in TREE_OPERAND 0, and so must be >= 1.
9609 Except for the CODE and operand count field, other storage for the
9610 object is initialized to zeros. */
9613 build_vl_exp_stat (enum tree_code code, int len MEM_STAT_DECL)
9616 int length = (len - 1) * sizeof (tree) + sizeof (struct tree_exp);
9618 gcc_assert (TREE_CODE_CLASS (code) == tcc_vl_exp);
9619 gcc_assert (len >= 1);
9621 #ifdef GATHER_STATISTICS
9622 tree_node_counts[(int) e_kind]++;
9623 tree_node_sizes[(int) e_kind] += length;
9626 t = ggc_alloc_zone_cleared_tree_node_stat (&tree_zone, length PASS_MEM_STAT);
9628 TREE_SET_CODE (t, code);
9630 /* Can't use TREE_OPERAND to store the length because if checking is
9631 enabled, it will try to check the length before we store it. :-P */
9632 t->exp.operands[0] = build_int_cst (sizetype, len);
9637 /* Build a CALL_EXPR of class tcc_vl_exp with the indicated RETURN_TYPE and
9638 FN and a null static chain slot. NARGS is the number of call arguments
9639 which are specified as "..." arguments. */
9642 build_call_nary (tree return_type, tree fn, int nargs, ...)
9646 va_start (args, nargs);
9647 ret = build_call_valist (return_type, fn, nargs, args);
9652 /* Build a CALL_EXPR of class tcc_vl_exp with the indicated RETURN_TYPE and
9653 FN and a null static chain slot. NARGS is the number of call arguments
9654 which are specified as a va_list ARGS. */
9657 build_call_valist (tree return_type, tree fn, int nargs, va_list args)
9662 t = build_vl_exp (CALL_EXPR, nargs + 3);
9663 TREE_TYPE (t) = return_type;
9664 CALL_EXPR_FN (t) = fn;
9665 CALL_EXPR_STATIC_CHAIN (t) = NULL_TREE;
9666 for (i = 0; i < nargs; i++)
9667 CALL_EXPR_ARG (t, i) = va_arg (args, tree);
9668 process_call_operands (t);
9672 /* Build a CALL_EXPR of class tcc_vl_exp with the indicated RETURN_TYPE and
9673 FN and a null static chain slot. NARGS is the number of call arguments
9674 which are specified as a tree array ARGS. */
9677 build_call_array_loc (location_t loc, tree return_type, tree fn,
9678 int nargs, const tree *args)
9683 t = build_vl_exp (CALL_EXPR, nargs + 3);
9684 TREE_TYPE (t) = return_type;
9685 CALL_EXPR_FN (t) = fn;
9686 CALL_EXPR_STATIC_CHAIN (t) = NULL_TREE;
9687 for (i = 0; i < nargs; i++)
9688 CALL_EXPR_ARG (t, i) = args[i];
9689 process_call_operands (t);
9690 SET_EXPR_LOCATION (t, loc);
9694 /* Like build_call_array, but takes a VEC. */
9697 build_call_vec (tree return_type, tree fn, VEC(tree,gc) *args)
9702 ret = build_vl_exp (CALL_EXPR, VEC_length (tree, args) + 3);
9703 TREE_TYPE (ret) = return_type;
9704 CALL_EXPR_FN (ret) = fn;
9705 CALL_EXPR_STATIC_CHAIN (ret) = NULL_TREE;
9706 FOR_EACH_VEC_ELT (tree, args, ix, t)
9707 CALL_EXPR_ARG (ret, ix) = t;
9708 process_call_operands (ret);
9713 /* Returns true if it is possible to prove that the index of
9714 an array access REF (an ARRAY_REF expression) falls into the
9718 in_array_bounds_p (tree ref)
9720 tree idx = TREE_OPERAND (ref, 1);
9723 if (TREE_CODE (idx) != INTEGER_CST)
9726 min = array_ref_low_bound (ref);
9727 max = array_ref_up_bound (ref);
9730 || TREE_CODE (min) != INTEGER_CST
9731 || TREE_CODE (max) != INTEGER_CST)
9734 if (tree_int_cst_lt (idx, min)
9735 || tree_int_cst_lt (max, idx))
9741 /* Returns true if it is possible to prove that the range of
9742 an array access REF (an ARRAY_RANGE_REF expression) falls
9743 into the array bounds. */
9746 range_in_array_bounds_p (tree ref)
9748 tree domain_type = TYPE_DOMAIN (TREE_TYPE (ref));
9749 tree range_min, range_max, min, max;
9751 range_min = TYPE_MIN_VALUE (domain_type);
9752 range_max = TYPE_MAX_VALUE (domain_type);
9755 || TREE_CODE (range_min) != INTEGER_CST
9756 || TREE_CODE (range_max) != INTEGER_CST)
9759 min = array_ref_low_bound (ref);
9760 max = array_ref_up_bound (ref);
9763 || TREE_CODE (min) != INTEGER_CST
9764 || TREE_CODE (max) != INTEGER_CST)
9767 if (tree_int_cst_lt (range_min, min)
9768 || tree_int_cst_lt (max, range_max))
9774 /* Return true if T (assumed to be a DECL) must be assigned a memory
9778 needs_to_live_in_memory (const_tree t)
9780 if (TREE_CODE (t) == SSA_NAME)
9781 t = SSA_NAME_VAR (t);
9783 return (TREE_ADDRESSABLE (t)
9784 || is_global_var (t)
9785 || (TREE_CODE (t) == RESULT_DECL
9786 && !DECL_BY_REFERENCE (t)
9787 && aggregate_value_p (t, current_function_decl)));
9790 /* There are situations in which a language considers record types
9791 compatible which have different field lists. Decide if two fields
9792 are compatible. It is assumed that the parent records are compatible. */
9795 fields_compatible_p (const_tree f1, const_tree f2)
9797 if (!operand_equal_p (DECL_FIELD_BIT_OFFSET (f1),
9798 DECL_FIELD_BIT_OFFSET (f2), OEP_ONLY_CONST))
9801 if (!operand_equal_p (DECL_FIELD_OFFSET (f1),
9802 DECL_FIELD_OFFSET (f2), OEP_ONLY_CONST))
9805 if (!types_compatible_p (TREE_TYPE (f1), TREE_TYPE (f2)))
9811 /* Locate within RECORD a field that is compatible with ORIG_FIELD. */
9814 find_compatible_field (tree record, tree orig_field)
9818 for (f = TYPE_FIELDS (record); f ; f = TREE_CHAIN (f))
9819 if (TREE_CODE (f) == FIELD_DECL
9820 && fields_compatible_p (f, orig_field))
9823 /* ??? Why isn't this on the main fields list? */
9824 f = TYPE_VFIELD (record);
9825 if (f && TREE_CODE (f) == FIELD_DECL
9826 && fields_compatible_p (f, orig_field))
9829 /* ??? We should abort here, but Java appears to do Bad Things
9830 with inherited fields. */
9834 /* Return value of a constant X and sign-extend it. */
9837 int_cst_value (const_tree x)
9839 unsigned bits = TYPE_PRECISION (TREE_TYPE (x));
9840 unsigned HOST_WIDE_INT val = TREE_INT_CST_LOW (x);
9842 /* Make sure the sign-extended value will fit in a HOST_WIDE_INT. */
9843 gcc_assert (TREE_INT_CST_HIGH (x) == 0
9844 || TREE_INT_CST_HIGH (x) == -1);
9846 if (bits < HOST_BITS_PER_WIDE_INT)
9848 bool negative = ((val >> (bits - 1)) & 1) != 0;
9850 val |= (~(unsigned HOST_WIDE_INT) 0) << (bits - 1) << 1;
9852 val &= ~((~(unsigned HOST_WIDE_INT) 0) << (bits - 1) << 1);
9858 /* Return value of a constant X and sign-extend it. */
9861 widest_int_cst_value (const_tree x)
9863 unsigned bits = TYPE_PRECISION (TREE_TYPE (x));
9864 unsigned HOST_WIDEST_INT val = TREE_INT_CST_LOW (x);
9866 #if HOST_BITS_PER_WIDEST_INT > HOST_BITS_PER_WIDE_INT
9867 gcc_assert (HOST_BITS_PER_WIDEST_INT >= 2 * HOST_BITS_PER_WIDE_INT);
9868 val |= (((unsigned HOST_WIDEST_INT) TREE_INT_CST_HIGH (x))
9869 << HOST_BITS_PER_WIDE_INT);
9871 /* Make sure the sign-extended value will fit in a HOST_WIDE_INT. */
9872 gcc_assert (TREE_INT_CST_HIGH (x) == 0
9873 || TREE_INT_CST_HIGH (x) == -1);
9876 if (bits < HOST_BITS_PER_WIDEST_INT)
9878 bool negative = ((val >> (bits - 1)) & 1) != 0;
9880 val |= (~(unsigned HOST_WIDEST_INT) 0) << (bits - 1) << 1;
9882 val &= ~((~(unsigned HOST_WIDEST_INT) 0) << (bits - 1) << 1);
9888 /* If TYPE is an integral type, return an equivalent type which is
9889 unsigned iff UNSIGNEDP is true. If TYPE is not an integral type,
9890 return TYPE itself. */
9893 signed_or_unsigned_type_for (int unsignedp, tree type)
9896 if (POINTER_TYPE_P (type))
9898 /* If the pointer points to the normal address space, use the
9899 size_type_node. Otherwise use an appropriate size for the pointer
9900 based on the named address space it points to. */
9901 if (!TYPE_ADDR_SPACE (TREE_TYPE (t)))
9904 return lang_hooks.types.type_for_size (TYPE_PRECISION (t), unsignedp);
9907 if (!INTEGRAL_TYPE_P (t) || TYPE_UNSIGNED (t) == unsignedp)
9910 return lang_hooks.types.type_for_size (TYPE_PRECISION (t), unsignedp);
9913 /* Returns unsigned variant of TYPE. */
9916 unsigned_type_for (tree type)
9918 return signed_or_unsigned_type_for (1, type);
9921 /* Returns signed variant of TYPE. */
9924 signed_type_for (tree type)
9926 return signed_or_unsigned_type_for (0, type);
9929 /* Returns the largest value obtainable by casting something in INNER type to
9933 upper_bound_in_type (tree outer, tree inner)
9935 unsigned HOST_WIDE_INT lo, hi;
9936 unsigned int det = 0;
9937 unsigned oprec = TYPE_PRECISION (outer);
9938 unsigned iprec = TYPE_PRECISION (inner);
9941 /* Compute a unique number for every combination. */
9942 det |= (oprec > iprec) ? 4 : 0;
9943 det |= TYPE_UNSIGNED (outer) ? 2 : 0;
9944 det |= TYPE_UNSIGNED (inner) ? 1 : 0;
9946 /* Determine the exponent to use. */
9951 /* oprec <= iprec, outer: signed, inner: don't care. */
9956 /* oprec <= iprec, outer: unsigned, inner: don't care. */
9960 /* oprec > iprec, outer: signed, inner: signed. */
9964 /* oprec > iprec, outer: signed, inner: unsigned. */
9968 /* oprec > iprec, outer: unsigned, inner: signed. */
9972 /* oprec > iprec, outer: unsigned, inner: unsigned. */
9979 /* Compute 2^^prec - 1. */
9980 if (prec <= HOST_BITS_PER_WIDE_INT)
9983 lo = ((~(unsigned HOST_WIDE_INT) 0)
9984 >> (HOST_BITS_PER_WIDE_INT - prec));
9988 hi = ((~(unsigned HOST_WIDE_INT) 0)
9989 >> (2 * HOST_BITS_PER_WIDE_INT - prec));
9990 lo = ~(unsigned HOST_WIDE_INT) 0;
9993 return build_int_cst_wide (outer, lo, hi);
9996 /* Returns the smallest value obtainable by casting something in INNER type to
10000 lower_bound_in_type (tree outer, tree inner)
10002 unsigned HOST_WIDE_INT lo, hi;
10003 unsigned oprec = TYPE_PRECISION (outer);
10004 unsigned iprec = TYPE_PRECISION (inner);
10006 /* If OUTER type is unsigned, we can definitely cast 0 to OUTER type
10008 if (TYPE_UNSIGNED (outer)
10009 /* If we are widening something of an unsigned type, OUTER type
10010 contains all values of INNER type. In particular, both INNER
10011 and OUTER types have zero in common. */
10012 || (oprec > iprec && TYPE_UNSIGNED (inner)))
10016 /* If we are widening a signed type to another signed type, we
10017 want to obtain -2^^(iprec-1). If we are keeping the
10018 precision or narrowing to a signed type, we want to obtain
10020 unsigned prec = oprec > iprec ? iprec : oprec;
10022 if (prec <= HOST_BITS_PER_WIDE_INT)
10024 hi = ~(unsigned HOST_WIDE_INT) 0;
10025 lo = (~(unsigned HOST_WIDE_INT) 0) << (prec - 1);
10029 hi = ((~(unsigned HOST_WIDE_INT) 0)
10030 << (prec - HOST_BITS_PER_WIDE_INT - 1));
10035 return build_int_cst_wide (outer, lo, hi);
10038 /* Return nonzero if two operands that are suitable for PHI nodes are
10039 necessarily equal. Specifically, both ARG0 and ARG1 must be either
10040 SSA_NAME or invariant. Note that this is strictly an optimization.
10041 That is, callers of this function can directly call operand_equal_p
10042 and get the same result, only slower. */
10045 operand_equal_for_phi_arg_p (const_tree arg0, const_tree arg1)
10049 if (TREE_CODE (arg0) == SSA_NAME || TREE_CODE (arg1) == SSA_NAME)
10051 return operand_equal_p (arg0, arg1, 0);
10054 /* Returns number of zeros at the end of binary representation of X.
10056 ??? Use ffs if available? */
10059 num_ending_zeros (const_tree x)
10061 unsigned HOST_WIDE_INT fr, nfr;
10062 unsigned num, abits;
10063 tree type = TREE_TYPE (x);
10065 if (TREE_INT_CST_LOW (x) == 0)
10067 num = HOST_BITS_PER_WIDE_INT;
10068 fr = TREE_INT_CST_HIGH (x);
10073 fr = TREE_INT_CST_LOW (x);
10076 for (abits = HOST_BITS_PER_WIDE_INT / 2; abits; abits /= 2)
10079 if (nfr << abits == fr)
10086 if (num > TYPE_PRECISION (type))
10087 num = TYPE_PRECISION (type);
10089 return build_int_cst_type (type, num);
10093 #define WALK_SUBTREE(NODE) \
10096 result = walk_tree_1 (&(NODE), func, data, pset, lh); \
10102 /* This is a subroutine of walk_tree that walks field of TYPE that are to
10103 be walked whenever a type is seen in the tree. Rest of operands and return
10104 value are as for walk_tree. */
10107 walk_type_fields (tree type, walk_tree_fn func, void *data,
10108 struct pointer_set_t *pset, walk_tree_lh lh)
10110 tree result = NULL_TREE;
10112 switch (TREE_CODE (type))
10115 case REFERENCE_TYPE:
10116 /* We have to worry about mutually recursive pointers. These can't
10117 be written in C. They can in Ada. It's pathological, but
10118 there's an ACATS test (c38102a) that checks it. Deal with this
10119 by checking if we're pointing to another pointer, that one
10120 points to another pointer, that one does too, and we have no htab.
10121 If so, get a hash table. We check three levels deep to avoid
10122 the cost of the hash table if we don't need one. */
10123 if (POINTER_TYPE_P (TREE_TYPE (type))
10124 && POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (type)))
10125 && POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (TREE_TYPE (type))))
10128 result = walk_tree_without_duplicates (&TREE_TYPE (type),
10136 /* ... fall through ... */
10139 WALK_SUBTREE (TREE_TYPE (type));
10143 WALK_SUBTREE (TYPE_METHOD_BASETYPE (type));
10145 /* Fall through. */
10147 case FUNCTION_TYPE:
10148 WALK_SUBTREE (TREE_TYPE (type));
10152 /* We never want to walk into default arguments. */
10153 for (arg = TYPE_ARG_TYPES (type); arg; arg = TREE_CHAIN (arg))
10154 WALK_SUBTREE (TREE_VALUE (arg));
10159 /* Don't follow this nodes's type if a pointer for fear that
10160 we'll have infinite recursion. If we have a PSET, then we
10163 || (!POINTER_TYPE_P (TREE_TYPE (type))
10164 && TREE_CODE (TREE_TYPE (type)) != OFFSET_TYPE))
10165 WALK_SUBTREE (TREE_TYPE (type));
10166 WALK_SUBTREE (TYPE_DOMAIN (type));
10170 WALK_SUBTREE (TREE_TYPE (type));
10171 WALK_SUBTREE (TYPE_OFFSET_BASETYPE (type));
10181 /* Apply FUNC to all the sub-trees of TP in a pre-order traversal. FUNC is
10182 called with the DATA and the address of each sub-tree. If FUNC returns a
10183 non-NULL value, the traversal is stopped, and the value returned by FUNC
10184 is returned. If PSET is non-NULL it is used to record the nodes visited,
10185 and to avoid visiting a node more than once. */
10188 walk_tree_1 (tree *tp, walk_tree_fn func, void *data,
10189 struct pointer_set_t *pset, walk_tree_lh lh)
10191 enum tree_code code;
10195 #define WALK_SUBTREE_TAIL(NODE) \
10199 goto tail_recurse; \
10204 /* Skip empty subtrees. */
10208 /* Don't walk the same tree twice, if the user has requested
10209 that we avoid doing so. */
10210 if (pset && pointer_set_insert (pset, *tp))
10213 /* Call the function. */
10215 result = (*func) (tp, &walk_subtrees, data);
10217 /* If we found something, return it. */
10221 code = TREE_CODE (*tp);
10223 /* Even if we didn't, FUNC may have decided that there was nothing
10224 interesting below this point in the tree. */
10225 if (!walk_subtrees)
10227 /* But we still need to check our siblings. */
10228 if (code == TREE_LIST)
10229 WALK_SUBTREE_TAIL (TREE_CHAIN (*tp));
10230 else if (code == OMP_CLAUSE)
10231 WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp));
10238 result = (*lh) (tp, &walk_subtrees, func, data, pset);
10239 if (result || !walk_subtrees)
10246 case IDENTIFIER_NODE:
10253 case PLACEHOLDER_EXPR:
10257 /* None of these have subtrees other than those already walked
10262 WALK_SUBTREE (TREE_VALUE (*tp));
10263 WALK_SUBTREE_TAIL (TREE_CHAIN (*tp));
10268 int len = TREE_VEC_LENGTH (*tp);
10273 /* Walk all elements but the first. */
10275 WALK_SUBTREE (TREE_VEC_ELT (*tp, len));
10277 /* Now walk the first one as a tail call. */
10278 WALK_SUBTREE_TAIL (TREE_VEC_ELT (*tp, 0));
10282 WALK_SUBTREE (TREE_REALPART (*tp));
10283 WALK_SUBTREE_TAIL (TREE_IMAGPART (*tp));
10287 unsigned HOST_WIDE_INT idx;
10288 constructor_elt *ce;
10291 VEC_iterate(constructor_elt, CONSTRUCTOR_ELTS (*tp), idx, ce);
10293 WALK_SUBTREE (ce->value);
10298 WALK_SUBTREE_TAIL (TREE_OPERAND (*tp, 0));
10303 for (decl = BIND_EXPR_VARS (*tp); decl; decl = DECL_CHAIN (decl))
10305 /* Walk the DECL_INITIAL and DECL_SIZE. We don't want to walk
10306 into declarations that are just mentioned, rather than
10307 declared; they don't really belong to this part of the tree.
10308 And, we can see cycles: the initializer for a declaration
10309 can refer to the declaration itself. */
10310 WALK_SUBTREE (DECL_INITIAL (decl));
10311 WALK_SUBTREE (DECL_SIZE (decl));
10312 WALK_SUBTREE (DECL_SIZE_UNIT (decl));
10314 WALK_SUBTREE_TAIL (BIND_EXPR_BODY (*tp));
10317 case STATEMENT_LIST:
10319 tree_stmt_iterator i;
10320 for (i = tsi_start (*tp); !tsi_end_p (i); tsi_next (&i))
10321 WALK_SUBTREE (*tsi_stmt_ptr (i));
10326 switch (OMP_CLAUSE_CODE (*tp))
10328 case OMP_CLAUSE_PRIVATE:
10329 case OMP_CLAUSE_SHARED:
10330 case OMP_CLAUSE_FIRSTPRIVATE:
10331 case OMP_CLAUSE_COPYIN:
10332 case OMP_CLAUSE_COPYPRIVATE:
10333 case OMP_CLAUSE_IF:
10334 case OMP_CLAUSE_NUM_THREADS:
10335 case OMP_CLAUSE_SCHEDULE:
10336 WALK_SUBTREE (OMP_CLAUSE_OPERAND (*tp, 0));
10339 case OMP_CLAUSE_NOWAIT:
10340 case OMP_CLAUSE_ORDERED:
10341 case OMP_CLAUSE_DEFAULT:
10342 case OMP_CLAUSE_UNTIED:
10343 WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp));
10345 case OMP_CLAUSE_LASTPRIVATE:
10346 WALK_SUBTREE (OMP_CLAUSE_DECL (*tp));
10347 WALK_SUBTREE (OMP_CLAUSE_LASTPRIVATE_STMT (*tp));
10348 WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp));
10350 case OMP_CLAUSE_COLLAPSE:
10353 for (i = 0; i < 3; i++)
10354 WALK_SUBTREE (OMP_CLAUSE_OPERAND (*tp, i));
10355 WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp));
10358 case OMP_CLAUSE_REDUCTION:
10361 for (i = 0; i < 4; i++)
10362 WALK_SUBTREE (OMP_CLAUSE_OPERAND (*tp, i));
10363 WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp));
10367 gcc_unreachable ();
10375 /* TARGET_EXPRs are peculiar: operands 1 and 3 can be the same.
10376 But, we only want to walk once. */
10377 len = (TREE_OPERAND (*tp, 3) == TREE_OPERAND (*tp, 1)) ? 2 : 3;
10378 for (i = 0; i < len; ++i)
10379 WALK_SUBTREE (TREE_OPERAND (*tp, i));
10380 WALK_SUBTREE_TAIL (TREE_OPERAND (*tp, len));
10384 /* If this is a TYPE_DECL, walk into the fields of the type that it's
10385 defining. We only want to walk into these fields of a type in this
10386 case and not in the general case of a mere reference to the type.
10388 The criterion is as follows: if the field can be an expression, it
10389 must be walked only here. This should be in keeping with the fields
10390 that are directly gimplified in gimplify_type_sizes in order for the
10391 mark/copy-if-shared/unmark machinery of the gimplifier to work with
10392 variable-sized types.
10394 Note that DECLs get walked as part of processing the BIND_EXPR. */
10395 if (TREE_CODE (DECL_EXPR_DECL (*tp)) == TYPE_DECL)
10397 tree *type_p = &TREE_TYPE (DECL_EXPR_DECL (*tp));
10398 if (TREE_CODE (*type_p) == ERROR_MARK)
10401 /* Call the function for the type. See if it returns anything or
10402 doesn't want us to continue. If we are to continue, walk both
10403 the normal fields and those for the declaration case. */
10404 result = (*func) (type_p, &walk_subtrees, data);
10405 if (result || !walk_subtrees)
10408 result = walk_type_fields (*type_p, func, data, pset, lh);
10412 /* If this is a record type, also walk the fields. */
10413 if (RECORD_OR_UNION_TYPE_P (*type_p))
10417 for (field = TYPE_FIELDS (*type_p); field;
10418 field = DECL_CHAIN (field))
10420 /* We'd like to look at the type of the field, but we can
10421 easily get infinite recursion. So assume it's pointed
10422 to elsewhere in the tree. Also, ignore things that
10424 if (TREE_CODE (field) != FIELD_DECL)
10427 WALK_SUBTREE (DECL_FIELD_OFFSET (field));
10428 WALK_SUBTREE (DECL_SIZE (field));
10429 WALK_SUBTREE (DECL_SIZE_UNIT (field));
10430 if (TREE_CODE (*type_p) == QUAL_UNION_TYPE)
10431 WALK_SUBTREE (DECL_QUALIFIER (field));
10435 /* Same for scalar types. */
10436 else if (TREE_CODE (*type_p) == BOOLEAN_TYPE
10437 || TREE_CODE (*type_p) == ENUMERAL_TYPE
10438 || TREE_CODE (*type_p) == INTEGER_TYPE
10439 || TREE_CODE (*type_p) == FIXED_POINT_TYPE
10440 || TREE_CODE (*type_p) == REAL_TYPE)
10442 WALK_SUBTREE (TYPE_MIN_VALUE (*type_p));
10443 WALK_SUBTREE (TYPE_MAX_VALUE (*type_p));
10446 WALK_SUBTREE (TYPE_SIZE (*type_p));
10447 WALK_SUBTREE_TAIL (TYPE_SIZE_UNIT (*type_p));
10452 if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (code)))
10456 /* Walk over all the sub-trees of this operand. */
10457 len = TREE_OPERAND_LENGTH (*tp);
10459 /* Go through the subtrees. We need to do this in forward order so
10460 that the scope of a FOR_EXPR is handled properly. */
10463 for (i = 0; i < len - 1; ++i)
10464 WALK_SUBTREE (TREE_OPERAND (*tp, i));
10465 WALK_SUBTREE_TAIL (TREE_OPERAND (*tp, len - 1));
10468 /* If this is a type, walk the needed fields in the type. */
10469 else if (TYPE_P (*tp))
10470 return walk_type_fields (*tp, func, data, pset, lh);
10474 /* We didn't find what we were looking for. */
10477 #undef WALK_SUBTREE_TAIL
10479 #undef WALK_SUBTREE
10481 /* Like walk_tree, but does not walk duplicate nodes more than once. */
10484 walk_tree_without_duplicates_1 (tree *tp, walk_tree_fn func, void *data,
10488 struct pointer_set_t *pset;
10490 pset = pointer_set_create ();
10491 result = walk_tree_1 (tp, func, data, pset, lh);
10492 pointer_set_destroy (pset);
10498 tree_block (tree t)
10500 char const c = TREE_CODE_CLASS (TREE_CODE (t));
10502 if (IS_EXPR_CODE_CLASS (c))
10503 return &t->exp.block;
10504 gcc_unreachable ();
10508 /* Create a nameless artificial label and put it in the current
10509 function context. The label has a location of LOC. Returns the
10510 newly created label. */
10513 create_artificial_label (location_t loc)
10515 tree lab = build_decl (loc,
10516 LABEL_DECL, NULL_TREE, void_type_node);
10518 DECL_ARTIFICIAL (lab) = 1;
10519 DECL_IGNORED_P (lab) = 1;
10520 DECL_CONTEXT (lab) = current_function_decl;
10524 /* Given a tree, try to return a useful variable name that we can use
10525 to prefix a temporary that is being assigned the value of the tree.
10526 I.E. given <temp> = &A, return A. */
10531 tree stripped_decl;
10534 STRIP_NOPS (stripped_decl);
10535 if (DECL_P (stripped_decl) && DECL_NAME (stripped_decl))
10536 return IDENTIFIER_POINTER (DECL_NAME (stripped_decl));
10539 switch (TREE_CODE (stripped_decl))
10542 return get_name (TREE_OPERAND (stripped_decl, 0));
10549 /* Return true if TYPE has a variable argument list. */
10552 stdarg_p (const_tree fntype)
10554 function_args_iterator args_iter;
10555 tree n = NULL_TREE, t;
10560 FOREACH_FUNCTION_ARGS(fntype, t, args_iter)
10565 return n != NULL_TREE && n != void_type_node;
10568 /* Return true if TYPE has a prototype. */
10571 prototype_p (tree fntype)
10575 gcc_assert (fntype != NULL_TREE);
10577 t = TYPE_ARG_TYPES (fntype);
10578 return (t != NULL_TREE);
10581 /* If BLOCK is inlined from an __attribute__((__artificial__))
10582 routine, return pointer to location from where it has been
10585 block_nonartificial_location (tree block)
10587 location_t *ret = NULL;
10589 while (block && TREE_CODE (block) == BLOCK
10590 && BLOCK_ABSTRACT_ORIGIN (block))
10592 tree ao = BLOCK_ABSTRACT_ORIGIN (block);
10594 while (TREE_CODE (ao) == BLOCK
10595 && BLOCK_ABSTRACT_ORIGIN (ao)
10596 && BLOCK_ABSTRACT_ORIGIN (ao) != ao)
10597 ao = BLOCK_ABSTRACT_ORIGIN (ao);
10599 if (TREE_CODE (ao) == FUNCTION_DECL)
10601 /* If AO is an artificial inline, point RET to the
10602 call site locus at which it has been inlined and continue
10603 the loop, in case AO's caller is also an artificial
10605 if (DECL_DECLARED_INLINE_P (ao)
10606 && lookup_attribute ("artificial", DECL_ATTRIBUTES (ao)))
10607 ret = &BLOCK_SOURCE_LOCATION (block);
10611 else if (TREE_CODE (ao) != BLOCK)
10614 block = BLOCK_SUPERCONTEXT (block);
10620 /* If EXP is inlined from an __attribute__((__artificial__))
10621 function, return the location of the original call expression. */
10624 tree_nonartificial_location (tree exp)
10626 location_t *loc = block_nonartificial_location (TREE_BLOCK (exp));
10631 return EXPR_LOCATION (exp);
10635 /* These are the hash table functions for the hash table of OPTIMIZATION_NODEq
10638 /* Return the hash code code X, an OPTIMIZATION_NODE or TARGET_OPTION code. */
10641 cl_option_hash_hash (const void *x)
10643 const_tree const t = (const_tree) x;
10647 hashval_t hash = 0;
10649 if (TREE_CODE (t) == OPTIMIZATION_NODE)
10651 p = (const char *)TREE_OPTIMIZATION (t);
10652 len = sizeof (struct cl_optimization);
10655 else if (TREE_CODE (t) == TARGET_OPTION_NODE)
10657 p = (const char *)TREE_TARGET_OPTION (t);
10658 len = sizeof (struct cl_target_option);
10662 gcc_unreachable ();
10664 /* assume most opt flags are just 0/1, some are 2-3, and a few might be
10666 for (i = 0; i < len; i++)
10668 hash = (hash << 4) ^ ((i << 2) | p[i]);
10673 /* Return nonzero if the value represented by *X (an OPTIMIZATION or
10674 TARGET_OPTION tree node) is the same as that given by *Y, which is the
10678 cl_option_hash_eq (const void *x, const void *y)
10680 const_tree const xt = (const_tree) x;
10681 const_tree const yt = (const_tree) y;
10686 if (TREE_CODE (xt) != TREE_CODE (yt))
10689 if (TREE_CODE (xt) == OPTIMIZATION_NODE)
10691 xp = (const char *)TREE_OPTIMIZATION (xt);
10692 yp = (const char *)TREE_OPTIMIZATION (yt);
10693 len = sizeof (struct cl_optimization);
10696 else if (TREE_CODE (xt) == TARGET_OPTION_NODE)
10698 xp = (const char *)TREE_TARGET_OPTION (xt);
10699 yp = (const char *)TREE_TARGET_OPTION (yt);
10700 len = sizeof (struct cl_target_option);
10704 gcc_unreachable ();
10706 return (memcmp (xp, yp, len) == 0);
10709 /* Build an OPTIMIZATION_NODE based on the current options. */
10712 build_optimization_node (void)
10717 /* Use the cache of optimization nodes. */
10719 cl_optimization_save (TREE_OPTIMIZATION (cl_optimization_node),
10722 slot = htab_find_slot (cl_option_hash_table, cl_optimization_node, INSERT);
10726 /* Insert this one into the hash table. */
10727 t = cl_optimization_node;
10730 /* Make a new node for next time round. */
10731 cl_optimization_node = make_node (OPTIMIZATION_NODE);
10737 /* Build a TARGET_OPTION_NODE based on the current options. */
10740 build_target_option_node (void)
10745 /* Use the cache of optimization nodes. */
10747 cl_target_option_save (TREE_TARGET_OPTION (cl_target_option_node),
10750 slot = htab_find_slot (cl_option_hash_table, cl_target_option_node, INSERT);
10754 /* Insert this one into the hash table. */
10755 t = cl_target_option_node;
10758 /* Make a new node for next time round. */
10759 cl_target_option_node = make_node (TARGET_OPTION_NODE);
10765 /* Determine the "ultimate origin" of a block. The block may be an inlined
10766 instance of an inlined instance of a block which is local to an inline
10767 function, so we have to trace all of the way back through the origin chain
10768 to find out what sort of node actually served as the original seed for the
10772 block_ultimate_origin (const_tree block)
10774 tree immediate_origin = BLOCK_ABSTRACT_ORIGIN (block);
10776 /* output_inline_function sets BLOCK_ABSTRACT_ORIGIN for all the
10777 nodes in the function to point to themselves; ignore that if
10778 we're trying to output the abstract instance of this function. */
10779 if (BLOCK_ABSTRACT (block) && immediate_origin == block)
10782 if (immediate_origin == NULL_TREE)
10787 tree lookahead = immediate_origin;
10791 ret_val = lookahead;
10792 lookahead = (TREE_CODE (ret_val) == BLOCK
10793 ? BLOCK_ABSTRACT_ORIGIN (ret_val) : NULL);
10795 while (lookahead != NULL && lookahead != ret_val);
10797 /* The block's abstract origin chain may not be the *ultimate* origin of
10798 the block. It could lead to a DECL that has an abstract origin set.
10799 If so, we want that DECL's abstract origin (which is what DECL_ORIGIN
10800 will give us if it has one). Note that DECL's abstract origins are
10801 supposed to be the most distant ancestor (or so decl_ultimate_origin
10802 claims), so we don't need to loop following the DECL origins. */
10803 if (DECL_P (ret_val))
10804 return DECL_ORIGIN (ret_val);
10810 /* Return true if T1 and T2 are equivalent lists. */
10813 list_equal_p (const_tree t1, const_tree t2)
10815 for (; t1 && t2; t1 = TREE_CHAIN (t1) , t2 = TREE_CHAIN (t2))
10816 if (TREE_VALUE (t1) != TREE_VALUE (t2))
10821 /* Return true iff conversion in EXP generates no instruction. Mark
10822 it inline so that we fully inline into the stripping functions even
10823 though we have two uses of this function. */
10826 tree_nop_conversion (const_tree exp)
10828 tree outer_type, inner_type;
10830 if (!CONVERT_EXPR_P (exp)
10831 && TREE_CODE (exp) != NON_LVALUE_EXPR)
10833 if (TREE_OPERAND (exp, 0) == error_mark_node)
10836 outer_type = TREE_TYPE (exp);
10837 inner_type = TREE_TYPE (TREE_OPERAND (exp, 0));
10842 /* Use precision rather then machine mode when we can, which gives
10843 the correct answer even for submode (bit-field) types. */
10844 if ((INTEGRAL_TYPE_P (outer_type)
10845 || POINTER_TYPE_P (outer_type)
10846 || TREE_CODE (outer_type) == OFFSET_TYPE)
10847 && (INTEGRAL_TYPE_P (inner_type)
10848 || POINTER_TYPE_P (inner_type)
10849 || TREE_CODE (inner_type) == OFFSET_TYPE))
10850 return TYPE_PRECISION (outer_type) == TYPE_PRECISION (inner_type);
10852 /* Otherwise fall back on comparing machine modes (e.g. for
10853 aggregate types, floats). */
10854 return TYPE_MODE (outer_type) == TYPE_MODE (inner_type);
10857 /* Return true iff conversion in EXP generates no instruction. Don't
10858 consider conversions changing the signedness. */
10861 tree_sign_nop_conversion (const_tree exp)
10863 tree outer_type, inner_type;
10865 if (!tree_nop_conversion (exp))
10868 outer_type = TREE_TYPE (exp);
10869 inner_type = TREE_TYPE (TREE_OPERAND (exp, 0));
10871 return (TYPE_UNSIGNED (outer_type) == TYPE_UNSIGNED (inner_type)
10872 && POINTER_TYPE_P (outer_type) == POINTER_TYPE_P (inner_type));
10875 /* Strip conversions from EXP according to tree_nop_conversion and
10876 return the resulting expression. */
10879 tree_strip_nop_conversions (tree exp)
10881 while (tree_nop_conversion (exp))
10882 exp = TREE_OPERAND (exp, 0);
10886 /* Strip conversions from EXP according to tree_sign_nop_conversion
10887 and return the resulting expression. */
10890 tree_strip_sign_nop_conversions (tree exp)
10892 while (tree_sign_nop_conversion (exp))
10893 exp = TREE_OPERAND (exp, 0);
10897 static GTY(()) tree gcc_eh_personality_decl;
10899 /* Return the GCC personality function decl. */
10902 lhd_gcc_personality (void)
10904 if (!gcc_eh_personality_decl)
10905 gcc_eh_personality_decl = build_personality_function ("gcc");
10906 return gcc_eh_personality_decl;
10909 /* Try to find a base info of BINFO that would have its field decl at offset
10910 OFFSET within the BINFO type and which is of EXPECTED_TYPE. If it can be
10911 found, return, otherwise return NULL_TREE. */
10914 get_binfo_at_offset (tree binfo, HOST_WIDE_INT offset, tree expected_type)
10918 type = TREE_TYPE (binfo);
10921 tree base_binfo, found_binfo;
10922 HOST_WIDE_INT pos, size;
10926 if (TREE_CODE (type) != RECORD_TYPE)
10929 for (fld = TYPE_FIELDS (type); fld; fld = DECL_CHAIN (fld))
10931 if (TREE_CODE (fld) != FIELD_DECL)
10934 pos = int_bit_position (fld);
10935 size = tree_low_cst (DECL_SIZE (fld), 1);
10936 if (pos <= offset && (pos + size) > offset)
10942 found_binfo = NULL_TREE;
10943 for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
10944 if (TREE_TYPE (base_binfo) == TREE_TYPE (fld))
10946 found_binfo = base_binfo;
10953 type = TREE_TYPE (fld);
10954 binfo = found_binfo;
10957 if (type != expected_type)
10962 /* Returns true if X is a typedef decl. */
10965 is_typedef_decl (tree x)
10967 return (x && TREE_CODE (x) == TYPE_DECL
10968 && DECL_ORIGINAL_TYPE (x) != NULL_TREE);
10971 /* Returns true iff TYPE is a type variant created for a typedef. */
10974 typedef_variant_p (tree type)
10976 return is_typedef_decl (TYPE_NAME (type));
10979 #include "gt-tree.h"