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 Free Software Foundation, Inc.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 2, or (at your option) any later
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING. If not, write to the Free
19 Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
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"
47 #include "langhooks.h"
48 #include "tree-iterator.h"
49 #include "basic-block.h"
50 #include "tree-flow.h"
52 #include "pointer-set.h"
54 /* Each tree code class has an associated string representation.
55 These must correspond to the tree_code_class entries. */
57 const char *const tree_code_class_strings
[] =
71 /* obstack.[ch] explicitly declined to prototype this. */
72 extern int _obstack_allocated_p (struct obstack
*h
, void *obj
);
74 #ifdef GATHER_STATISTICS
75 /* Statistics-gathering stuff. */
77 int tree_node_counts
[(int) all_kinds
];
78 int tree_node_sizes
[(int) all_kinds
];
80 /* Keep in sync with tree.h:enum tree_node_kind. */
81 static const char * const tree_node_kind_names
[] = {
101 #endif /* GATHER_STATISTICS */
103 /* Unique id for next decl created. */
104 static GTY(()) int next_decl_uid
;
105 /* Unique id for next type created. */
106 static GTY(()) int next_type_uid
= 1;
108 /* Since we cannot rehash a type after it is in the table, we have to
109 keep the hash code. */
111 struct type_hash
GTY(())
117 /* Initial size of the hash table (rounded to next prime). */
118 #define TYPE_HASH_INITIAL_SIZE 1000
120 /* Now here is the hash table. When recording a type, it is added to
121 the slot whose index is the hash code. Note that the hash table is
122 used for several kinds of types (function types, array types and
123 array index range types, for now). While all these live in the
124 same table, they are completely independent, and the hash code is
125 computed differently for each of these. */
127 static GTY ((if_marked ("type_hash_marked_p"), param_is (struct type_hash
)))
128 htab_t type_hash_table
;
130 /* Hash table and temporary node for larger integer const values. */
131 static GTY (()) tree int_cst_node
;
132 static GTY ((if_marked ("ggc_marked_p"), param_is (union tree_node
)))
133 htab_t int_cst_hash_table
;
135 /* General tree->tree mapping structure for use in hash tables. */
138 static GTY ((if_marked ("tree_map_marked_p"), param_is (struct tree_map
)))
139 htab_t debug_expr_for_decl
;
141 static GTY ((if_marked ("tree_map_marked_p"), param_is (struct tree_map
)))
142 htab_t value_expr_for_decl
;
144 static GTY ((if_marked ("tree_int_map_marked_p"), param_is (struct tree_int_map
)))
145 htab_t init_priority_for_decl
;
147 static GTY ((if_marked ("tree_map_marked_p"), param_is (struct tree_map
)))
148 htab_t restrict_base_for_decl
;
150 struct tree_int_map
GTY(())
155 static unsigned int tree_int_map_hash (const void *);
156 static int tree_int_map_eq (const void *, const void *);
157 static int tree_int_map_marked_p (const void *);
158 static void set_type_quals (tree
, int);
159 static int type_hash_eq (const void *, const void *);
160 static hashval_t
type_hash_hash (const void *);
161 static hashval_t
int_cst_hash_hash (const void *);
162 static int int_cst_hash_eq (const void *, const void *);
163 static void print_type_hash_statistics (void);
164 static void print_debug_expr_statistics (void);
165 static void print_value_expr_statistics (void);
166 static tree
make_vector_type (tree
, int, enum machine_mode
);
167 static int type_hash_marked_p (const void *);
168 static unsigned int type_hash_list (tree
, hashval_t
);
169 static unsigned int attribute_hash_list (tree
, hashval_t
);
171 tree global_trees
[TI_MAX
];
172 tree integer_types
[itk_none
];
174 unsigned char tree_contains_struct
[256][64];
182 /* Initialize the hash table of types. */
183 type_hash_table
= htab_create_ggc (TYPE_HASH_INITIAL_SIZE
, type_hash_hash
,
186 debug_expr_for_decl
= htab_create_ggc (512, tree_map_hash
,
189 value_expr_for_decl
= htab_create_ggc (512, tree_map_hash
,
191 init_priority_for_decl
= htab_create_ggc (512, tree_int_map_hash
,
193 restrict_base_for_decl
= htab_create_ggc (256, tree_map_hash
,
196 int_cst_hash_table
= htab_create_ggc (1024, int_cst_hash_hash
,
197 int_cst_hash_eq
, NULL
);
199 int_cst_node
= make_node (INTEGER_CST
);
201 tree_contains_struct
[FUNCTION_DECL
][TS_DECL_NON_COMMON
] = 1;
202 tree_contains_struct
[TRANSLATION_UNIT_DECL
][TS_DECL_NON_COMMON
] = 1;
203 tree_contains_struct
[TYPE_DECL
][TS_DECL_NON_COMMON
] = 1;
206 tree_contains_struct
[CONST_DECL
][TS_DECL_COMMON
] = 1;
207 tree_contains_struct
[VAR_DECL
][TS_DECL_COMMON
] = 1;
208 tree_contains_struct
[PARM_DECL
][TS_DECL_COMMON
] = 1;
209 tree_contains_struct
[RESULT_DECL
][TS_DECL_COMMON
] = 1;
210 tree_contains_struct
[FUNCTION_DECL
][TS_DECL_COMMON
] = 1;
211 tree_contains_struct
[TYPE_DECL
][TS_DECL_COMMON
] = 1;
212 tree_contains_struct
[TRANSLATION_UNIT_DECL
][TS_DECL_COMMON
] = 1;
213 tree_contains_struct
[LABEL_DECL
][TS_DECL_COMMON
] = 1;
214 tree_contains_struct
[FIELD_DECL
][TS_DECL_COMMON
] = 1;
217 tree_contains_struct
[CONST_DECL
][TS_DECL_WRTL
] = 1;
218 tree_contains_struct
[VAR_DECL
][TS_DECL_WRTL
] = 1;
219 tree_contains_struct
[PARM_DECL
][TS_DECL_WRTL
] = 1;
220 tree_contains_struct
[RESULT_DECL
][TS_DECL_WRTL
] = 1;
221 tree_contains_struct
[FUNCTION_DECL
][TS_DECL_WRTL
] = 1;
222 tree_contains_struct
[LABEL_DECL
][TS_DECL_WRTL
] = 1;
224 tree_contains_struct
[CONST_DECL
][TS_DECL_MINIMAL
] = 1;
225 tree_contains_struct
[VAR_DECL
][TS_DECL_MINIMAL
] = 1;
226 tree_contains_struct
[PARM_DECL
][TS_DECL_MINIMAL
] = 1;
227 tree_contains_struct
[RESULT_DECL
][TS_DECL_MINIMAL
] = 1;
228 tree_contains_struct
[FUNCTION_DECL
][TS_DECL_MINIMAL
] = 1;
229 tree_contains_struct
[TYPE_DECL
][TS_DECL_MINIMAL
] = 1;
230 tree_contains_struct
[TRANSLATION_UNIT_DECL
][TS_DECL_MINIMAL
] = 1;
231 tree_contains_struct
[LABEL_DECL
][TS_DECL_MINIMAL
] = 1;
232 tree_contains_struct
[FIELD_DECL
][TS_DECL_MINIMAL
] = 1;
234 tree_contains_struct
[VAR_DECL
][TS_DECL_WITH_VIS
] = 1;
235 tree_contains_struct
[FUNCTION_DECL
][TS_DECL_WITH_VIS
] = 1;
236 tree_contains_struct
[TYPE_DECL
][TS_DECL_WITH_VIS
] = 1;
237 tree_contains_struct
[TRANSLATION_UNIT_DECL
][TS_DECL_WITH_VIS
] = 1;
239 tree_contains_struct
[VAR_DECL
][TS_VAR_DECL
] = 1;
240 tree_contains_struct
[FIELD_DECL
][TS_FIELD_DECL
] = 1;
241 tree_contains_struct
[PARM_DECL
][TS_PARM_DECL
] = 1;
242 tree_contains_struct
[LABEL_DECL
][TS_LABEL_DECL
] = 1;
243 tree_contains_struct
[RESULT_DECL
][TS_RESULT_DECL
] = 1;
244 tree_contains_struct
[CONST_DECL
][TS_CONST_DECL
] = 1;
245 tree_contains_struct
[TYPE_DECL
][TS_TYPE_DECL
] = 1;
246 tree_contains_struct
[FUNCTION_DECL
][TS_FUNCTION_DECL
] = 1;
248 lang_hooks
.init_ts ();
252 /* The name of the object as the assembler will see it (but before any
253 translations made by ASM_OUTPUT_LABELREF). Often this is the same
254 as DECL_NAME. It is an IDENTIFIER_NODE. */
256 decl_assembler_name (tree decl
)
258 if (!DECL_ASSEMBLER_NAME_SET_P (decl
))
259 lang_hooks
.set_decl_assembler_name (decl
);
260 return DECL_WITH_VIS_CHECK (decl
)->decl_with_vis
.assembler_name
;
263 /* Compute the number of bytes occupied by a tree with code CODE.
264 This function cannot be used for TREE_VEC, PHI_NODE, or STRING_CST
265 codes, which are of variable length. */
267 tree_code_size (enum tree_code code
)
269 switch (TREE_CODE_CLASS (code
))
271 case tcc_declaration
: /* A decl node */
276 return sizeof (struct tree_field_decl
);
278 return sizeof (struct tree_parm_decl
);
280 return sizeof (struct tree_var_decl
);
282 return sizeof (struct tree_label_decl
);
284 return sizeof (struct tree_result_decl
);
286 return sizeof (struct tree_const_decl
);
288 return sizeof (struct tree_type_decl
);
290 return sizeof (struct tree_function_decl
);
292 return sizeof (struct tree_decl_non_common
);
296 case tcc_type
: /* a type node */
297 return sizeof (struct tree_type
);
299 case tcc_reference
: /* a reference */
300 case tcc_expression
: /* an expression */
301 case tcc_statement
: /* an expression with side effects */
302 case tcc_comparison
: /* a comparison expression */
303 case tcc_unary
: /* a unary arithmetic expression */
304 case tcc_binary
: /* a binary arithmetic expression */
305 return (sizeof (struct tree_exp
)
306 + (TREE_CODE_LENGTH (code
) - 1) * sizeof (char *));
308 case tcc_constant
: /* a constant */
311 case INTEGER_CST
: return sizeof (struct tree_int_cst
);
312 case REAL_CST
: return sizeof (struct tree_real_cst
);
313 case COMPLEX_CST
: return sizeof (struct tree_complex
);
314 case VECTOR_CST
: return sizeof (struct tree_vector
);
315 case STRING_CST
: gcc_unreachable ();
317 return lang_hooks
.tree_size (code
);
320 case tcc_exceptional
: /* something random, like an identifier. */
323 case IDENTIFIER_NODE
: return lang_hooks
.identifier_size
;
324 case TREE_LIST
: return sizeof (struct tree_list
);
327 case PLACEHOLDER_EXPR
: return sizeof (struct tree_common
);
330 case PHI_NODE
: gcc_unreachable ();
332 case SSA_NAME
: return sizeof (struct tree_ssa_name
);
334 case STATEMENT_LIST
: return sizeof (struct tree_statement_list
);
335 case BLOCK
: return sizeof (struct tree_block
);
336 case VALUE_HANDLE
: return sizeof (struct tree_value_handle
);
337 case CONSTRUCTOR
: return sizeof (struct tree_constructor
);
340 return lang_hooks
.tree_size (code
);
348 /* Compute the number of bytes occupied by NODE. This routine only
349 looks at TREE_CODE, except for PHI_NODE and TREE_VEC nodes. */
351 tree_size (tree node
)
353 enum tree_code code
= TREE_CODE (node
);
357 return (sizeof (struct tree_phi_node
)
358 + (PHI_ARG_CAPACITY (node
) - 1) * sizeof (struct phi_arg_d
));
361 return (offsetof (struct tree_binfo
, base_binfos
)
362 + VEC_embedded_size (tree
, BINFO_N_BASE_BINFOS (node
)));
365 return (sizeof (struct tree_vec
)
366 + (TREE_VEC_LENGTH (node
) - 1) * sizeof(char *));
369 return sizeof (struct tree_string
) + TREE_STRING_LENGTH (node
) - 1;
372 return tree_code_size (code
);
376 /* Return a newly allocated node of code CODE. For decl and type
377 nodes, some other fields are initialized. The rest of the node is
378 initialized to zero. This function cannot be used for PHI_NODE or
379 TREE_VEC nodes, which is enforced by asserts in tree_code_size.
381 Achoo! I got a code in the node. */
384 make_node_stat (enum tree_code code MEM_STAT_DECL
)
387 enum tree_code_class type
= TREE_CODE_CLASS (code
);
388 size_t length
= tree_code_size (code
);
389 #ifdef GATHER_STATISTICS
394 case tcc_declaration
: /* A decl node */
398 case tcc_type
: /* a type node */
402 case tcc_statement
: /* an expression with side effects */
406 case tcc_reference
: /* a reference */
410 case tcc_expression
: /* an expression */
411 case tcc_comparison
: /* a comparison expression */
412 case tcc_unary
: /* a unary arithmetic expression */
413 case tcc_binary
: /* a binary arithmetic expression */
417 case tcc_constant
: /* a constant */
421 case tcc_exceptional
: /* something random, like an identifier. */
424 case IDENTIFIER_NODE
:
441 kind
= ssa_name_kind
;
462 tree_node_counts
[(int) kind
]++;
463 tree_node_sizes
[(int) kind
] += length
;
466 if (code
== IDENTIFIER_NODE
)
467 t
= ggc_alloc_zone_pass_stat (length
, &tree_id_zone
);
469 t
= ggc_alloc_zone_pass_stat (length
, &tree_zone
);
471 memset (t
, 0, length
);
473 TREE_SET_CODE (t
, code
);
478 TREE_SIDE_EFFECTS (t
) = 1;
481 case tcc_declaration
:
482 if (code
!= FUNCTION_DECL
)
484 DECL_USER_ALIGN (t
) = 0;
485 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_WITH_VIS
))
486 DECL_IN_SYSTEM_HEADER (t
) = in_system_header
;
487 /* We have not yet computed the alias set for this declaration. */
488 DECL_POINTER_ALIAS_SET (t
) = -1;
489 DECL_SOURCE_LOCATION (t
) = input_location
;
490 DECL_UID (t
) = next_decl_uid
++;
495 TYPE_UID (t
) = next_type_uid
++;
496 TYPE_ALIGN (t
) = BITS_PER_UNIT
;
497 TYPE_USER_ALIGN (t
) = 0;
498 TYPE_MAIN_VARIANT (t
) = t
;
500 /* Default to no attributes for type, but let target change that. */
501 TYPE_ATTRIBUTES (t
) = NULL_TREE
;
502 targetm
.set_default_type_attributes (t
);
504 /* We have not yet computed the alias set for this type. */
505 TYPE_ALIAS_SET (t
) = -1;
509 TREE_CONSTANT (t
) = 1;
510 TREE_INVARIANT (t
) = 1;
519 case PREDECREMENT_EXPR
:
520 case PREINCREMENT_EXPR
:
521 case POSTDECREMENT_EXPR
:
522 case POSTINCREMENT_EXPR
:
523 /* All of these have side-effects, no matter what their
525 TREE_SIDE_EFFECTS (t
) = 1;
534 /* Other classes need no special treatment. */
541 /* Return a new node with the same contents as NODE except that its
542 TREE_CHAIN is zero and it has a fresh uid. */
545 copy_node_stat (tree node MEM_STAT_DECL
)
548 enum tree_code code
= TREE_CODE (node
);
551 gcc_assert (code
!= STATEMENT_LIST
);
553 length
= tree_size (node
);
554 t
= ggc_alloc_zone_pass_stat (length
, &tree_zone
);
555 memcpy (t
, node
, length
);
558 TREE_ASM_WRITTEN (t
) = 0;
559 TREE_VISITED (t
) = 0;
562 if (TREE_CODE_CLASS (code
) == tcc_declaration
)
564 DECL_UID (t
) = next_decl_uid
++;
565 if ((TREE_CODE (node
) == PARM_DECL
|| TREE_CODE (node
) == VAR_DECL
)
566 && DECL_HAS_VALUE_EXPR_P (node
))
568 SET_DECL_VALUE_EXPR (t
, DECL_VALUE_EXPR (node
));
569 DECL_HAS_VALUE_EXPR_P (t
) = 1;
571 if (TREE_CODE (node
) == VAR_DECL
&& DECL_HAS_INIT_PRIORITY_P (node
))
573 SET_DECL_INIT_PRIORITY (t
, DECL_INIT_PRIORITY (node
));
574 DECL_HAS_INIT_PRIORITY_P (t
) = 1;
576 if (TREE_CODE (node
) == VAR_DECL
&& DECL_BASED_ON_RESTRICT_P (node
))
578 SET_DECL_RESTRICT_BASE (t
, DECL_GET_RESTRICT_BASE (node
));
579 DECL_BASED_ON_RESTRICT_P (t
) = 1;
582 else if (TREE_CODE_CLASS (code
) == tcc_type
)
584 TYPE_UID (t
) = next_type_uid
++;
585 /* The following is so that the debug code for
586 the copy is different from the original type.
587 The two statements usually duplicate each other
588 (because they clear fields of the same union),
589 but the optimizer should catch that. */
590 TYPE_SYMTAB_POINTER (t
) = 0;
591 TYPE_SYMTAB_ADDRESS (t
) = 0;
593 /* Do not copy the values cache. */
594 if (TYPE_CACHED_VALUES_P(t
))
596 TYPE_CACHED_VALUES_P (t
) = 0;
597 TYPE_CACHED_VALUES (t
) = NULL_TREE
;
604 /* Return a copy of a chain of nodes, chained through the TREE_CHAIN field.
605 For example, this can copy a list made of TREE_LIST nodes. */
608 copy_list (tree list
)
616 head
= prev
= copy_node (list
);
617 next
= TREE_CHAIN (list
);
620 TREE_CHAIN (prev
) = copy_node (next
);
621 prev
= TREE_CHAIN (prev
);
622 next
= TREE_CHAIN (next
);
628 /* Create an INT_CST node with a LOW value sign extended. */
631 build_int_cst (tree type
, HOST_WIDE_INT low
)
633 return build_int_cst_wide (type
, low
, low
< 0 ? -1 : 0);
636 /* Create an INT_CST node with a LOW value zero extended. */
639 build_int_cstu (tree type
, unsigned HOST_WIDE_INT low
)
641 return build_int_cst_wide (type
, low
, 0);
644 /* Create an INT_CST node with a LOW value in TYPE. The value is sign extended
645 if it is negative. This function is similar to build_int_cst, but
646 the extra bits outside of the type precision are cleared. Constants
647 with these extra bits may confuse the fold so that it detects overflows
648 even in cases when they do not occur, and in general should be avoided.
649 We cannot however make this a default behavior of build_int_cst without
650 more intrusive changes, since there are parts of gcc that rely on the extra
651 precision of the integer constants. */
654 build_int_cst_type (tree type
, HOST_WIDE_INT low
)
656 unsigned HOST_WIDE_INT val
= (unsigned HOST_WIDE_INT
) low
;
657 unsigned HOST_WIDE_INT hi
, mask
;
663 type
= integer_type_node
;
665 bits
= TYPE_PRECISION (type
);
666 signed_p
= !TYPE_UNSIGNED (type
);
668 if (bits
>= HOST_BITS_PER_WIDE_INT
)
669 negative
= (low
< 0);
672 /* If the sign bit is inside precision of LOW, use it to determine
673 the sign of the constant. */
674 negative
= ((val
>> (bits
- 1)) & 1) != 0;
676 /* Mask out the bits outside of the precision of the constant. */
677 mask
= (((unsigned HOST_WIDE_INT
) 2) << (bits
- 1)) - 1;
679 if (signed_p
&& negative
)
685 /* Determine the high bits. */
686 hi
= (negative
? ~(unsigned HOST_WIDE_INT
) 0 : 0);
688 /* For unsigned type we need to mask out the bits outside of the type
692 if (bits
<= HOST_BITS_PER_WIDE_INT
)
696 bits
-= HOST_BITS_PER_WIDE_INT
;
697 mask
= (((unsigned HOST_WIDE_INT
) 2) << (bits
- 1)) - 1;
702 return build_int_cst_wide (type
, val
, hi
);
705 /* These are the hash table functions for the hash table of INTEGER_CST
706 nodes of a sizetype. */
708 /* Return the hash code code X, an INTEGER_CST. */
711 int_cst_hash_hash (const void *x
)
715 return (TREE_INT_CST_HIGH (t
) ^ TREE_INT_CST_LOW (t
)
716 ^ htab_hash_pointer (TREE_TYPE (t
)));
719 /* Return nonzero if the value represented by *X (an INTEGER_CST tree node)
720 is the same as that given by *Y, which is the same. */
723 int_cst_hash_eq (const void *x
, const void *y
)
728 return (TREE_TYPE (xt
) == TREE_TYPE (yt
)
729 && TREE_INT_CST_HIGH (xt
) == TREE_INT_CST_HIGH (yt
)
730 && TREE_INT_CST_LOW (xt
) == TREE_INT_CST_LOW (yt
));
733 /* Create an INT_CST node of TYPE and value HI:LOW. If TYPE is NULL,
734 integer_type_node is used. The returned node is always shared.
735 For small integers we use a per-type vector cache, for larger ones
736 we use a single hash table. */
739 build_int_cst_wide (tree type
, unsigned HOST_WIDE_INT low
, HOST_WIDE_INT hi
)
746 type
= integer_type_node
;
748 switch (TREE_CODE (type
))
752 /* Cache NULL pointer. */
761 /* Cache false or true. */
770 if (TYPE_UNSIGNED (type
))
773 limit
= INTEGER_SHARE_LIMIT
;
774 if (!hi
&& low
< (unsigned HOST_WIDE_INT
)INTEGER_SHARE_LIMIT
)
780 limit
= INTEGER_SHARE_LIMIT
+ 1;
781 if (!hi
&& low
< (unsigned HOST_WIDE_INT
)INTEGER_SHARE_LIMIT
)
783 else if (hi
== -1 && low
== -(unsigned HOST_WIDE_INT
)1)
793 /* Look for it in the type's vector of small shared ints. */
794 if (!TYPE_CACHED_VALUES_P (type
))
796 TYPE_CACHED_VALUES_P (type
) = 1;
797 TYPE_CACHED_VALUES (type
) = make_tree_vec (limit
);
800 t
= TREE_VEC_ELT (TYPE_CACHED_VALUES (type
), ix
);
803 /* Make sure no one is clobbering the shared constant. */
804 gcc_assert (TREE_TYPE (t
) == type
);
805 gcc_assert (TREE_INT_CST_LOW (t
) == low
);
806 gcc_assert (TREE_INT_CST_HIGH (t
) == hi
);
810 /* Create a new shared int. */
811 t
= make_node (INTEGER_CST
);
813 TREE_INT_CST_LOW (t
) = low
;
814 TREE_INT_CST_HIGH (t
) = hi
;
815 TREE_TYPE (t
) = type
;
817 TREE_VEC_ELT (TYPE_CACHED_VALUES (type
), ix
) = t
;
822 /* Use the cache of larger shared ints. */
825 TREE_INT_CST_LOW (int_cst_node
) = low
;
826 TREE_INT_CST_HIGH (int_cst_node
) = hi
;
827 TREE_TYPE (int_cst_node
) = type
;
829 slot
= htab_find_slot (int_cst_hash_table
, int_cst_node
, INSERT
);
833 /* Insert this one into the hash table. */
836 /* Make a new node for next time round. */
837 int_cst_node
= make_node (INTEGER_CST
);
844 /* Builds an integer constant in TYPE such that lowest BITS bits are ones
845 and the rest are zeros. */
848 build_low_bits_mask (tree type
, unsigned bits
)
850 unsigned HOST_WIDE_INT low
;
852 unsigned HOST_WIDE_INT all_ones
= ~(unsigned HOST_WIDE_INT
) 0;
854 gcc_assert (bits
<= TYPE_PRECISION (type
));
856 if (bits
== TYPE_PRECISION (type
)
857 && !TYPE_UNSIGNED (type
))
859 /* Sign extended all-ones mask. */
863 else if (bits
<= HOST_BITS_PER_WIDE_INT
)
865 low
= all_ones
>> (HOST_BITS_PER_WIDE_INT
- bits
);
870 bits
-= HOST_BITS_PER_WIDE_INT
;
872 high
= all_ones
>> (HOST_BITS_PER_WIDE_INT
- bits
);
875 return build_int_cst_wide (type
, low
, high
);
878 /* Checks that X is integer constant that can be expressed in (unsigned)
879 HOST_WIDE_INT without loss of precision. */
882 cst_and_fits_in_hwi (tree x
)
884 if (TREE_CODE (x
) != INTEGER_CST
)
887 if (TYPE_PRECISION (TREE_TYPE (x
)) > HOST_BITS_PER_WIDE_INT
)
890 return (TREE_INT_CST_HIGH (x
) == 0
891 || TREE_INT_CST_HIGH (x
) == -1);
894 /* Return a new VECTOR_CST node whose type is TYPE and whose values
895 are in a list pointed to by VALS. */
898 build_vector (tree type
, tree vals
)
900 tree v
= make_node (VECTOR_CST
);
901 int over1
= 0, over2
= 0;
904 TREE_VECTOR_CST_ELTS (v
) = vals
;
905 TREE_TYPE (v
) = type
;
907 /* Iterate through elements and check for overflow. */
908 for (link
= vals
; link
; link
= TREE_CHAIN (link
))
910 tree value
= TREE_VALUE (link
);
912 over1
|= TREE_OVERFLOW (value
);
913 over2
|= TREE_CONSTANT_OVERFLOW (value
);
916 TREE_OVERFLOW (v
) = over1
;
917 TREE_CONSTANT_OVERFLOW (v
) = over2
;
922 /* Return a new VECTOR_CST node whose type is TYPE and whose values
923 are extracted from V, a vector of CONSTRUCTOR_ELT. */
926 build_vector_from_ctor (tree type
, VEC(constructor_elt
,gc
) *v
)
928 tree list
= NULL_TREE
;
929 unsigned HOST_WIDE_INT idx
;
932 FOR_EACH_CONSTRUCTOR_VALUE (v
, idx
, value
)
933 list
= tree_cons (NULL_TREE
, value
, list
);
934 return build_vector (type
, nreverse (list
));
937 /* Return a new CONSTRUCTOR node whose type is TYPE and whose values
938 are in the VEC pointed to by VALS. */
940 build_constructor (tree type
, VEC(constructor_elt
,gc
) *vals
)
942 tree c
= make_node (CONSTRUCTOR
);
943 TREE_TYPE (c
) = type
;
944 CONSTRUCTOR_ELTS (c
) = vals
;
948 /* Build a CONSTRUCTOR node made of a single initializer, with the specified
951 build_constructor_single (tree type
, tree index
, tree value
)
953 VEC(constructor_elt
,gc
) *v
;
954 constructor_elt
*elt
;
956 v
= VEC_alloc (constructor_elt
, gc
, 1);
957 elt
= VEC_quick_push (constructor_elt
, v
, NULL
);
961 return build_constructor (type
, v
);
965 /* Return a new CONSTRUCTOR node whose type is TYPE and whose values
966 are in a list pointed to by VALS. */
968 build_constructor_from_list (tree type
, tree vals
)
971 VEC(constructor_elt
,gc
) *v
= NULL
;
975 v
= VEC_alloc (constructor_elt
, gc
, list_length (vals
));
976 for (t
= vals
; t
; t
= TREE_CHAIN (t
))
978 constructor_elt
*elt
= VEC_quick_push (constructor_elt
, v
, NULL
);
979 elt
->index
= TREE_PURPOSE (t
);
980 elt
->value
= TREE_VALUE (t
);
984 return build_constructor (type
, v
);
988 /* Return a new REAL_CST node whose type is TYPE and value is D. */
991 build_real (tree type
, REAL_VALUE_TYPE d
)
997 /* ??? Used to check for overflow here via CHECK_FLOAT_TYPE.
998 Consider doing it via real_convert now. */
1000 v
= make_node (REAL_CST
);
1001 dp
= ggc_alloc (sizeof (REAL_VALUE_TYPE
));
1002 memcpy (dp
, &d
, sizeof (REAL_VALUE_TYPE
));
1004 TREE_TYPE (v
) = type
;
1005 TREE_REAL_CST_PTR (v
) = dp
;
1006 TREE_OVERFLOW (v
) = TREE_CONSTANT_OVERFLOW (v
) = overflow
;
1010 /* Return a new REAL_CST node whose type is TYPE
1011 and whose value is the integer value of the INTEGER_CST node I. */
1014 real_value_from_int_cst (tree type
, tree i
)
1018 /* Clear all bits of the real value type so that we can later do
1019 bitwise comparisons to see if two values are the same. */
1020 memset (&d
, 0, sizeof d
);
1022 real_from_integer (&d
, type
? TYPE_MODE (type
) : VOIDmode
,
1023 TREE_INT_CST_LOW (i
), TREE_INT_CST_HIGH (i
),
1024 TYPE_UNSIGNED (TREE_TYPE (i
)));
1028 /* Given a tree representing an integer constant I, return a tree
1029 representing the same value as a floating-point constant of type TYPE. */
1032 build_real_from_int_cst (tree type
, tree i
)
1035 int overflow
= TREE_OVERFLOW (i
);
1037 v
= build_real (type
, real_value_from_int_cst (type
, i
));
1039 TREE_OVERFLOW (v
) |= overflow
;
1040 TREE_CONSTANT_OVERFLOW (v
) |= overflow
;
1044 /* Return a newly constructed STRING_CST node whose value is
1045 the LEN characters at STR.
1046 The TREE_TYPE is not initialized. */
1049 build_string (int len
, const char *str
)
1054 length
= len
+ sizeof (struct tree_string
);
1056 #ifdef GATHER_STATISTICS
1057 tree_node_counts
[(int) c_kind
]++;
1058 tree_node_sizes
[(int) c_kind
] += length
;
1061 s
= ggc_alloc_tree (length
);
1063 memset (s
, 0, sizeof (struct tree_common
));
1064 TREE_SET_CODE (s
, STRING_CST
);
1065 TREE_CONSTANT (s
) = 1;
1066 TREE_INVARIANT (s
) = 1;
1067 TREE_STRING_LENGTH (s
) = len
;
1068 memcpy ((char *) TREE_STRING_POINTER (s
), str
, len
);
1069 ((char *) TREE_STRING_POINTER (s
))[len
] = '\0';
1074 /* Return a newly constructed COMPLEX_CST node whose value is
1075 specified by the real and imaginary parts REAL and IMAG.
1076 Both REAL and IMAG should be constant nodes. TYPE, if specified,
1077 will be the type of the COMPLEX_CST; otherwise a new type will be made. */
1080 build_complex (tree type
, tree real
, tree imag
)
1082 tree t
= make_node (COMPLEX_CST
);
1084 TREE_REALPART (t
) = real
;
1085 TREE_IMAGPART (t
) = imag
;
1086 TREE_TYPE (t
) = type
? type
: build_complex_type (TREE_TYPE (real
));
1087 TREE_OVERFLOW (t
) = TREE_OVERFLOW (real
) | TREE_OVERFLOW (imag
);
1088 TREE_CONSTANT_OVERFLOW (t
)
1089 = TREE_CONSTANT_OVERFLOW (real
) | TREE_CONSTANT_OVERFLOW (imag
);
1093 /* Build a BINFO with LEN language slots. */
1096 make_tree_binfo_stat (unsigned base_binfos MEM_STAT_DECL
)
1099 size_t length
= (offsetof (struct tree_binfo
, base_binfos
)
1100 + VEC_embedded_size (tree
, base_binfos
));
1102 #ifdef GATHER_STATISTICS
1103 tree_node_counts
[(int) binfo_kind
]++;
1104 tree_node_sizes
[(int) binfo_kind
] += length
;
1107 t
= ggc_alloc_zone_pass_stat (length
, &tree_zone
);
1109 memset (t
, 0, offsetof (struct tree_binfo
, base_binfos
));
1111 TREE_SET_CODE (t
, TREE_BINFO
);
1113 VEC_embedded_init (tree
, BINFO_BASE_BINFOS (t
), base_binfos
);
1119 /* Build a newly constructed TREE_VEC node of length LEN. */
1122 make_tree_vec_stat (int len MEM_STAT_DECL
)
1125 int length
= (len
- 1) * sizeof (tree
) + sizeof (struct tree_vec
);
1127 #ifdef GATHER_STATISTICS
1128 tree_node_counts
[(int) vec_kind
]++;
1129 tree_node_sizes
[(int) vec_kind
] += length
;
1132 t
= ggc_alloc_zone_pass_stat (length
, &tree_zone
);
1134 memset (t
, 0, length
);
1136 TREE_SET_CODE (t
, TREE_VEC
);
1137 TREE_VEC_LENGTH (t
) = len
;
1142 /* Return 1 if EXPR is the integer constant zero or a complex constant
1146 integer_zerop (tree expr
)
1150 return ((TREE_CODE (expr
) == INTEGER_CST
1151 && ! TREE_CONSTANT_OVERFLOW (expr
)
1152 && TREE_INT_CST_LOW (expr
) == 0
1153 && TREE_INT_CST_HIGH (expr
) == 0)
1154 || (TREE_CODE (expr
) == COMPLEX_CST
1155 && integer_zerop (TREE_REALPART (expr
))
1156 && integer_zerop (TREE_IMAGPART (expr
))));
1159 /* Return 1 if EXPR is the integer constant one or the corresponding
1160 complex constant. */
1163 integer_onep (tree expr
)
1167 return ((TREE_CODE (expr
) == INTEGER_CST
1168 && ! TREE_CONSTANT_OVERFLOW (expr
)
1169 && TREE_INT_CST_LOW (expr
) == 1
1170 && TREE_INT_CST_HIGH (expr
) == 0)
1171 || (TREE_CODE (expr
) == COMPLEX_CST
1172 && integer_onep (TREE_REALPART (expr
))
1173 && integer_zerop (TREE_IMAGPART (expr
))));
1176 /* Return 1 if EXPR is an integer containing all 1's in as much precision as
1177 it contains. Likewise for the corresponding complex constant. */
1180 integer_all_onesp (tree expr
)
1187 if (TREE_CODE (expr
) == COMPLEX_CST
1188 && integer_all_onesp (TREE_REALPART (expr
))
1189 && integer_zerop (TREE_IMAGPART (expr
)))
1192 else if (TREE_CODE (expr
) != INTEGER_CST
1193 || TREE_CONSTANT_OVERFLOW (expr
))
1196 uns
= TYPE_UNSIGNED (TREE_TYPE (expr
));
1198 return (TREE_INT_CST_LOW (expr
) == ~(unsigned HOST_WIDE_INT
) 0
1199 && TREE_INT_CST_HIGH (expr
) == -1);
1201 /* Note that using TYPE_PRECISION here is wrong. We care about the
1202 actual bits, not the (arbitrary) range of the type. */
1203 prec
= GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (expr
)));
1204 if (prec
>= HOST_BITS_PER_WIDE_INT
)
1206 HOST_WIDE_INT high_value
;
1209 shift_amount
= prec
- HOST_BITS_PER_WIDE_INT
;
1211 /* Can not handle precisions greater than twice the host int size. */
1212 gcc_assert (shift_amount
<= HOST_BITS_PER_WIDE_INT
);
1213 if (shift_amount
== HOST_BITS_PER_WIDE_INT
)
1214 /* Shifting by the host word size is undefined according to the ANSI
1215 standard, so we must handle this as a special case. */
1218 high_value
= ((HOST_WIDE_INT
) 1 << shift_amount
) - 1;
1220 return (TREE_INT_CST_LOW (expr
) == ~(unsigned HOST_WIDE_INT
) 0
1221 && TREE_INT_CST_HIGH (expr
) == high_value
);
1224 return TREE_INT_CST_LOW (expr
) == ((unsigned HOST_WIDE_INT
) 1 << prec
) - 1;
1227 /* Return 1 if EXPR is an integer constant that is a power of 2 (i.e., has only
1231 integer_pow2p (tree expr
)
1234 HOST_WIDE_INT high
, low
;
1238 if (TREE_CODE (expr
) == COMPLEX_CST
1239 && integer_pow2p (TREE_REALPART (expr
))
1240 && integer_zerop (TREE_IMAGPART (expr
)))
1243 if (TREE_CODE (expr
) != INTEGER_CST
|| TREE_CONSTANT_OVERFLOW (expr
))
1246 prec
= (POINTER_TYPE_P (TREE_TYPE (expr
))
1247 ? POINTER_SIZE
: TYPE_PRECISION (TREE_TYPE (expr
)));
1248 high
= TREE_INT_CST_HIGH (expr
);
1249 low
= TREE_INT_CST_LOW (expr
);
1251 /* First clear all bits that are beyond the type's precision in case
1252 we've been sign extended. */
1254 if (prec
== 2 * HOST_BITS_PER_WIDE_INT
)
1256 else if (prec
> HOST_BITS_PER_WIDE_INT
)
1257 high
&= ~((HOST_WIDE_INT
) (-1) << (prec
- HOST_BITS_PER_WIDE_INT
));
1261 if (prec
< HOST_BITS_PER_WIDE_INT
)
1262 low
&= ~((HOST_WIDE_INT
) (-1) << prec
);
1265 if (high
== 0 && low
== 0)
1268 return ((high
== 0 && (low
& (low
- 1)) == 0)
1269 || (low
== 0 && (high
& (high
- 1)) == 0));
1272 /* Return 1 if EXPR is an integer constant other than zero or a
1273 complex constant other than zero. */
1276 integer_nonzerop (tree expr
)
1280 return ((TREE_CODE (expr
) == INTEGER_CST
1281 && ! TREE_CONSTANT_OVERFLOW (expr
)
1282 && (TREE_INT_CST_LOW (expr
) != 0
1283 || TREE_INT_CST_HIGH (expr
) != 0))
1284 || (TREE_CODE (expr
) == COMPLEX_CST
1285 && (integer_nonzerop (TREE_REALPART (expr
))
1286 || integer_nonzerop (TREE_IMAGPART (expr
)))));
1289 /* Return the power of two represented by a tree node known to be a
1293 tree_log2 (tree expr
)
1296 HOST_WIDE_INT high
, low
;
1300 if (TREE_CODE (expr
) == COMPLEX_CST
)
1301 return tree_log2 (TREE_REALPART (expr
));
1303 prec
= (POINTER_TYPE_P (TREE_TYPE (expr
))
1304 ? POINTER_SIZE
: TYPE_PRECISION (TREE_TYPE (expr
)));
1306 high
= TREE_INT_CST_HIGH (expr
);
1307 low
= TREE_INT_CST_LOW (expr
);
1309 /* First clear all bits that are beyond the type's precision in case
1310 we've been sign extended. */
1312 if (prec
== 2 * HOST_BITS_PER_WIDE_INT
)
1314 else if (prec
> HOST_BITS_PER_WIDE_INT
)
1315 high
&= ~((HOST_WIDE_INT
) (-1) << (prec
- HOST_BITS_PER_WIDE_INT
));
1319 if (prec
< HOST_BITS_PER_WIDE_INT
)
1320 low
&= ~((HOST_WIDE_INT
) (-1) << prec
);
1323 return (high
!= 0 ? HOST_BITS_PER_WIDE_INT
+ exact_log2 (high
)
1324 : exact_log2 (low
));
1327 /* Similar, but return the largest integer Y such that 2 ** Y is less
1328 than or equal to EXPR. */
1331 tree_floor_log2 (tree expr
)
1334 HOST_WIDE_INT high
, low
;
1338 if (TREE_CODE (expr
) == COMPLEX_CST
)
1339 return tree_log2 (TREE_REALPART (expr
));
1341 prec
= (POINTER_TYPE_P (TREE_TYPE (expr
))
1342 ? POINTER_SIZE
: TYPE_PRECISION (TREE_TYPE (expr
)));
1344 high
= TREE_INT_CST_HIGH (expr
);
1345 low
= TREE_INT_CST_LOW (expr
);
1347 /* First clear all bits that are beyond the type's precision in case
1348 we've been sign extended. Ignore if type's precision hasn't been set
1349 since what we are doing is setting it. */
1351 if (prec
== 2 * HOST_BITS_PER_WIDE_INT
|| prec
== 0)
1353 else if (prec
> HOST_BITS_PER_WIDE_INT
)
1354 high
&= ~((HOST_WIDE_INT
) (-1) << (prec
- HOST_BITS_PER_WIDE_INT
));
1358 if (prec
< HOST_BITS_PER_WIDE_INT
)
1359 low
&= ~((HOST_WIDE_INT
) (-1) << prec
);
1362 return (high
!= 0 ? HOST_BITS_PER_WIDE_INT
+ floor_log2 (high
)
1363 : floor_log2 (low
));
1366 /* Return 1 if EXPR is the real constant zero. */
1369 real_zerop (tree expr
)
1373 return ((TREE_CODE (expr
) == REAL_CST
1374 && ! TREE_CONSTANT_OVERFLOW (expr
)
1375 && REAL_VALUES_EQUAL (TREE_REAL_CST (expr
), dconst0
))
1376 || (TREE_CODE (expr
) == COMPLEX_CST
1377 && real_zerop (TREE_REALPART (expr
))
1378 && real_zerop (TREE_IMAGPART (expr
))));
1381 /* Return 1 if EXPR is the real constant one in real or complex form. */
1384 real_onep (tree expr
)
1388 return ((TREE_CODE (expr
) == REAL_CST
1389 && ! TREE_CONSTANT_OVERFLOW (expr
)
1390 && REAL_VALUES_EQUAL (TREE_REAL_CST (expr
), dconst1
))
1391 || (TREE_CODE (expr
) == COMPLEX_CST
1392 && real_onep (TREE_REALPART (expr
))
1393 && real_zerop (TREE_IMAGPART (expr
))));
1396 /* Return 1 if EXPR is the real constant two. */
1399 real_twop (tree expr
)
1403 return ((TREE_CODE (expr
) == REAL_CST
1404 && ! TREE_CONSTANT_OVERFLOW (expr
)
1405 && REAL_VALUES_EQUAL (TREE_REAL_CST (expr
), dconst2
))
1406 || (TREE_CODE (expr
) == COMPLEX_CST
1407 && real_twop (TREE_REALPART (expr
))
1408 && real_zerop (TREE_IMAGPART (expr
))));
1411 /* Return 1 if EXPR is the real constant minus one. */
1414 real_minus_onep (tree expr
)
1418 return ((TREE_CODE (expr
) == REAL_CST
1419 && ! TREE_CONSTANT_OVERFLOW (expr
)
1420 && REAL_VALUES_EQUAL (TREE_REAL_CST (expr
), dconstm1
))
1421 || (TREE_CODE (expr
) == COMPLEX_CST
1422 && real_minus_onep (TREE_REALPART (expr
))
1423 && real_zerop (TREE_IMAGPART (expr
))));
1426 /* Nonzero if EXP is a constant or a cast of a constant. */
1429 really_constant_p (tree exp
)
1431 /* This is not quite the same as STRIP_NOPS. It does more. */
1432 while (TREE_CODE (exp
) == NOP_EXPR
1433 || TREE_CODE (exp
) == CONVERT_EXPR
1434 || TREE_CODE (exp
) == NON_LVALUE_EXPR
)
1435 exp
= TREE_OPERAND (exp
, 0);
1436 return TREE_CONSTANT (exp
);
1439 /* Return first list element whose TREE_VALUE is ELEM.
1440 Return 0 if ELEM is not in LIST. */
1443 value_member (tree elem
, tree list
)
1447 if (elem
== TREE_VALUE (list
))
1449 list
= TREE_CHAIN (list
);
1454 /* Return first list element whose TREE_PURPOSE is ELEM.
1455 Return 0 if ELEM is not in LIST. */
1458 purpose_member (tree elem
, tree list
)
1462 if (elem
== TREE_PURPOSE (list
))
1464 list
= TREE_CHAIN (list
);
1469 /* Return nonzero if ELEM is part of the chain CHAIN. */
1472 chain_member (tree elem
, tree chain
)
1478 chain
= TREE_CHAIN (chain
);
1484 /* Return the length of a chain of nodes chained through TREE_CHAIN.
1485 We expect a null pointer to mark the end of the chain.
1486 This is the Lisp primitive `length'. */
1489 list_length (tree t
)
1492 #ifdef ENABLE_TREE_CHECKING
1500 #ifdef ENABLE_TREE_CHECKING
1503 gcc_assert (p
!= q
);
1511 /* Returns the number of FIELD_DECLs in TYPE. */
1514 fields_length (tree type
)
1516 tree t
= TYPE_FIELDS (type
);
1519 for (; t
; t
= TREE_CHAIN (t
))
1520 if (TREE_CODE (t
) == FIELD_DECL
)
1526 /* Concatenate two chains of nodes (chained through TREE_CHAIN)
1527 by modifying the last node in chain 1 to point to chain 2.
1528 This is the Lisp primitive `nconc'. */
1531 chainon (tree op1
, tree op2
)
1540 for (t1
= op1
; TREE_CHAIN (t1
); t1
= TREE_CHAIN (t1
))
1542 TREE_CHAIN (t1
) = op2
;
1544 #ifdef ENABLE_TREE_CHECKING
1547 for (t2
= op2
; t2
; t2
= TREE_CHAIN (t2
))
1548 gcc_assert (t2
!= t1
);
1555 /* Return the last node in a chain of nodes (chained through TREE_CHAIN). */
1558 tree_last (tree chain
)
1562 while ((next
= TREE_CHAIN (chain
)))
1567 /* Reverse the order of elements in the chain T,
1568 and return the new head of the chain (old last element). */
1573 tree prev
= 0, decl
, next
;
1574 for (decl
= t
; decl
; decl
= next
)
1576 next
= TREE_CHAIN (decl
);
1577 TREE_CHAIN (decl
) = prev
;
1583 /* Return a newly created TREE_LIST node whose
1584 purpose and value fields are PARM and VALUE. */
1587 build_tree_list_stat (tree parm
, tree value MEM_STAT_DECL
)
1589 tree t
= make_node_stat (TREE_LIST PASS_MEM_STAT
);
1590 TREE_PURPOSE (t
) = parm
;
1591 TREE_VALUE (t
) = value
;
1595 /* Return a newly created TREE_LIST node whose
1596 purpose and value fields are PURPOSE and VALUE
1597 and whose TREE_CHAIN is CHAIN. */
1600 tree_cons_stat (tree purpose
, tree value
, tree chain MEM_STAT_DECL
)
1604 node
= ggc_alloc_zone_pass_stat (sizeof (struct tree_list
), &tree_zone
);
1606 memset (node
, 0, sizeof (struct tree_common
));
1608 #ifdef GATHER_STATISTICS
1609 tree_node_counts
[(int) x_kind
]++;
1610 tree_node_sizes
[(int) x_kind
] += sizeof (struct tree_list
);
1613 TREE_SET_CODE (node
, TREE_LIST
);
1614 TREE_CHAIN (node
) = chain
;
1615 TREE_PURPOSE (node
) = purpose
;
1616 TREE_VALUE (node
) = value
;
1621 /* Return the size nominally occupied by an object of type TYPE
1622 when it resides in memory. The value is measured in units of bytes,
1623 and its data type is that normally used for type sizes
1624 (which is the first type created by make_signed_type or
1625 make_unsigned_type). */
1628 size_in_bytes (tree type
)
1632 if (type
== error_mark_node
)
1633 return integer_zero_node
;
1635 type
= TYPE_MAIN_VARIANT (type
);
1636 t
= TYPE_SIZE_UNIT (type
);
1640 lang_hooks
.types
.incomplete_type_error (NULL_TREE
, type
);
1641 return size_zero_node
;
1644 if (TREE_CODE (t
) == INTEGER_CST
)
1645 t
= force_fit_type (t
, 0, false, false);
1650 /* Return the size of TYPE (in bytes) as a wide integer
1651 or return -1 if the size can vary or is larger than an integer. */
1654 int_size_in_bytes (tree type
)
1658 if (type
== error_mark_node
)
1661 type
= TYPE_MAIN_VARIANT (type
);
1662 t
= TYPE_SIZE_UNIT (type
);
1664 || TREE_CODE (t
) != INTEGER_CST
1665 || TREE_OVERFLOW (t
)
1666 || TREE_INT_CST_HIGH (t
) != 0
1667 /* If the result would appear negative, it's too big to represent. */
1668 || (HOST_WIDE_INT
) TREE_INT_CST_LOW (t
) < 0)
1671 return TREE_INT_CST_LOW (t
);
1674 /* Return the bit position of FIELD, in bits from the start of the record.
1675 This is a tree of type bitsizetype. */
1678 bit_position (tree field
)
1680 return bit_from_pos (DECL_FIELD_OFFSET (field
),
1681 DECL_FIELD_BIT_OFFSET (field
));
1684 /* Likewise, but return as an integer. It must be representable in
1685 that way (since it could be a signed value, we don't have the
1686 option of returning -1 like int_size_in_byte can. */
1689 int_bit_position (tree field
)
1691 return tree_low_cst (bit_position (field
), 0);
1694 /* Return the byte position of FIELD, in bytes from the start of the record.
1695 This is a tree of type sizetype. */
1698 byte_position (tree field
)
1700 return byte_from_pos (DECL_FIELD_OFFSET (field
),
1701 DECL_FIELD_BIT_OFFSET (field
));
1704 /* Likewise, but return as an integer. It must be representable in
1705 that way (since it could be a signed value, we don't have the
1706 option of returning -1 like int_size_in_byte can. */
1709 int_byte_position (tree field
)
1711 return tree_low_cst (byte_position (field
), 0);
1714 /* Return the strictest alignment, in bits, that T is known to have. */
1719 unsigned int align0
, align1
;
1721 switch (TREE_CODE (t
))
1723 case NOP_EXPR
: case CONVERT_EXPR
: case NON_LVALUE_EXPR
:
1724 /* If we have conversions, we know that the alignment of the
1725 object must meet each of the alignments of the types. */
1726 align0
= expr_align (TREE_OPERAND (t
, 0));
1727 align1
= TYPE_ALIGN (TREE_TYPE (t
));
1728 return MAX (align0
, align1
);
1730 case SAVE_EXPR
: case COMPOUND_EXPR
: case MODIFY_EXPR
:
1731 case INIT_EXPR
: case TARGET_EXPR
: case WITH_CLEANUP_EXPR
:
1732 case CLEANUP_POINT_EXPR
:
1733 /* These don't change the alignment of an object. */
1734 return expr_align (TREE_OPERAND (t
, 0));
1737 /* The best we can do is say that the alignment is the least aligned
1739 align0
= expr_align (TREE_OPERAND (t
, 1));
1740 align1
= expr_align (TREE_OPERAND (t
, 2));
1741 return MIN (align0
, align1
);
1743 case LABEL_DECL
: case CONST_DECL
:
1744 case VAR_DECL
: case PARM_DECL
: case RESULT_DECL
:
1745 if (DECL_ALIGN (t
) != 0)
1746 return DECL_ALIGN (t
);
1750 return FUNCTION_BOUNDARY
;
1756 /* Otherwise take the alignment from that of the type. */
1757 return TYPE_ALIGN (TREE_TYPE (t
));
1760 /* Return, as a tree node, the number of elements for TYPE (which is an
1761 ARRAY_TYPE) minus one. This counts only elements of the top array. */
1764 array_type_nelts (tree type
)
1766 tree index_type
, min
, max
;
1768 /* If they did it with unspecified bounds, then we should have already
1769 given an error about it before we got here. */
1770 if (! TYPE_DOMAIN (type
))
1771 return error_mark_node
;
1773 index_type
= TYPE_DOMAIN (type
);
1774 min
= TYPE_MIN_VALUE (index_type
);
1775 max
= TYPE_MAX_VALUE (index_type
);
1777 return (integer_zerop (min
)
1779 : fold_build2 (MINUS_EXPR
, TREE_TYPE (max
), max
, min
));
1782 /* If arg is static -- a reference to an object in static storage -- then
1783 return the object. This is not the same as the C meaning of `static'.
1784 If arg isn't static, return NULL. */
1789 switch (TREE_CODE (arg
))
1792 /* Nested functions are static, even though taking their address will
1793 involve a trampoline as we unnest the nested function and create
1794 the trampoline on the tree level. */
1798 return ((TREE_STATIC (arg
) || DECL_EXTERNAL (arg
))
1799 && ! DECL_THREAD_LOCAL_P (arg
)
1800 && ! DECL_NON_ADDR_CONST_P (arg
)
1804 return ((TREE_STATIC (arg
) || DECL_EXTERNAL (arg
))
1808 return TREE_STATIC (arg
) ? arg
: NULL
;
1815 /* If the thing being referenced is not a field, then it is
1816 something language specific. */
1817 if (TREE_CODE (TREE_OPERAND (arg
, 1)) != FIELD_DECL
)
1818 return (*lang_hooks
.staticp
) (arg
);
1820 /* If we are referencing a bitfield, we can't evaluate an
1821 ADDR_EXPR at compile time and so it isn't a constant. */
1822 if (DECL_BIT_FIELD (TREE_OPERAND (arg
, 1)))
1825 return staticp (TREE_OPERAND (arg
, 0));
1830 case MISALIGNED_INDIRECT_REF
:
1831 case ALIGN_INDIRECT_REF
:
1833 return TREE_CONSTANT (TREE_OPERAND (arg
, 0)) ? arg
: NULL
;
1836 case ARRAY_RANGE_REF
:
1837 if (TREE_CODE (TYPE_SIZE (TREE_TYPE (arg
))) == INTEGER_CST
1838 && TREE_CODE (TREE_OPERAND (arg
, 1)) == INTEGER_CST
)
1839 return staticp (TREE_OPERAND (arg
, 0));
1844 if ((unsigned int) TREE_CODE (arg
)
1845 >= (unsigned int) LAST_AND_UNUSED_TREE_CODE
)
1846 return lang_hooks
.staticp (arg
);
1852 /* Wrap a SAVE_EXPR around EXPR, if appropriate.
1853 Do this to any expression which may be used in more than one place,
1854 but must be evaluated only once.
1856 Normally, expand_expr would reevaluate the expression each time.
1857 Calling save_expr produces something that is evaluated and recorded
1858 the first time expand_expr is called on it. Subsequent calls to
1859 expand_expr just reuse the recorded value.
1861 The call to expand_expr that generates code that actually computes
1862 the value is the first call *at compile time*. Subsequent calls
1863 *at compile time* generate code to use the saved value.
1864 This produces correct result provided that *at run time* control
1865 always flows through the insns made by the first expand_expr
1866 before reaching the other places where the save_expr was evaluated.
1867 You, the caller of save_expr, must make sure this is so.
1869 Constants, and certain read-only nodes, are returned with no
1870 SAVE_EXPR because that is safe. Expressions containing placeholders
1871 are not touched; see tree.def for an explanation of what these
1875 save_expr (tree expr
)
1877 tree t
= fold (expr
);
1880 /* If the tree evaluates to a constant, then we don't want to hide that
1881 fact (i.e. this allows further folding, and direct checks for constants).
1882 However, a read-only object that has side effects cannot be bypassed.
1883 Since it is no problem to reevaluate literals, we just return the
1885 inner
= skip_simple_arithmetic (t
);
1887 if (TREE_INVARIANT (inner
)
1888 || (TREE_READONLY (inner
) && ! TREE_SIDE_EFFECTS (inner
))
1889 || TREE_CODE (inner
) == SAVE_EXPR
1890 || TREE_CODE (inner
) == ERROR_MARK
)
1893 /* If INNER contains a PLACEHOLDER_EXPR, we must evaluate it each time, since
1894 it means that the size or offset of some field of an object depends on
1895 the value within another field.
1897 Note that it must not be the case that T contains both a PLACEHOLDER_EXPR
1898 and some variable since it would then need to be both evaluated once and
1899 evaluated more than once. Front-ends must assure this case cannot
1900 happen by surrounding any such subexpressions in their own SAVE_EXPR
1901 and forcing evaluation at the proper time. */
1902 if (contains_placeholder_p (inner
))
1905 t
= build1 (SAVE_EXPR
, TREE_TYPE (expr
), t
);
1907 /* This expression might be placed ahead of a jump to ensure that the
1908 value was computed on both sides of the jump. So make sure it isn't
1909 eliminated as dead. */
1910 TREE_SIDE_EFFECTS (t
) = 1;
1911 TREE_INVARIANT (t
) = 1;
1915 /* Look inside EXPR and into any simple arithmetic operations. Return
1916 the innermost non-arithmetic node. */
1919 skip_simple_arithmetic (tree expr
)
1923 /* We don't care about whether this can be used as an lvalue in this
1925 while (TREE_CODE (expr
) == NON_LVALUE_EXPR
)
1926 expr
= TREE_OPERAND (expr
, 0);
1928 /* If we have simple operations applied to a SAVE_EXPR or to a SAVE_EXPR and
1929 a constant, it will be more efficient to not make another SAVE_EXPR since
1930 it will allow better simplification and GCSE will be able to merge the
1931 computations if they actually occur. */
1935 if (UNARY_CLASS_P (inner
))
1936 inner
= TREE_OPERAND (inner
, 0);
1937 else if (BINARY_CLASS_P (inner
))
1939 if (TREE_INVARIANT (TREE_OPERAND (inner
, 1)))
1940 inner
= TREE_OPERAND (inner
, 0);
1941 else if (TREE_INVARIANT (TREE_OPERAND (inner
, 0)))
1942 inner
= TREE_OPERAND (inner
, 1);
1953 /* Return which tree structure is used by T. */
1955 enum tree_node_structure_enum
1956 tree_node_structure (tree t
)
1958 enum tree_code code
= TREE_CODE (t
);
1960 switch (TREE_CODE_CLASS (code
))
1962 case tcc_declaration
:
1967 return TS_FIELD_DECL
;
1969 return TS_PARM_DECL
;
1973 return TS_LABEL_DECL
;
1975 return TS_RESULT_DECL
;
1977 return TS_CONST_DECL
;
1979 return TS_TYPE_DECL
;
1981 return TS_FUNCTION_DECL
;
1983 return TS_DECL_NON_COMMON
;
1989 case tcc_comparison
:
1992 case tcc_expression
:
1995 default: /* tcc_constant and tcc_exceptional */
2000 /* tcc_constant cases. */
2001 case INTEGER_CST
: return TS_INT_CST
;
2002 case REAL_CST
: return TS_REAL_CST
;
2003 case COMPLEX_CST
: return TS_COMPLEX
;
2004 case VECTOR_CST
: return TS_VECTOR
;
2005 case STRING_CST
: return TS_STRING
;
2006 /* tcc_exceptional cases. */
2007 case ERROR_MARK
: return TS_COMMON
;
2008 case IDENTIFIER_NODE
: return TS_IDENTIFIER
;
2009 case TREE_LIST
: return TS_LIST
;
2010 case TREE_VEC
: return TS_VEC
;
2011 case PHI_NODE
: return TS_PHI_NODE
;
2012 case SSA_NAME
: return TS_SSA_NAME
;
2013 case PLACEHOLDER_EXPR
: return TS_COMMON
;
2014 case STATEMENT_LIST
: return TS_STATEMENT_LIST
;
2015 case BLOCK
: return TS_BLOCK
;
2016 case CONSTRUCTOR
: return TS_CONSTRUCTOR
;
2017 case TREE_BINFO
: return TS_BINFO
;
2018 case VALUE_HANDLE
: return TS_VALUE_HANDLE
;
2025 /* Return 1 if EXP contains a PLACEHOLDER_EXPR; i.e., if it represents a size
2026 or offset that depends on a field within a record. */
2029 contains_placeholder_p (tree exp
)
2031 enum tree_code code
;
2036 code
= TREE_CODE (exp
);
2037 if (code
== PLACEHOLDER_EXPR
)
2040 switch (TREE_CODE_CLASS (code
))
2043 /* Don't look at any PLACEHOLDER_EXPRs that might be in index or bit
2044 position computations since they will be converted into a
2045 WITH_RECORD_EXPR involving the reference, which will assume
2046 here will be valid. */
2047 return CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp
, 0));
2049 case tcc_exceptional
:
2050 if (code
== TREE_LIST
)
2051 return (CONTAINS_PLACEHOLDER_P (TREE_VALUE (exp
))
2052 || CONTAINS_PLACEHOLDER_P (TREE_CHAIN (exp
)));
2057 case tcc_comparison
:
2058 case tcc_expression
:
2062 /* Ignoring the first operand isn't quite right, but works best. */
2063 return CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp
, 1));
2066 return (CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp
, 0))
2067 || CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp
, 1))
2068 || CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp
, 2)));
2071 return CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp
, 1));
2077 switch (TREE_CODE_LENGTH (code
))
2080 return CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp
, 0));
2082 return (CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp
, 0))
2083 || CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp
, 1)));
2094 /* Return true if any part of the computation of TYPE involves a
2095 PLACEHOLDER_EXPR. This includes size, bounds, qualifiers
2096 (for QUAL_UNION_TYPE) and field positions. */
2099 type_contains_placeholder_1 (tree type
)
2101 /* If the size contains a placeholder or the parent type (component type in
2102 the case of arrays) type involves a placeholder, this type does. */
2103 if (CONTAINS_PLACEHOLDER_P (TYPE_SIZE (type
))
2104 || CONTAINS_PLACEHOLDER_P (TYPE_SIZE_UNIT (type
))
2105 || (TREE_TYPE (type
) != 0
2106 && type_contains_placeholder_p (TREE_TYPE (type
))))
2109 /* Now do type-specific checks. Note that the last part of the check above
2110 greatly limits what we have to do below. */
2111 switch (TREE_CODE (type
))
2120 case REFERENCE_TYPE
:
2128 /* Here we just check the bounds. */
2129 return (CONTAINS_PLACEHOLDER_P (TYPE_MIN_VALUE (type
))
2130 || CONTAINS_PLACEHOLDER_P (TYPE_MAX_VALUE (type
)));
2133 /* We're already checked the component type (TREE_TYPE), so just check
2135 return type_contains_placeholder_p (TYPE_DOMAIN (type
));
2139 case QUAL_UNION_TYPE
:
2143 for (field
= TYPE_FIELDS (type
); field
; field
= TREE_CHAIN (field
))
2144 if (TREE_CODE (field
) == FIELD_DECL
2145 && (CONTAINS_PLACEHOLDER_P (DECL_FIELD_OFFSET (field
))
2146 || (TREE_CODE (type
) == QUAL_UNION_TYPE
2147 && CONTAINS_PLACEHOLDER_P (DECL_QUALIFIER (field
)))
2148 || type_contains_placeholder_p (TREE_TYPE (field
))))
2160 type_contains_placeholder_p (tree type
)
2164 /* If the contains_placeholder_bits field has been initialized,
2165 then we know the answer. */
2166 if (TYPE_CONTAINS_PLACEHOLDER_INTERNAL (type
) > 0)
2167 return TYPE_CONTAINS_PLACEHOLDER_INTERNAL (type
) - 1;
2169 /* Indicate that we've seen this type node, and the answer is false.
2170 This is what we want to return if we run into recursion via fields. */
2171 TYPE_CONTAINS_PLACEHOLDER_INTERNAL (type
) = 1;
2173 /* Compute the real value. */
2174 result
= type_contains_placeholder_1 (type
);
2176 /* Store the real value. */
2177 TYPE_CONTAINS_PLACEHOLDER_INTERNAL (type
) = result
+ 1;
2182 /* Given a tree EXP, a FIELD_DECL F, and a replacement value R,
2183 return a tree with all occurrences of references to F in a
2184 PLACEHOLDER_EXPR replaced by R. Note that we assume here that EXP
2185 contains only arithmetic expressions or a CALL_EXPR with a
2186 PLACEHOLDER_EXPR occurring only in its arglist. */
2189 substitute_in_expr (tree exp
, tree f
, tree r
)
2191 enum tree_code code
= TREE_CODE (exp
);
2192 tree op0
, op1
, op2
, op3
;
2196 /* We handle TREE_LIST and COMPONENT_REF separately. */
2197 if (code
== TREE_LIST
)
2199 op0
= SUBSTITUTE_IN_EXPR (TREE_CHAIN (exp
), f
, r
);
2200 op1
= SUBSTITUTE_IN_EXPR (TREE_VALUE (exp
), f
, r
);
2201 if (op0
== TREE_CHAIN (exp
) && op1
== TREE_VALUE (exp
))
2204 return tree_cons (TREE_PURPOSE (exp
), op1
, op0
);
2206 else if (code
== COMPONENT_REF
)
2208 /* If this expression is getting a value from a PLACEHOLDER_EXPR
2209 and it is the right field, replace it with R. */
2210 for (inner
= TREE_OPERAND (exp
, 0);
2211 REFERENCE_CLASS_P (inner
);
2212 inner
= TREE_OPERAND (inner
, 0))
2214 if (TREE_CODE (inner
) == PLACEHOLDER_EXPR
2215 && TREE_OPERAND (exp
, 1) == f
)
2218 /* If this expression hasn't been completed let, leave it alone. */
2219 if (TREE_CODE (inner
) == PLACEHOLDER_EXPR
&& TREE_TYPE (inner
) == 0)
2222 op0
= SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp
, 0), f
, r
);
2223 if (op0
== TREE_OPERAND (exp
, 0))
2226 new = fold_build3 (COMPONENT_REF
, TREE_TYPE (exp
),
2227 op0
, TREE_OPERAND (exp
, 1), NULL_TREE
);
2230 switch (TREE_CODE_CLASS (code
))
2233 case tcc_declaration
:
2236 case tcc_exceptional
:
2239 case tcc_comparison
:
2240 case tcc_expression
:
2242 switch (TREE_CODE_LENGTH (code
))
2248 op0
= SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp
, 0), f
, r
);
2249 if (op0
== TREE_OPERAND (exp
, 0))
2252 new = fold_build1 (code
, TREE_TYPE (exp
), op0
);
2256 op0
= SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp
, 0), f
, r
);
2257 op1
= SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp
, 1), f
, r
);
2259 if (op0
== TREE_OPERAND (exp
, 0) && op1
== TREE_OPERAND (exp
, 1))
2262 new = fold_build2 (code
, TREE_TYPE (exp
), op0
, op1
);
2266 op0
= SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp
, 0), f
, r
);
2267 op1
= SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp
, 1), f
, r
);
2268 op2
= SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp
, 2), f
, r
);
2270 if (op0
== TREE_OPERAND (exp
, 0) && op1
== TREE_OPERAND (exp
, 1)
2271 && op2
== TREE_OPERAND (exp
, 2))
2274 new = fold_build3 (code
, TREE_TYPE (exp
), op0
, op1
, op2
);
2278 op0
= SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp
, 0), f
, r
);
2279 op1
= SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp
, 1), f
, r
);
2280 op2
= SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp
, 2), f
, r
);
2281 op3
= SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp
, 3), f
, r
);
2283 if (op0
== TREE_OPERAND (exp
, 0) && op1
== TREE_OPERAND (exp
, 1)
2284 && op2
== TREE_OPERAND (exp
, 2)
2285 && op3
== TREE_OPERAND (exp
, 3))
2288 new = fold (build4 (code
, TREE_TYPE (exp
), op0
, op1
, op2
, op3
));
2300 TREE_READONLY (new) = TREE_READONLY (exp
);
2304 /* Similar, but look for a PLACEHOLDER_EXPR in EXP and find a replacement
2305 for it within OBJ, a tree that is an object or a chain of references. */
2308 substitute_placeholder_in_expr (tree exp
, tree obj
)
2310 enum tree_code code
= TREE_CODE (exp
);
2311 tree op0
, op1
, op2
, op3
;
2313 /* If this is a PLACEHOLDER_EXPR, see if we find a corresponding type
2314 in the chain of OBJ. */
2315 if (code
== PLACEHOLDER_EXPR
)
2317 tree need_type
= TYPE_MAIN_VARIANT (TREE_TYPE (exp
));
2320 for (elt
= obj
; elt
!= 0;
2321 elt
= ((TREE_CODE (elt
) == COMPOUND_EXPR
2322 || TREE_CODE (elt
) == COND_EXPR
)
2323 ? TREE_OPERAND (elt
, 1)
2324 : (REFERENCE_CLASS_P (elt
)
2325 || UNARY_CLASS_P (elt
)
2326 || BINARY_CLASS_P (elt
)
2327 || EXPRESSION_CLASS_P (elt
))
2328 ? TREE_OPERAND (elt
, 0) : 0))
2329 if (TYPE_MAIN_VARIANT (TREE_TYPE (elt
)) == need_type
)
2332 for (elt
= obj
; elt
!= 0;
2333 elt
= ((TREE_CODE (elt
) == COMPOUND_EXPR
2334 || TREE_CODE (elt
) == COND_EXPR
)
2335 ? TREE_OPERAND (elt
, 1)
2336 : (REFERENCE_CLASS_P (elt
)
2337 || UNARY_CLASS_P (elt
)
2338 || BINARY_CLASS_P (elt
)
2339 || EXPRESSION_CLASS_P (elt
))
2340 ? TREE_OPERAND (elt
, 0) : 0))
2341 if (POINTER_TYPE_P (TREE_TYPE (elt
))
2342 && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (elt
)))
2344 return fold_build1 (INDIRECT_REF
, need_type
, elt
);
2346 /* If we didn't find it, return the original PLACEHOLDER_EXPR. If it
2347 survives until RTL generation, there will be an error. */
2351 /* TREE_LIST is special because we need to look at TREE_VALUE
2352 and TREE_CHAIN, not TREE_OPERANDS. */
2353 else if (code
== TREE_LIST
)
2355 op0
= SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_CHAIN (exp
), obj
);
2356 op1
= SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_VALUE (exp
), obj
);
2357 if (op0
== TREE_CHAIN (exp
) && op1
== TREE_VALUE (exp
))
2360 return tree_cons (TREE_PURPOSE (exp
), op1
, op0
);
2363 switch (TREE_CODE_CLASS (code
))
2366 case tcc_declaration
:
2369 case tcc_exceptional
:
2372 case tcc_comparison
:
2373 case tcc_expression
:
2376 switch (TREE_CODE_LENGTH (code
))
2382 op0
= SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp
, 0), obj
);
2383 if (op0
== TREE_OPERAND (exp
, 0))
2386 return fold_build1 (code
, TREE_TYPE (exp
), op0
);
2389 op0
= SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp
, 0), obj
);
2390 op1
= SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp
, 1), obj
);
2392 if (op0
== TREE_OPERAND (exp
, 0) && op1
== TREE_OPERAND (exp
, 1))
2395 return fold_build2 (code
, TREE_TYPE (exp
), op0
, op1
);
2398 op0
= SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp
, 0), obj
);
2399 op1
= SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp
, 1), obj
);
2400 op2
= SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp
, 2), obj
);
2402 if (op0
== TREE_OPERAND (exp
, 0) && op1
== TREE_OPERAND (exp
, 1)
2403 && op2
== TREE_OPERAND (exp
, 2))
2406 return fold_build3 (code
, TREE_TYPE (exp
), op0
, op1
, op2
);
2409 op0
= SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp
, 0), obj
);
2410 op1
= SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp
, 1), obj
);
2411 op2
= SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp
, 2), obj
);
2412 op3
= SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp
, 3), obj
);
2414 if (op0
== TREE_OPERAND (exp
, 0) && op1
== TREE_OPERAND (exp
, 1)
2415 && op2
== TREE_OPERAND (exp
, 2)
2416 && op3
== TREE_OPERAND (exp
, 3))
2419 return fold (build4 (code
, TREE_TYPE (exp
), op0
, op1
, op2
, op3
));
2431 /* Stabilize a reference so that we can use it any number of times
2432 without causing its operands to be evaluated more than once.
2433 Returns the stabilized reference. This works by means of save_expr,
2434 so see the caveats in the comments about save_expr.
2436 Also allows conversion expressions whose operands are references.
2437 Any other kind of expression is returned unchanged. */
2440 stabilize_reference (tree ref
)
2443 enum tree_code code
= TREE_CODE (ref
);
2450 /* No action is needed in this case. */
2456 case FIX_TRUNC_EXPR
:
2457 case FIX_FLOOR_EXPR
:
2458 case FIX_ROUND_EXPR
:
2460 result
= build_nt (code
, stabilize_reference (TREE_OPERAND (ref
, 0)));
2464 result
= build_nt (INDIRECT_REF
,
2465 stabilize_reference_1 (TREE_OPERAND (ref
, 0)));
2469 result
= build_nt (COMPONENT_REF
,
2470 stabilize_reference (TREE_OPERAND (ref
, 0)),
2471 TREE_OPERAND (ref
, 1), NULL_TREE
);
2475 result
= build_nt (BIT_FIELD_REF
,
2476 stabilize_reference (TREE_OPERAND (ref
, 0)),
2477 stabilize_reference_1 (TREE_OPERAND (ref
, 1)),
2478 stabilize_reference_1 (TREE_OPERAND (ref
, 2)));
2482 result
= build_nt (ARRAY_REF
,
2483 stabilize_reference (TREE_OPERAND (ref
, 0)),
2484 stabilize_reference_1 (TREE_OPERAND (ref
, 1)),
2485 TREE_OPERAND (ref
, 2), TREE_OPERAND (ref
, 3));
2488 case ARRAY_RANGE_REF
:
2489 result
= build_nt (ARRAY_RANGE_REF
,
2490 stabilize_reference (TREE_OPERAND (ref
, 0)),
2491 stabilize_reference_1 (TREE_OPERAND (ref
, 1)),
2492 TREE_OPERAND (ref
, 2), TREE_OPERAND (ref
, 3));
2496 /* We cannot wrap the first expression in a SAVE_EXPR, as then
2497 it wouldn't be ignored. This matters when dealing with
2499 return stabilize_reference_1 (ref
);
2501 /* If arg isn't a kind of lvalue we recognize, make no change.
2502 Caller should recognize the error for an invalid lvalue. */
2507 return error_mark_node
;
2510 TREE_TYPE (result
) = TREE_TYPE (ref
);
2511 TREE_READONLY (result
) = TREE_READONLY (ref
);
2512 TREE_SIDE_EFFECTS (result
) = TREE_SIDE_EFFECTS (ref
);
2513 TREE_THIS_VOLATILE (result
) = TREE_THIS_VOLATILE (ref
);
2518 /* Subroutine of stabilize_reference; this is called for subtrees of
2519 references. Any expression with side-effects must be put in a SAVE_EXPR
2520 to ensure that it is only evaluated once.
2522 We don't put SAVE_EXPR nodes around everything, because assigning very
2523 simple expressions to temporaries causes us to miss good opportunities
2524 for optimizations. Among other things, the opportunity to fold in the
2525 addition of a constant into an addressing mode often gets lost, e.g.
2526 "y[i+1] += x;". In general, we take the approach that we should not make
2527 an assignment unless we are forced into it - i.e., that any non-side effect
2528 operator should be allowed, and that cse should take care of coalescing
2529 multiple utterances of the same expression should that prove fruitful. */
2532 stabilize_reference_1 (tree e
)
2535 enum tree_code code
= TREE_CODE (e
);
2537 /* We cannot ignore const expressions because it might be a reference
2538 to a const array but whose index contains side-effects. But we can
2539 ignore things that are actual constant or that already have been
2540 handled by this function. */
2542 if (TREE_INVARIANT (e
))
2545 switch (TREE_CODE_CLASS (code
))
2547 case tcc_exceptional
:
2549 case tcc_declaration
:
2550 case tcc_comparison
:
2552 case tcc_expression
:
2554 /* If the expression has side-effects, then encase it in a SAVE_EXPR
2555 so that it will only be evaluated once. */
2556 /* The reference (r) and comparison (<) classes could be handled as
2557 below, but it is generally faster to only evaluate them once. */
2558 if (TREE_SIDE_EFFECTS (e
))
2559 return save_expr (e
);
2563 /* Constants need no processing. In fact, we should never reach
2568 /* Division is slow and tends to be compiled with jumps,
2569 especially the division by powers of 2 that is often
2570 found inside of an array reference. So do it just once. */
2571 if (code
== TRUNC_DIV_EXPR
|| code
== TRUNC_MOD_EXPR
2572 || code
== FLOOR_DIV_EXPR
|| code
== FLOOR_MOD_EXPR
2573 || code
== CEIL_DIV_EXPR
|| code
== CEIL_MOD_EXPR
2574 || code
== ROUND_DIV_EXPR
|| code
== ROUND_MOD_EXPR
)
2575 return save_expr (e
);
2576 /* Recursively stabilize each operand. */
2577 result
= build_nt (code
, stabilize_reference_1 (TREE_OPERAND (e
, 0)),
2578 stabilize_reference_1 (TREE_OPERAND (e
, 1)));
2582 /* Recursively stabilize each operand. */
2583 result
= build_nt (code
, stabilize_reference_1 (TREE_OPERAND (e
, 0)));
2590 TREE_TYPE (result
) = TREE_TYPE (e
);
2591 TREE_READONLY (result
) = TREE_READONLY (e
);
2592 TREE_SIDE_EFFECTS (result
) = TREE_SIDE_EFFECTS (e
);
2593 TREE_THIS_VOLATILE (result
) = TREE_THIS_VOLATILE (e
);
2594 TREE_INVARIANT (result
) = 1;
2599 /* Low-level constructors for expressions. */
2601 /* A helper function for build1 and constant folders. Set TREE_CONSTANT,
2602 TREE_INVARIANT, and TREE_SIDE_EFFECTS for an ADDR_EXPR. */
2605 recompute_tree_invarant_for_addr_expr (tree t
)
2608 bool tc
= true, ti
= true, se
= false;
2610 /* We started out assuming this address is both invariant and constant, but
2611 does not have side effects. Now go down any handled components and see if
2612 any of them involve offsets that are either non-constant or non-invariant.
2613 Also check for side-effects.
2615 ??? Note that this code makes no attempt to deal with the case where
2616 taking the address of something causes a copy due to misalignment. */
2618 #define UPDATE_TITCSE(NODE) \
2619 do { tree _node = (NODE); \
2620 if (_node && !TREE_INVARIANT (_node)) ti = false; \
2621 if (_node && !TREE_CONSTANT (_node)) tc = false; \
2622 if (_node && TREE_SIDE_EFFECTS (_node)) se = true; } while (0)
2624 for (node
= TREE_OPERAND (t
, 0); handled_component_p (node
);
2625 node
= TREE_OPERAND (node
, 0))
2627 /* If the first operand doesn't have an ARRAY_TYPE, this is a bogus
2628 array reference (probably made temporarily by the G++ front end),
2629 so ignore all the operands. */
2630 if ((TREE_CODE (node
) == ARRAY_REF
2631 || TREE_CODE (node
) == ARRAY_RANGE_REF
)
2632 && TREE_CODE (TREE_TYPE (TREE_OPERAND (node
, 0))) == ARRAY_TYPE
)
2634 UPDATE_TITCSE (TREE_OPERAND (node
, 1));
2635 if (TREE_OPERAND (node
, 2))
2636 UPDATE_TITCSE (TREE_OPERAND (node
, 2));
2637 if (TREE_OPERAND (node
, 3))
2638 UPDATE_TITCSE (TREE_OPERAND (node
, 3));
2640 /* Likewise, just because this is a COMPONENT_REF doesn't mean we have a
2641 FIELD_DECL, apparently. The G++ front end can put something else
2642 there, at least temporarily. */
2643 else if (TREE_CODE (node
) == COMPONENT_REF
2644 && TREE_CODE (TREE_OPERAND (node
, 1)) == FIELD_DECL
)
2646 if (TREE_OPERAND (node
, 2))
2647 UPDATE_TITCSE (TREE_OPERAND (node
, 2));
2649 else if (TREE_CODE (node
) == BIT_FIELD_REF
)
2650 UPDATE_TITCSE (TREE_OPERAND (node
, 2));
2653 node
= lang_hooks
.expr_to_decl (node
, &tc
, &ti
, &se
);
2655 /* Now see what's inside. If it's an INDIRECT_REF, copy our properties from
2656 the address, since &(*a)->b is a form of addition. If it's a decl, it's
2657 invariant and constant if the decl is static. It's also invariant if it's
2658 a decl in the current function. Taking the address of a volatile variable
2659 is not volatile. If it's a constant, the address is both invariant and
2660 constant. Otherwise it's neither. */
2661 if (TREE_CODE (node
) == INDIRECT_REF
)
2662 UPDATE_TITCSE (TREE_OPERAND (node
, 0));
2663 else if (DECL_P (node
))
2667 else if (decl_function_context (node
) == current_function_decl
2668 /* Addresses of thread-local variables are invariant. */
2669 || (TREE_CODE (node
) == VAR_DECL
2670 && DECL_THREAD_LOCAL_P (node
)))
2675 else if (CONSTANT_CLASS_P (node
))
2680 se
|= TREE_SIDE_EFFECTS (node
);
2683 TREE_CONSTANT (t
) = tc
;
2684 TREE_INVARIANT (t
) = ti
;
2685 TREE_SIDE_EFFECTS (t
) = se
;
2686 #undef UPDATE_TITCSE
2689 /* Build an expression of code CODE, data type TYPE, and operands as
2690 specified. Expressions and reference nodes can be created this way.
2691 Constants, decls, types and misc nodes cannot be.
2693 We define 5 non-variadic functions, from 0 to 4 arguments. This is
2694 enough for all extant tree codes. These functions can be called
2695 directly (preferably!), but can also be obtained via GCC preprocessor
2696 magic within the build macro. */
2699 build0_stat (enum tree_code code
, tree tt MEM_STAT_DECL
)
2703 gcc_assert (TREE_CODE_LENGTH (code
) == 0);
2705 t
= make_node_stat (code PASS_MEM_STAT
);
2712 build1_stat (enum tree_code code
, tree type
, tree node MEM_STAT_DECL
)
2714 int length
= sizeof (struct tree_exp
);
2715 #ifdef GATHER_STATISTICS
2716 tree_node_kind kind
;
2720 #ifdef GATHER_STATISTICS
2721 switch (TREE_CODE_CLASS (code
))
2723 case tcc_statement
: /* an expression with side effects */
2726 case tcc_reference
: /* a reference */
2734 tree_node_counts
[(int) kind
]++;
2735 tree_node_sizes
[(int) kind
] += length
;
2738 gcc_assert (TREE_CODE_LENGTH (code
) == 1);
2740 t
= ggc_alloc_zone_pass_stat (length
, &tree_zone
);
2742 memset (t
, 0, sizeof (struct tree_common
));
2744 TREE_SET_CODE (t
, code
);
2746 TREE_TYPE (t
) = type
;
2747 #ifdef USE_MAPPED_LOCATION
2748 SET_EXPR_LOCATION (t
, UNKNOWN_LOCATION
);
2750 SET_EXPR_LOCUS (t
, NULL
);
2752 TREE_COMPLEXITY (t
) = 0;
2753 TREE_OPERAND (t
, 0) = node
;
2754 TREE_BLOCK (t
) = NULL_TREE
;
2755 if (node
&& !TYPE_P (node
))
2757 TREE_SIDE_EFFECTS (t
) = TREE_SIDE_EFFECTS (node
);
2758 TREE_READONLY (t
) = TREE_READONLY (node
);
2761 if (TREE_CODE_CLASS (code
) == tcc_statement
)
2762 TREE_SIDE_EFFECTS (t
) = 1;
2766 /* All of these have side-effects, no matter what their
2768 TREE_SIDE_EFFECTS (t
) = 1;
2769 TREE_READONLY (t
) = 0;
2772 case MISALIGNED_INDIRECT_REF
:
2773 case ALIGN_INDIRECT_REF
:
2775 /* Whether a dereference is readonly has nothing to do with whether
2776 its operand is readonly. */
2777 TREE_READONLY (t
) = 0;
2782 recompute_tree_invarant_for_addr_expr (t
);
2786 if (TREE_CODE_CLASS (code
) == tcc_unary
2787 && node
&& !TYPE_P (node
)
2788 && TREE_CONSTANT (node
))
2789 TREE_CONSTANT (t
) = 1;
2790 if (TREE_CODE_CLASS (code
) == tcc_unary
2791 && node
&& TREE_INVARIANT (node
))
2792 TREE_INVARIANT (t
) = 1;
2793 if (TREE_CODE_CLASS (code
) == tcc_reference
2794 && node
&& TREE_THIS_VOLATILE (node
))
2795 TREE_THIS_VOLATILE (t
) = 1;
2802 #define PROCESS_ARG(N) \
2804 TREE_OPERAND (t, N) = arg##N; \
2805 if (arg##N &&!TYPE_P (arg##N)) \
2807 if (TREE_SIDE_EFFECTS (arg##N)) \
2809 if (!TREE_READONLY (arg##N)) \
2811 if (!TREE_CONSTANT (arg##N)) \
2813 if (!TREE_INVARIANT (arg##N)) \
2819 build2_stat (enum tree_code code
, tree tt
, tree arg0
, tree arg1 MEM_STAT_DECL
)
2821 bool constant
, read_only
, side_effects
, invariant
;
2824 gcc_assert (TREE_CODE_LENGTH (code
) == 2);
2826 t
= make_node_stat (code PASS_MEM_STAT
);
2829 /* Below, we automatically set TREE_SIDE_EFFECTS and TREE_READONLY for the
2830 result based on those same flags for the arguments. But if the
2831 arguments aren't really even `tree' expressions, we shouldn't be trying
2834 /* Expressions without side effects may be constant if their
2835 arguments are as well. */
2836 constant
= (TREE_CODE_CLASS (code
) == tcc_comparison
2837 || TREE_CODE_CLASS (code
) == tcc_binary
);
2839 side_effects
= TREE_SIDE_EFFECTS (t
);
2840 invariant
= constant
;
2845 TREE_READONLY (t
) = read_only
;
2846 TREE_CONSTANT (t
) = constant
;
2847 TREE_INVARIANT (t
) = invariant
;
2848 TREE_SIDE_EFFECTS (t
) = side_effects
;
2849 TREE_THIS_VOLATILE (t
)
2850 = (TREE_CODE_CLASS (code
) == tcc_reference
2851 && arg0
&& TREE_THIS_VOLATILE (arg0
));
2857 build3_stat (enum tree_code code
, tree tt
, tree arg0
, tree arg1
,
2858 tree arg2 MEM_STAT_DECL
)
2860 bool constant
, read_only
, side_effects
, invariant
;
2863 gcc_assert (TREE_CODE_LENGTH (code
) == 3);
2865 t
= make_node_stat (code PASS_MEM_STAT
);
2868 side_effects
= TREE_SIDE_EFFECTS (t
);
2874 if (code
== CALL_EXPR
&& !side_effects
)
2879 /* Calls have side-effects, except those to const or
2881 i
= call_expr_flags (t
);
2882 if (!(i
& (ECF_CONST
| ECF_PURE
)))
2885 /* And even those have side-effects if their arguments do. */
2886 else for (node
= arg1
; node
; node
= TREE_CHAIN (node
))
2887 if (TREE_SIDE_EFFECTS (TREE_VALUE (node
)))
2894 TREE_SIDE_EFFECTS (t
) = side_effects
;
2895 TREE_THIS_VOLATILE (t
)
2896 = (TREE_CODE_CLASS (code
) == tcc_reference
2897 && arg0
&& TREE_THIS_VOLATILE (arg0
));
2903 build4_stat (enum tree_code code
, tree tt
, tree arg0
, tree arg1
,
2904 tree arg2
, tree arg3 MEM_STAT_DECL
)
2906 bool constant
, read_only
, side_effects
, invariant
;
2909 gcc_assert (TREE_CODE_LENGTH (code
) == 4);
2911 t
= make_node_stat (code PASS_MEM_STAT
);
2914 side_effects
= TREE_SIDE_EFFECTS (t
);
2921 TREE_SIDE_EFFECTS (t
) = side_effects
;
2922 TREE_THIS_VOLATILE (t
)
2923 = (TREE_CODE_CLASS (code
) == tcc_reference
2924 && arg0
&& TREE_THIS_VOLATILE (arg0
));
2930 build7_stat (enum tree_code code
, tree tt
, tree arg0
, tree arg1
,
2931 tree arg2
, tree arg3
, tree arg4
, tree arg5
,
2932 tree arg6 MEM_STAT_DECL
)
2934 bool constant
, read_only
, side_effects
, invariant
;
2937 gcc_assert (code
== TARGET_MEM_REF
);
2939 t
= make_node_stat (code PASS_MEM_STAT
);
2942 side_effects
= TREE_SIDE_EFFECTS (t
);
2952 TREE_SIDE_EFFECTS (t
) = side_effects
;
2953 TREE_THIS_VOLATILE (t
) = 0;
2958 /* Backup definition for non-gcc build compilers. */
2961 (build
) (enum tree_code code
, tree tt
, ...)
2963 tree t
, arg0
, arg1
, arg2
, arg3
, arg4
, arg5
, arg6
;
2964 int length
= TREE_CODE_LENGTH (code
);
2971 t
= build0 (code
, tt
);
2974 arg0
= va_arg (p
, tree
);
2975 t
= build1 (code
, tt
, arg0
);
2978 arg0
= va_arg (p
, tree
);
2979 arg1
= va_arg (p
, tree
);
2980 t
= build2 (code
, tt
, arg0
, arg1
);
2983 arg0
= va_arg (p
, tree
);
2984 arg1
= va_arg (p
, tree
);
2985 arg2
= va_arg (p
, tree
);
2986 t
= build3 (code
, tt
, arg0
, arg1
, arg2
);
2989 arg0
= va_arg (p
, tree
);
2990 arg1
= va_arg (p
, tree
);
2991 arg2
= va_arg (p
, tree
);
2992 arg3
= va_arg (p
, tree
);
2993 t
= build4 (code
, tt
, arg0
, arg1
, arg2
, arg3
);
2996 arg0
= va_arg (p
, tree
);
2997 arg1
= va_arg (p
, tree
);
2998 arg2
= va_arg (p
, tree
);
2999 arg3
= va_arg (p
, tree
);
3000 arg4
= va_arg (p
, tree
);
3001 arg5
= va_arg (p
, tree
);
3002 arg6
= va_arg (p
, tree
);
3003 t
= build7 (code
, tt
, arg0
, arg1
, arg2
, arg3
, arg4
, arg5
, arg6
);
3013 /* Similar except don't specify the TREE_TYPE
3014 and leave the TREE_SIDE_EFFECTS as 0.
3015 It is permissible for arguments to be null,
3016 or even garbage if their values do not matter. */
3019 build_nt (enum tree_code code
, ...)
3028 t
= make_node (code
);
3029 length
= TREE_CODE_LENGTH (code
);
3031 for (i
= 0; i
< length
; i
++)
3032 TREE_OPERAND (t
, i
) = va_arg (p
, tree
);
3038 /* Create a DECL_... node of code CODE, name NAME and data type TYPE.
3039 We do NOT enter this node in any sort of symbol table.
3041 layout_decl is used to set up the decl's storage layout.
3042 Other slots are initialized to 0 or null pointers. */
3045 build_decl_stat (enum tree_code code
, tree name
, tree type MEM_STAT_DECL
)
3049 t
= make_node_stat (code PASS_MEM_STAT
);
3051 /* if (type == error_mark_node)
3052 type = integer_type_node; */
3053 /* That is not done, deliberately, so that having error_mark_node
3054 as the type can suppress useless errors in the use of this variable. */
3056 DECL_NAME (t
) = name
;
3057 TREE_TYPE (t
) = type
;
3059 if (code
== VAR_DECL
|| code
== PARM_DECL
|| code
== RESULT_DECL
)
3061 else if (code
== FUNCTION_DECL
)
3062 DECL_MODE (t
) = FUNCTION_MODE
;
3064 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_WITH_VIS
))
3066 /* Set default visibility to whatever the user supplied with
3067 visibility_specified depending on #pragma GCC visibility. */
3068 DECL_VISIBILITY (t
) = default_visibility
;
3069 DECL_VISIBILITY_SPECIFIED (t
) = visibility_options
.inpragma
;
3075 /* Builds and returns function declaration with NAME and TYPE. */
3078 build_fn_decl (const char *name
, tree type
)
3080 tree id
= get_identifier (name
);
3081 tree decl
= build_decl (FUNCTION_DECL
, id
, type
);
3083 DECL_EXTERNAL (decl
) = 1;
3084 TREE_PUBLIC (decl
) = 1;
3085 DECL_ARTIFICIAL (decl
) = 1;
3086 TREE_NOTHROW (decl
) = 1;
3092 /* BLOCK nodes are used to represent the structure of binding contours
3093 and declarations, once those contours have been exited and their contents
3094 compiled. This information is used for outputting debugging info. */
3097 build_block (tree vars
, tree subblocks
, tree supercontext
, tree chain
)
3099 tree block
= make_node (BLOCK
);
3101 BLOCK_VARS (block
) = vars
;
3102 BLOCK_SUBBLOCKS (block
) = subblocks
;
3103 BLOCK_SUPERCONTEXT (block
) = supercontext
;
3104 BLOCK_CHAIN (block
) = chain
;
3108 #if 1 /* ! defined(USE_MAPPED_LOCATION) */
3109 /* ??? gengtype doesn't handle conditionals */
3110 static GTY(()) tree last_annotated_node
;
3113 #ifdef USE_MAPPED_LOCATION
3116 expand_location (source_location loc
)
3118 expanded_location xloc
;
3119 if (loc
== 0) { xloc
.file
= NULL
; xloc
.line
= 0; xloc
.column
= 0; }
3122 const struct line_map
*map
= linemap_lookup (&line_table
, loc
);
3123 xloc
.file
= map
->to_file
;
3124 xloc
.line
= SOURCE_LINE (map
, loc
);
3125 xloc
.column
= SOURCE_COLUMN (map
, loc
);
3132 /* Record the exact location where an expression or an identifier were
3136 annotate_with_file_line (tree node
, const char *file
, int line
)
3138 /* Roughly one percent of the calls to this function are to annotate
3139 a node with the same information already attached to that node!
3140 Just return instead of wasting memory. */
3141 if (EXPR_LOCUS (node
)
3142 && EXPR_LINENO (node
) == line
3143 && (EXPR_FILENAME (node
) == file
3144 || !strcmp (EXPR_FILENAME (node
), file
)))
3146 last_annotated_node
= node
;
3150 /* In heavily macroized code (such as GCC itself) this single
3151 entry cache can reduce the number of allocations by more
3153 if (last_annotated_node
3154 && EXPR_LOCUS (last_annotated_node
)
3155 && EXPR_LINENO (last_annotated_node
) == line
3156 && (EXPR_FILENAME (last_annotated_node
) == file
3157 || !strcmp (EXPR_FILENAME (last_annotated_node
), file
)))
3159 SET_EXPR_LOCUS (node
, EXPR_LOCUS (last_annotated_node
));
3163 SET_EXPR_LOCUS (node
, ggc_alloc (sizeof (location_t
)));
3164 EXPR_LINENO (node
) = line
;
3165 EXPR_FILENAME (node
) = file
;
3166 last_annotated_node
= node
;
3170 annotate_with_locus (tree node
, location_t locus
)
3172 annotate_with_file_line (node
, locus
.file
, locus
.line
);
3176 /* Return a declaration like DDECL except that its DECL_ATTRIBUTES
3180 build_decl_attribute_variant (tree ddecl
, tree attribute
)
3182 DECL_ATTRIBUTES (ddecl
) = attribute
;
3186 /* Borrowed from hashtab.c iterative_hash implementation. */
3187 #define mix(a,b,c) \
3189 a -= b; a -= c; a ^= (c>>13); \
3190 b -= c; b -= a; b ^= (a<< 8); \
3191 c -= a; c -= b; c ^= ((b&0xffffffff)>>13); \
3192 a -= b; a -= c; a ^= ((c&0xffffffff)>>12); \
3193 b -= c; b -= a; b = (b ^ (a<<16)) & 0xffffffff; \
3194 c -= a; c -= b; c = (c ^ (b>> 5)) & 0xffffffff; \
3195 a -= b; a -= c; a = (a ^ (c>> 3)) & 0xffffffff; \
3196 b -= c; b -= a; b = (b ^ (a<<10)) & 0xffffffff; \
3197 c -= a; c -= b; c = (c ^ (b>>15)) & 0xffffffff; \
3201 /* Produce good hash value combining VAL and VAL2. */
3202 static inline hashval_t
3203 iterative_hash_hashval_t (hashval_t val
, hashval_t val2
)
3205 /* the golden ratio; an arbitrary value. */
3206 hashval_t a
= 0x9e3779b9;
3212 /* Produce good hash value combining PTR and VAL2. */
3213 static inline hashval_t
3214 iterative_hash_pointer (void *ptr
, hashval_t val2
)
3216 if (sizeof (ptr
) == sizeof (hashval_t
))
3217 return iterative_hash_hashval_t ((size_t) ptr
, val2
);
3220 hashval_t a
= (hashval_t
) (size_t) ptr
;
3221 /* Avoid warnings about shifting of more than the width of the type on
3222 hosts that won't execute this path. */
3224 hashval_t b
= (hashval_t
) ((size_t) ptr
>> (sizeof (hashval_t
) * 8 + zero
));
3230 /* Produce good hash value combining VAL and VAL2. */
3231 static inline hashval_t
3232 iterative_hash_host_wide_int (HOST_WIDE_INT val
, hashval_t val2
)
3234 if (sizeof (HOST_WIDE_INT
) == sizeof (hashval_t
))
3235 return iterative_hash_hashval_t (val
, val2
);
3238 hashval_t a
= (hashval_t
) val
;
3239 /* Avoid warnings about shifting of more than the width of the type on
3240 hosts that won't execute this path. */
3242 hashval_t b
= (hashval_t
) (val
>> (sizeof (hashval_t
) * 8 + zero
));
3244 if (sizeof (HOST_WIDE_INT
) > 2 * sizeof (hashval_t
))
3246 hashval_t a
= (hashval_t
) (val
>> (sizeof (hashval_t
) * 16 + zero
));
3247 hashval_t b
= (hashval_t
) (val
>> (sizeof (hashval_t
) * 24 + zero
));
3254 /* Return a type like TTYPE except that its TYPE_ATTRIBUTE
3257 Record such modified types already made so we don't make duplicates. */
3260 build_type_attribute_variant (tree ttype
, tree attribute
)
3262 if (! attribute_list_equal (TYPE_ATTRIBUTES (ttype
), attribute
))
3264 hashval_t hashcode
= 0;
3266 enum tree_code code
= TREE_CODE (ttype
);
3268 ntype
= copy_node (ttype
);
3270 TYPE_POINTER_TO (ntype
) = 0;
3271 TYPE_REFERENCE_TO (ntype
) = 0;
3272 TYPE_ATTRIBUTES (ntype
) = attribute
;
3274 /* Create a new main variant of TYPE. */
3275 TYPE_MAIN_VARIANT (ntype
) = ntype
;
3276 TYPE_NEXT_VARIANT (ntype
) = 0;
3277 set_type_quals (ntype
, TYPE_UNQUALIFIED
);
3279 hashcode
= iterative_hash_object (code
, hashcode
);
3280 if (TREE_TYPE (ntype
))
3281 hashcode
= iterative_hash_object (TYPE_HASH (TREE_TYPE (ntype
)),
3283 hashcode
= attribute_hash_list (attribute
, hashcode
);
3285 switch (TREE_CODE (ntype
))
3288 hashcode
= type_hash_list (TYPE_ARG_TYPES (ntype
), hashcode
);
3291 hashcode
= iterative_hash_object (TYPE_HASH (TYPE_DOMAIN (ntype
)),
3295 hashcode
= iterative_hash_object
3296 (TREE_INT_CST_LOW (TYPE_MAX_VALUE (ntype
)), hashcode
);
3297 hashcode
= iterative_hash_object
3298 (TREE_INT_CST_HIGH (TYPE_MAX_VALUE (ntype
)), hashcode
);
3302 unsigned int precision
= TYPE_PRECISION (ntype
);
3303 hashcode
= iterative_hash_object (precision
, hashcode
);
3310 ntype
= type_hash_canon (hashcode
, ntype
);
3311 ttype
= build_qualified_type (ntype
, TYPE_QUALS (ttype
));
3318 /* Return nonzero if IDENT is a valid name for attribute ATTR,
3321 We try both `text' and `__text__', ATTR may be either one. */
3322 /* ??? It might be a reasonable simplification to require ATTR to be only
3323 `text'. One might then also require attribute lists to be stored in
3324 their canonicalized form. */
3327 is_attribute_with_length_p (const char *attr
, int attr_len
, tree ident
)
3332 if (TREE_CODE (ident
) != IDENTIFIER_NODE
)
3335 p
= IDENTIFIER_POINTER (ident
);
3336 ident_len
= IDENTIFIER_LENGTH (ident
);
3338 if (ident_len
== attr_len
3339 && strcmp (attr
, p
) == 0)
3342 /* If ATTR is `__text__', IDENT must be `text'; and vice versa. */
3345 gcc_assert (attr
[1] == '_');
3346 gcc_assert (attr
[attr_len
- 2] == '_');
3347 gcc_assert (attr
[attr_len
- 1] == '_');
3348 gcc_assert (attr
[1] == '_');
3349 if (ident_len
== attr_len
- 4
3350 && strncmp (attr
+ 2, p
, attr_len
- 4) == 0)
3355 if (ident_len
== attr_len
+ 4
3356 && p
[0] == '_' && p
[1] == '_'
3357 && p
[ident_len
- 2] == '_' && p
[ident_len
- 1] == '_'
3358 && strncmp (attr
, p
+ 2, attr_len
) == 0)
3365 /* Return nonzero if IDENT is a valid name for attribute ATTR,
3368 We try both `text' and `__text__', ATTR may be either one. */
3371 is_attribute_p (const char *attr
, tree ident
)
3373 return is_attribute_with_length_p (attr
, strlen (attr
), ident
);
3376 /* Given an attribute name and a list of attributes, return a pointer to the
3377 attribute's list element if the attribute is part of the list, or NULL_TREE
3378 if not found. If the attribute appears more than once, this only
3379 returns the first occurrence; the TREE_CHAIN of the return value should
3380 be passed back in if further occurrences are wanted. */
3383 lookup_attribute (const char *attr_name
, tree list
)
3386 size_t attr_len
= strlen (attr_name
);
3388 for (l
= list
; l
; l
= TREE_CHAIN (l
))
3390 gcc_assert (TREE_CODE (TREE_PURPOSE (l
)) == IDENTIFIER_NODE
);
3391 if (is_attribute_with_length_p (attr_name
, attr_len
, TREE_PURPOSE (l
)))
3398 /* Return an attribute list that is the union of a1 and a2. */
3401 merge_attributes (tree a1
, tree a2
)
3405 /* Either one unset? Take the set one. */
3407 if ((attributes
= a1
) == 0)
3410 /* One that completely contains the other? Take it. */
3412 else if (a2
!= 0 && ! attribute_list_contained (a1
, a2
))
3414 if (attribute_list_contained (a2
, a1
))
3418 /* Pick the longest list, and hang on the other list. */
3420 if (list_length (a1
) < list_length (a2
))
3421 attributes
= a2
, a2
= a1
;
3423 for (; a2
!= 0; a2
= TREE_CHAIN (a2
))
3426 for (a
= lookup_attribute (IDENTIFIER_POINTER (TREE_PURPOSE (a2
)),
3429 a
= lookup_attribute (IDENTIFIER_POINTER (TREE_PURPOSE (a2
)),
3432 if (simple_cst_equal (TREE_VALUE (a
), TREE_VALUE (a2
)) == 1)
3437 a1
= copy_node (a2
);
3438 TREE_CHAIN (a1
) = attributes
;
3447 /* Given types T1 and T2, merge their attributes and return
3451 merge_type_attributes (tree t1
, tree t2
)
3453 return merge_attributes (TYPE_ATTRIBUTES (t1
),
3454 TYPE_ATTRIBUTES (t2
));
3457 /* Given decls OLDDECL and NEWDECL, merge their attributes and return
3461 merge_decl_attributes (tree olddecl
, tree newdecl
)
3463 return merge_attributes (DECL_ATTRIBUTES (olddecl
),
3464 DECL_ATTRIBUTES (newdecl
));
3467 #if TARGET_DLLIMPORT_DECL_ATTRIBUTES
3469 /* Specialization of merge_decl_attributes for various Windows targets.
3471 This handles the following situation:
3473 __declspec (dllimport) int foo;
3476 The second instance of `foo' nullifies the dllimport. */
3479 merge_dllimport_decl_attributes (tree old
, tree
new)
3482 int delete_dllimport_p
;
3484 old
= DECL_ATTRIBUTES (old
);
3485 new = DECL_ATTRIBUTES (new);
3487 /* What we need to do here is remove from `old' dllimport if it doesn't
3488 appear in `new'. dllimport behaves like extern: if a declaration is
3489 marked dllimport and a definition appears later, then the object
3490 is not dllimport'd. */
3491 if (lookup_attribute ("dllimport", old
) != NULL_TREE
3492 && lookup_attribute ("dllimport", new) == NULL_TREE
)
3493 delete_dllimport_p
= 1;
3495 delete_dllimport_p
= 0;
3497 a
= merge_attributes (old
, new);
3499 if (delete_dllimport_p
)
3503 /* Scan the list for dllimport and delete it. */
3504 for (prev
= NULL_TREE
, t
= a
; t
; prev
= t
, t
= TREE_CHAIN (t
))
3506 if (is_attribute_p ("dllimport", TREE_PURPOSE (t
)))
3508 if (prev
== NULL_TREE
)
3511 TREE_CHAIN (prev
) = TREE_CHAIN (t
);
3520 /* Handle a "dllimport" or "dllexport" attribute; arguments as in
3521 struct attribute_spec.handler. */
3524 handle_dll_attribute (tree
* pnode
, tree name
, tree args
, int flags
,
3529 /* These attributes may apply to structure and union types being created,
3530 but otherwise should pass to the declaration involved. */
3533 if (flags
& ((int) ATTR_FLAG_DECL_NEXT
| (int) ATTR_FLAG_FUNCTION_NEXT
3534 | (int) ATTR_FLAG_ARRAY_NEXT
))
3536 *no_add_attrs
= true;
3537 return tree_cons (name
, args
, NULL_TREE
);
3539 if (TREE_CODE (node
) != RECORD_TYPE
&& TREE_CODE (node
) != UNION_TYPE
)
3541 warning (OPT_Wattributes
, "%qs attribute ignored",
3542 IDENTIFIER_POINTER (name
));
3543 *no_add_attrs
= true;
3549 /* Report error on dllimport ambiguities seen now before they cause
3551 if (is_attribute_p ("dllimport", name
))
3553 /* Like MS, treat definition of dllimported variables and
3554 non-inlined functions on declaration as syntax errors. We
3555 allow the attribute for function definitions if declared
3557 if (TREE_CODE (node
) == FUNCTION_DECL
&& DECL_INITIAL (node
)
3558 && !DECL_DECLARED_INLINE_P (node
))
3560 error ("function %q+D definition is marked dllimport", node
);
3561 *no_add_attrs
= true;
3564 else if (TREE_CODE (node
) == VAR_DECL
)
3566 if (DECL_INITIAL (node
))
3568 error ("variable %q+D definition is marked dllimport",
3570 *no_add_attrs
= true;
3573 /* `extern' needn't be specified with dllimport.
3574 Specify `extern' now and hope for the best. Sigh. */
3575 DECL_EXTERNAL (node
) = 1;
3576 /* Also, implicitly give dllimport'd variables declared within
3577 a function global scope, unless declared static. */
3578 if (current_function_decl
!= NULL_TREE
&& !TREE_STATIC (node
))
3579 TREE_PUBLIC (node
) = 1;
3583 /* Report error if symbol is not accessible at global scope. */
3584 if (!TREE_PUBLIC (node
)
3585 && (TREE_CODE (node
) == VAR_DECL
3586 || TREE_CODE (node
) == FUNCTION_DECL
))
3588 error ("external linkage required for symbol %q+D because of "
3589 "%qs attribute", node
, IDENTIFIER_POINTER (name
));
3590 *no_add_attrs
= true;
3596 #endif /* TARGET_DLLIMPORT_DECL_ATTRIBUTES */
3598 /* Set the type qualifiers for TYPE to TYPE_QUALS, which is a bitmask
3599 of the various TYPE_QUAL values. */
3602 set_type_quals (tree type
, int type_quals
)
3604 TYPE_READONLY (type
) = (type_quals
& TYPE_QUAL_CONST
) != 0;
3605 TYPE_VOLATILE (type
) = (type_quals
& TYPE_QUAL_VOLATILE
) != 0;
3606 TYPE_RESTRICT (type
) = (type_quals
& TYPE_QUAL_RESTRICT
) != 0;
3609 /* Returns true iff cand is equivalent to base with type_quals. */
3612 check_qualified_type (tree cand
, tree base
, int type_quals
)
3614 return (TYPE_QUALS (cand
) == type_quals
3615 && TYPE_NAME (cand
) == TYPE_NAME (base
)
3616 /* Apparently this is needed for Objective-C. */
3617 && TYPE_CONTEXT (cand
) == TYPE_CONTEXT (base
)
3618 && attribute_list_equal (TYPE_ATTRIBUTES (cand
),
3619 TYPE_ATTRIBUTES (base
)));
3622 /* Return a version of the TYPE, qualified as indicated by the
3623 TYPE_QUALS, if one exists. If no qualified version exists yet,
3624 return NULL_TREE. */
3627 get_qualified_type (tree type
, int type_quals
)
3631 if (TYPE_QUALS (type
) == type_quals
)
3634 /* Search the chain of variants to see if there is already one there just
3635 like the one we need to have. If so, use that existing one. We must
3636 preserve the TYPE_NAME, since there is code that depends on this. */
3637 for (t
= TYPE_MAIN_VARIANT (type
); t
; t
= TYPE_NEXT_VARIANT (t
))
3638 if (check_qualified_type (t
, type
, type_quals
))
3644 /* Like get_qualified_type, but creates the type if it does not
3645 exist. This function never returns NULL_TREE. */
3648 build_qualified_type (tree type
, int type_quals
)
3652 /* See if we already have the appropriate qualified variant. */
3653 t
= get_qualified_type (type
, type_quals
);
3655 /* If not, build it. */
3658 t
= build_variant_type_copy (type
);
3659 set_type_quals (t
, type_quals
);
3665 /* Create a new distinct copy of TYPE. The new type is made its own
3669 build_distinct_type_copy (tree type
)
3671 tree t
= copy_node (type
);
3673 TYPE_POINTER_TO (t
) = 0;
3674 TYPE_REFERENCE_TO (t
) = 0;
3676 /* Make it its own variant. */
3677 TYPE_MAIN_VARIANT (t
) = t
;
3678 TYPE_NEXT_VARIANT (t
) = 0;
3683 /* Create a new variant of TYPE, equivalent but distinct.
3684 This is so the caller can modify it. */
3687 build_variant_type_copy (tree type
)
3689 tree t
, m
= TYPE_MAIN_VARIANT (type
);
3691 t
= build_distinct_type_copy (type
);
3693 /* Add the new type to the chain of variants of TYPE. */
3694 TYPE_NEXT_VARIANT (t
) = TYPE_NEXT_VARIANT (m
);
3695 TYPE_NEXT_VARIANT (m
) = t
;
3696 TYPE_MAIN_VARIANT (t
) = m
;
3701 /* Return true if the from tree in both tree maps are equal. */
3704 tree_map_eq (const void *va
, const void *vb
)
3706 const struct tree_map
*a
= va
, *b
= vb
;
3707 return (a
->from
== b
->from
);
3710 /* Hash a from tree in a tree_map. */
3713 tree_map_hash (const void *item
)
3715 return (((const struct tree_map
*) item
)->hash
);
3718 /* Return true if this tree map structure is marked for garbage collection
3719 purposes. We simply return true if the from tree is marked, so that this
3720 structure goes away when the from tree goes away. */
3723 tree_map_marked_p (const void *p
)
3725 tree from
= ((struct tree_map
*) p
)->from
;
3727 return ggc_marked_p (from
);
3730 /* Return true if the trees in the tree_int_map *'s VA and VB are equal. */
3733 tree_int_map_eq (const void *va
, const void *vb
)
3735 const struct tree_int_map
*a
= va
, *b
= vb
;
3736 return (a
->from
== b
->from
);
3739 /* Hash a from tree in the tree_int_map * ITEM. */
3742 tree_int_map_hash (const void *item
)
3744 return htab_hash_pointer (((const struct tree_int_map
*)item
)->from
);
3747 /* Return true if this tree int map structure is marked for garbage collection
3748 purposes. We simply return true if the from tree_int_map *P's from tree is marked, so that this
3749 structure goes away when the from tree goes away. */
3752 tree_int_map_marked_p (const void *p
)
3754 tree from
= ((struct tree_int_map
*) p
)->from
;
3756 return ggc_marked_p (from
);
3758 /* Lookup an init priority for FROM, and return it if we find one. */
3761 decl_init_priority_lookup (tree from
)
3763 struct tree_int_map
*h
, in
;
3766 h
= htab_find_with_hash (init_priority_for_decl
,
3767 &in
, htab_hash_pointer (from
));
3773 /* Insert a mapping FROM->TO in the init priority hashtable. */
3776 decl_init_priority_insert (tree from
, unsigned short to
)
3778 struct tree_int_map
*h
;
3781 h
= ggc_alloc (sizeof (struct tree_int_map
));
3784 loc
= htab_find_slot_with_hash (init_priority_for_decl
, h
,
3785 htab_hash_pointer (from
), INSERT
);
3786 *(struct tree_int_map
**) loc
= h
;
3789 /* Look up a restrict qualified base decl for FROM. */
3792 decl_restrict_base_lookup (tree from
)
3798 h
= htab_find_with_hash (restrict_base_for_decl
, &in
,
3799 htab_hash_pointer (from
));
3800 return h
? h
->to
: NULL_TREE
;
3803 /* Record the restrict qualified base TO for FROM. */
3806 decl_restrict_base_insert (tree from
, tree to
)
3811 h
= ggc_alloc (sizeof (struct tree_map
));
3812 h
->hash
= htab_hash_pointer (from
);
3815 loc
= htab_find_slot_with_hash (restrict_base_for_decl
, h
, h
->hash
, INSERT
);
3816 *(struct tree_map
**) loc
= h
;
3819 /* Print out the statistics for the DECL_DEBUG_EXPR hash table. */
3822 print_debug_expr_statistics (void)
3824 fprintf (stderr
, "DECL_DEBUG_EXPR hash: size %ld, %ld elements, %f collisions\n",
3825 (long) htab_size (debug_expr_for_decl
),
3826 (long) htab_elements (debug_expr_for_decl
),
3827 htab_collisions (debug_expr_for_decl
));
3830 /* Print out the statistics for the DECL_VALUE_EXPR hash table. */
3833 print_value_expr_statistics (void)
3835 fprintf (stderr
, "DECL_VALUE_EXPR hash: size %ld, %ld elements, %f collisions\n",
3836 (long) htab_size (value_expr_for_decl
),
3837 (long) htab_elements (value_expr_for_decl
),
3838 htab_collisions (value_expr_for_decl
));
3841 /* Print out statistics for the RESTRICT_BASE_FOR_DECL hash table, but
3842 don't print anything if the table is empty. */
3845 print_restrict_base_statistics (void)
3847 if (htab_elements (restrict_base_for_decl
) != 0)
3849 "RESTRICT_BASE hash: size %ld, %ld elements, %f collisions\n",
3850 (long) htab_size (restrict_base_for_decl
),
3851 (long) htab_elements (restrict_base_for_decl
),
3852 htab_collisions (restrict_base_for_decl
));
3855 /* Lookup a debug expression for FROM, and return it if we find one. */
3858 decl_debug_expr_lookup (tree from
)
3860 struct tree_map
*h
, in
;
3863 h
= htab_find_with_hash (debug_expr_for_decl
, &in
, htab_hash_pointer (from
));
3869 /* Insert a mapping FROM->TO in the debug expression hashtable. */
3872 decl_debug_expr_insert (tree from
, tree to
)
3877 h
= ggc_alloc (sizeof (struct tree_map
));
3878 h
->hash
= htab_hash_pointer (from
);
3881 loc
= htab_find_slot_with_hash (debug_expr_for_decl
, h
, h
->hash
, INSERT
);
3882 *(struct tree_map
**) loc
= h
;
3885 /* Lookup a value expression for FROM, and return it if we find one. */
3888 decl_value_expr_lookup (tree from
)
3890 struct tree_map
*h
, in
;
3893 h
= htab_find_with_hash (value_expr_for_decl
, &in
, htab_hash_pointer (from
));
3899 /* Insert a mapping FROM->TO in the value expression hashtable. */
3902 decl_value_expr_insert (tree from
, tree to
)
3907 h
= ggc_alloc (sizeof (struct tree_map
));
3908 h
->hash
= htab_hash_pointer (from
);
3911 loc
= htab_find_slot_with_hash (value_expr_for_decl
, h
, h
->hash
, INSERT
);
3912 *(struct tree_map
**) loc
= h
;
3915 /* Hashing of types so that we don't make duplicates.
3916 The entry point is `type_hash_canon'. */
3918 /* Compute a hash code for a list of types (chain of TREE_LIST nodes
3919 with types in the TREE_VALUE slots), by adding the hash codes
3920 of the individual types. */
3923 type_hash_list (tree list
, hashval_t hashcode
)
3927 for (tail
= list
; tail
; tail
= TREE_CHAIN (tail
))
3928 if (TREE_VALUE (tail
) != error_mark_node
)
3929 hashcode
= iterative_hash_object (TYPE_HASH (TREE_VALUE (tail
)),
3935 /* These are the Hashtable callback functions. */
3937 /* Returns true iff the types are equivalent. */
3940 type_hash_eq (const void *va
, const void *vb
)
3942 const struct type_hash
*a
= va
, *b
= vb
;
3944 /* First test the things that are the same for all types. */
3945 if (a
->hash
!= b
->hash
3946 || TREE_CODE (a
->type
) != TREE_CODE (b
->type
)
3947 || TREE_TYPE (a
->type
) != TREE_TYPE (b
->type
)
3948 || !attribute_list_equal (TYPE_ATTRIBUTES (a
->type
),
3949 TYPE_ATTRIBUTES (b
->type
))
3950 || TYPE_ALIGN (a
->type
) != TYPE_ALIGN (b
->type
)
3951 || TYPE_MODE (a
->type
) != TYPE_MODE (b
->type
))
3954 switch (TREE_CODE (a
->type
))
3959 case REFERENCE_TYPE
:
3963 return TYPE_VECTOR_SUBPARTS (a
->type
) == TYPE_VECTOR_SUBPARTS (b
->type
);
3966 if (TYPE_VALUES (a
->type
) != TYPE_VALUES (b
->type
)
3967 && !(TYPE_VALUES (a
->type
)
3968 && TREE_CODE (TYPE_VALUES (a
->type
)) == TREE_LIST
3969 && TYPE_VALUES (b
->type
)
3970 && TREE_CODE (TYPE_VALUES (b
->type
)) == TREE_LIST
3971 && type_list_equal (TYPE_VALUES (a
->type
),
3972 TYPE_VALUES (b
->type
))))
3975 /* ... fall through ... */
3981 return ((TYPE_MAX_VALUE (a
->type
) == TYPE_MAX_VALUE (b
->type
)
3982 || tree_int_cst_equal (TYPE_MAX_VALUE (a
->type
),
3983 TYPE_MAX_VALUE (b
->type
)))
3984 && (TYPE_MIN_VALUE (a
->type
) == TYPE_MIN_VALUE (b
->type
)
3985 || tree_int_cst_equal (TYPE_MIN_VALUE (a
->type
),
3986 TYPE_MIN_VALUE (b
->type
))));
3989 return TYPE_OFFSET_BASETYPE (a
->type
) == TYPE_OFFSET_BASETYPE (b
->type
);
3992 return (TYPE_METHOD_BASETYPE (a
->type
) == TYPE_METHOD_BASETYPE (b
->type
)
3993 && (TYPE_ARG_TYPES (a
->type
) == TYPE_ARG_TYPES (b
->type
)
3994 || (TYPE_ARG_TYPES (a
->type
)
3995 && TREE_CODE (TYPE_ARG_TYPES (a
->type
)) == TREE_LIST
3996 && TYPE_ARG_TYPES (b
->type
)
3997 && TREE_CODE (TYPE_ARG_TYPES (b
->type
)) == TREE_LIST
3998 && type_list_equal (TYPE_ARG_TYPES (a
->type
),
3999 TYPE_ARG_TYPES (b
->type
)))));
4002 return TYPE_DOMAIN (a
->type
) == TYPE_DOMAIN (b
->type
);
4006 case QUAL_UNION_TYPE
:
4007 return (TYPE_FIELDS (a
->type
) == TYPE_FIELDS (b
->type
)
4008 || (TYPE_FIELDS (a
->type
)
4009 && TREE_CODE (TYPE_FIELDS (a
->type
)) == TREE_LIST
4010 && TYPE_FIELDS (b
->type
)
4011 && TREE_CODE (TYPE_FIELDS (b
->type
)) == TREE_LIST
4012 && type_list_equal (TYPE_FIELDS (a
->type
),
4013 TYPE_FIELDS (b
->type
))));
4016 return (TYPE_ARG_TYPES (a
->type
) == TYPE_ARG_TYPES (b
->type
)
4017 || (TYPE_ARG_TYPES (a
->type
)
4018 && TREE_CODE (TYPE_ARG_TYPES (a
->type
)) == TREE_LIST
4019 && TYPE_ARG_TYPES (b
->type
)
4020 && TREE_CODE (TYPE_ARG_TYPES (b
->type
)) == TREE_LIST
4021 && type_list_equal (TYPE_ARG_TYPES (a
->type
),
4022 TYPE_ARG_TYPES (b
->type
))));
4029 /* Return the cached hash value. */
4032 type_hash_hash (const void *item
)
4034 return ((const struct type_hash
*) item
)->hash
;
4037 /* Look in the type hash table for a type isomorphic to TYPE.
4038 If one is found, return it. Otherwise return 0. */
4041 type_hash_lookup (hashval_t hashcode
, tree type
)
4043 struct type_hash
*h
, in
;
4045 /* The TYPE_ALIGN field of a type is set by layout_type(), so we
4046 must call that routine before comparing TYPE_ALIGNs. */
4052 h
= htab_find_with_hash (type_hash_table
, &in
, hashcode
);
4058 /* Add an entry to the type-hash-table
4059 for a type TYPE whose hash code is HASHCODE. */
4062 type_hash_add (hashval_t hashcode
, tree type
)
4064 struct type_hash
*h
;
4067 h
= ggc_alloc (sizeof (struct type_hash
));
4070 loc
= htab_find_slot_with_hash (type_hash_table
, h
, hashcode
, INSERT
);
4071 *(struct type_hash
**) loc
= h
;
4074 /* Given TYPE, and HASHCODE its hash code, return the canonical
4075 object for an identical type if one already exists.
4076 Otherwise, return TYPE, and record it as the canonical object.
4078 To use this function, first create a type of the sort you want.
4079 Then compute its hash code from the fields of the type that
4080 make it different from other similar types.
4081 Then call this function and use the value. */
4084 type_hash_canon (unsigned int hashcode
, tree type
)
4088 /* The hash table only contains main variants, so ensure that's what we're
4090 gcc_assert (TYPE_MAIN_VARIANT (type
) == type
);
4092 if (!lang_hooks
.types
.hash_types
)
4095 /* See if the type is in the hash table already. If so, return it.
4096 Otherwise, add the type. */
4097 t1
= type_hash_lookup (hashcode
, type
);
4100 #ifdef GATHER_STATISTICS
4101 tree_node_counts
[(int) t_kind
]--;
4102 tree_node_sizes
[(int) t_kind
] -= sizeof (struct tree_type
);
4108 type_hash_add (hashcode
, type
);
4113 /* See if the data pointed to by the type hash table is marked. We consider
4114 it marked if the type is marked or if a debug type number or symbol
4115 table entry has been made for the type. This reduces the amount of
4116 debugging output and eliminates that dependency of the debug output on
4117 the number of garbage collections. */
4120 type_hash_marked_p (const void *p
)
4122 tree type
= ((struct type_hash
*) p
)->type
;
4124 return ggc_marked_p (type
) || TYPE_SYMTAB_POINTER (type
);
4128 print_type_hash_statistics (void)
4130 fprintf (stderr
, "Type hash: size %ld, %ld elements, %f collisions\n",
4131 (long) htab_size (type_hash_table
),
4132 (long) htab_elements (type_hash_table
),
4133 htab_collisions (type_hash_table
));
4136 /* Compute a hash code for a list of attributes (chain of TREE_LIST nodes
4137 with names in the TREE_PURPOSE slots and args in the TREE_VALUE slots),
4138 by adding the hash codes of the individual attributes. */
4141 attribute_hash_list (tree list
, hashval_t hashcode
)
4145 for (tail
= list
; tail
; tail
= TREE_CHAIN (tail
))
4146 /* ??? Do we want to add in TREE_VALUE too? */
4147 hashcode
= iterative_hash_object
4148 (IDENTIFIER_HASH_VALUE (TREE_PURPOSE (tail
)), hashcode
);
4152 /* Given two lists of attributes, return true if list l2 is
4153 equivalent to l1. */
4156 attribute_list_equal (tree l1
, tree l2
)
4158 return attribute_list_contained (l1
, l2
)
4159 && attribute_list_contained (l2
, l1
);
4162 /* Given two lists of attributes, return true if list L2 is
4163 completely contained within L1. */
4164 /* ??? This would be faster if attribute names were stored in a canonicalized
4165 form. Otherwise, if L1 uses `foo' and L2 uses `__foo__', the long method
4166 must be used to show these elements are equivalent (which they are). */
4167 /* ??? It's not clear that attributes with arguments will always be handled
4171 attribute_list_contained (tree l1
, tree l2
)
4175 /* First check the obvious, maybe the lists are identical. */
4179 /* Maybe the lists are similar. */
4180 for (t1
= l1
, t2
= l2
;
4182 && TREE_PURPOSE (t1
) == TREE_PURPOSE (t2
)
4183 && TREE_VALUE (t1
) == TREE_VALUE (t2
);
4184 t1
= TREE_CHAIN (t1
), t2
= TREE_CHAIN (t2
));
4186 /* Maybe the lists are equal. */
4187 if (t1
== 0 && t2
== 0)
4190 for (; t2
!= 0; t2
= TREE_CHAIN (t2
))
4193 for (attr
= lookup_attribute (IDENTIFIER_POINTER (TREE_PURPOSE (t2
)), l1
);
4195 attr
= lookup_attribute (IDENTIFIER_POINTER (TREE_PURPOSE (t2
)),
4198 if (simple_cst_equal (TREE_VALUE (t2
), TREE_VALUE (attr
)) == 1)
4205 if (simple_cst_equal (TREE_VALUE (t2
), TREE_VALUE (attr
)) != 1)
4212 /* Given two lists of types
4213 (chains of TREE_LIST nodes with types in the TREE_VALUE slots)
4214 return 1 if the lists contain the same types in the same order.
4215 Also, the TREE_PURPOSEs must match. */
4218 type_list_equal (tree l1
, tree l2
)
4222 for (t1
= l1
, t2
= l2
; t1
&& t2
; t1
= TREE_CHAIN (t1
), t2
= TREE_CHAIN (t2
))
4223 if (TREE_VALUE (t1
) != TREE_VALUE (t2
)
4224 || (TREE_PURPOSE (t1
) != TREE_PURPOSE (t2
)
4225 && ! (1 == simple_cst_equal (TREE_PURPOSE (t1
), TREE_PURPOSE (t2
))
4226 && (TREE_TYPE (TREE_PURPOSE (t1
))
4227 == TREE_TYPE (TREE_PURPOSE (t2
))))))
4233 /* Returns the number of arguments to the FUNCTION_TYPE or METHOD_TYPE
4234 given by TYPE. If the argument list accepts variable arguments,
4235 then this function counts only the ordinary arguments. */
4238 type_num_arguments (tree type
)
4243 for (t
= TYPE_ARG_TYPES (type
); t
; t
= TREE_CHAIN (t
))
4244 /* If the function does not take a variable number of arguments,
4245 the last element in the list will have type `void'. */
4246 if (VOID_TYPE_P (TREE_VALUE (t
)))
4254 /* Nonzero if integer constants T1 and T2
4255 represent the same constant value. */
4258 tree_int_cst_equal (tree t1
, tree t2
)
4263 if (t1
== 0 || t2
== 0)
4266 if (TREE_CODE (t1
) == INTEGER_CST
4267 && TREE_CODE (t2
) == INTEGER_CST
4268 && TREE_INT_CST_LOW (t1
) == TREE_INT_CST_LOW (t2
)
4269 && TREE_INT_CST_HIGH (t1
) == TREE_INT_CST_HIGH (t2
))
4275 /* Nonzero if integer constants T1 and T2 represent values that satisfy <.
4276 The precise way of comparison depends on their data type. */
4279 tree_int_cst_lt (tree t1
, tree t2
)
4284 if (TYPE_UNSIGNED (TREE_TYPE (t1
)) != TYPE_UNSIGNED (TREE_TYPE (t2
)))
4286 int t1_sgn
= tree_int_cst_sgn (t1
);
4287 int t2_sgn
= tree_int_cst_sgn (t2
);
4289 if (t1_sgn
< t2_sgn
)
4291 else if (t1_sgn
> t2_sgn
)
4293 /* Otherwise, both are non-negative, so we compare them as
4294 unsigned just in case one of them would overflow a signed
4297 else if (!TYPE_UNSIGNED (TREE_TYPE (t1
)))
4298 return INT_CST_LT (t1
, t2
);
4300 return INT_CST_LT_UNSIGNED (t1
, t2
);
4303 /* Returns -1 if T1 < T2, 0 if T1 == T2, and 1 if T1 > T2. */
4306 tree_int_cst_compare (tree t1
, tree t2
)
4308 if (tree_int_cst_lt (t1
, t2
))
4310 else if (tree_int_cst_lt (t2
, t1
))
4316 /* Return 1 if T is an INTEGER_CST that can be manipulated efficiently on
4317 the host. If POS is zero, the value can be represented in a single
4318 HOST_WIDE_INT. If POS is nonzero, the value must be non-negative and can
4319 be represented in a single unsigned HOST_WIDE_INT. */
4322 host_integerp (tree t
, int pos
)
4324 return (TREE_CODE (t
) == INTEGER_CST
4325 && ! TREE_OVERFLOW (t
)
4326 && ((TREE_INT_CST_HIGH (t
) == 0
4327 && (HOST_WIDE_INT
) TREE_INT_CST_LOW (t
) >= 0)
4328 || (! pos
&& TREE_INT_CST_HIGH (t
) == -1
4329 && (HOST_WIDE_INT
) TREE_INT_CST_LOW (t
) < 0
4330 && !TYPE_UNSIGNED (TREE_TYPE (t
)))
4331 || (pos
&& TREE_INT_CST_HIGH (t
) == 0)));
4334 /* Return the HOST_WIDE_INT least significant bits of T if it is an
4335 INTEGER_CST and there is no overflow. POS is nonzero if the result must
4336 be non-negative. We must be able to satisfy the above conditions. */
4339 tree_low_cst (tree t
, int pos
)
4341 gcc_assert (host_integerp (t
, pos
));
4342 return TREE_INT_CST_LOW (t
);
4345 /* Return the most significant bit of the integer constant T. */
4348 tree_int_cst_msb (tree t
)
4352 unsigned HOST_WIDE_INT l
;
4354 /* Note that using TYPE_PRECISION here is wrong. We care about the
4355 actual bits, not the (arbitrary) range of the type. */
4356 prec
= GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (t
))) - 1;
4357 rshift_double (TREE_INT_CST_LOW (t
), TREE_INT_CST_HIGH (t
), prec
,
4358 2 * HOST_BITS_PER_WIDE_INT
, &l
, &h
, 0);
4359 return (l
& 1) == 1;
4362 /* Return an indication of the sign of the integer constant T.
4363 The return value is -1 if T < 0, 0 if T == 0, and 1 if T > 0.
4364 Note that -1 will never be returned it T's type is unsigned. */
4367 tree_int_cst_sgn (tree t
)
4369 if (TREE_INT_CST_LOW (t
) == 0 && TREE_INT_CST_HIGH (t
) == 0)
4371 else if (TYPE_UNSIGNED (TREE_TYPE (t
)))
4373 else if (TREE_INT_CST_HIGH (t
) < 0)
4379 /* Compare two constructor-element-type constants. Return 1 if the lists
4380 are known to be equal; otherwise return 0. */
4383 simple_cst_list_equal (tree l1
, tree l2
)
4385 while (l1
!= NULL_TREE
&& l2
!= NULL_TREE
)
4387 if (simple_cst_equal (TREE_VALUE (l1
), TREE_VALUE (l2
)) != 1)
4390 l1
= TREE_CHAIN (l1
);
4391 l2
= TREE_CHAIN (l2
);
4397 /* Return truthvalue of whether T1 is the same tree structure as T2.
4398 Return 1 if they are the same.
4399 Return 0 if they are understandably different.
4400 Return -1 if either contains tree structure not understood by
4404 simple_cst_equal (tree t1
, tree t2
)
4406 enum tree_code code1
, code2
;
4412 if (t1
== 0 || t2
== 0)
4415 code1
= TREE_CODE (t1
);
4416 code2
= TREE_CODE (t2
);
4418 if (code1
== NOP_EXPR
|| code1
== CONVERT_EXPR
|| code1
== NON_LVALUE_EXPR
)
4420 if (code2
== NOP_EXPR
|| code2
== CONVERT_EXPR
4421 || code2
== NON_LVALUE_EXPR
)
4422 return simple_cst_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
4424 return simple_cst_equal (TREE_OPERAND (t1
, 0), t2
);
4427 else if (code2
== NOP_EXPR
|| code2
== CONVERT_EXPR
4428 || code2
== NON_LVALUE_EXPR
)
4429 return simple_cst_equal (t1
, TREE_OPERAND (t2
, 0));
4437 return (TREE_INT_CST_LOW (t1
) == TREE_INT_CST_LOW (t2
)
4438 && TREE_INT_CST_HIGH (t1
) == TREE_INT_CST_HIGH (t2
));
4441 return REAL_VALUES_IDENTICAL (TREE_REAL_CST (t1
), TREE_REAL_CST (t2
));
4444 return (TREE_STRING_LENGTH (t1
) == TREE_STRING_LENGTH (t2
)
4445 && ! memcmp (TREE_STRING_POINTER (t1
), TREE_STRING_POINTER (t2
),
4446 TREE_STRING_LENGTH (t1
)));
4450 unsigned HOST_WIDE_INT idx
;
4451 VEC(constructor_elt
, gc
) *v1
= CONSTRUCTOR_ELTS (t1
);
4452 VEC(constructor_elt
, gc
) *v2
= CONSTRUCTOR_ELTS (t2
);
4454 if (VEC_length (constructor_elt
, v1
) != VEC_length (constructor_elt
, v2
))
4457 for (idx
= 0; idx
< VEC_length (constructor_elt
, v1
); ++idx
)
4458 /* ??? Should we handle also fields here? */
4459 if (!simple_cst_equal (VEC_index (constructor_elt
, v1
, idx
)->value
,
4460 VEC_index (constructor_elt
, v2
, idx
)->value
))
4466 return simple_cst_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
4469 cmp
= simple_cst_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
4473 simple_cst_list_equal (TREE_OPERAND (t1
, 1), TREE_OPERAND (t2
, 1));
4476 /* Special case: if either target is an unallocated VAR_DECL,
4477 it means that it's going to be unified with whatever the
4478 TARGET_EXPR is really supposed to initialize, so treat it
4479 as being equivalent to anything. */
4480 if ((TREE_CODE (TREE_OPERAND (t1
, 0)) == VAR_DECL
4481 && DECL_NAME (TREE_OPERAND (t1
, 0)) == NULL_TREE
4482 && !DECL_RTL_SET_P (TREE_OPERAND (t1
, 0)))
4483 || (TREE_CODE (TREE_OPERAND (t2
, 0)) == VAR_DECL
4484 && DECL_NAME (TREE_OPERAND (t2
, 0)) == NULL_TREE
4485 && !DECL_RTL_SET_P (TREE_OPERAND (t2
, 0))))
4488 cmp
= simple_cst_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
4493 return simple_cst_equal (TREE_OPERAND (t1
, 1), TREE_OPERAND (t2
, 1));
4495 case WITH_CLEANUP_EXPR
:
4496 cmp
= simple_cst_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
4500 return simple_cst_equal (TREE_OPERAND (t1
, 1), TREE_OPERAND (t1
, 1));
4503 if (TREE_OPERAND (t1
, 1) == TREE_OPERAND (t2
, 1))
4504 return simple_cst_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
4518 /* This general rule works for most tree codes. All exceptions should be
4519 handled above. If this is a language-specific tree code, we can't
4520 trust what might be in the operand, so say we don't know
4522 if ((int) code1
>= (int) LAST_AND_UNUSED_TREE_CODE
)
4525 switch (TREE_CODE_CLASS (code1
))
4529 case tcc_comparison
:
4530 case tcc_expression
:
4534 for (i
= 0; i
< TREE_CODE_LENGTH (code1
); i
++)
4536 cmp
= simple_cst_equal (TREE_OPERAND (t1
, i
), TREE_OPERAND (t2
, i
));
4548 /* Compare the value of T, an INTEGER_CST, with U, an unsigned integer value.
4549 Return -1, 0, or 1 if the value of T is less than, equal to, or greater
4550 than U, respectively. */
4553 compare_tree_int (tree t
, unsigned HOST_WIDE_INT u
)
4555 if (tree_int_cst_sgn (t
) < 0)
4557 else if (TREE_INT_CST_HIGH (t
) != 0)
4559 else if (TREE_INT_CST_LOW (t
) == u
)
4561 else if (TREE_INT_CST_LOW (t
) < u
)
4567 /* Return true if CODE represents an associative tree code. Otherwise
4570 associative_tree_code (enum tree_code code
)
4589 /* Return true if CODE represents a commutative tree code. Otherwise
4592 commutative_tree_code (enum tree_code code
)
4605 case UNORDERED_EXPR
:
4609 case TRUTH_AND_EXPR
:
4610 case TRUTH_XOR_EXPR
:
4620 /* Generate a hash value for an expression. This can be used iteratively
4621 by passing a previous result as the "val" argument.
4623 This function is intended to produce the same hash for expressions which
4624 would compare equal using operand_equal_p. */
4627 iterative_hash_expr (tree t
, hashval_t val
)
4630 enum tree_code code
;
4634 return iterative_hash_pointer (t
, val
);
4636 code
= TREE_CODE (t
);
4640 /* Alas, constants aren't shared, so we can't rely on pointer
4643 val
= iterative_hash_host_wide_int (TREE_INT_CST_LOW (t
), val
);
4644 return iterative_hash_host_wide_int (TREE_INT_CST_HIGH (t
), val
);
4647 unsigned int val2
= real_hash (TREE_REAL_CST_PTR (t
));
4649 return iterative_hash_hashval_t (val2
, val
);
4652 return iterative_hash (TREE_STRING_POINTER (t
),
4653 TREE_STRING_LENGTH (t
), val
);
4655 val
= iterative_hash_expr (TREE_REALPART (t
), val
);
4656 return iterative_hash_expr (TREE_IMAGPART (t
), val
);
4658 return iterative_hash_expr (TREE_VECTOR_CST_ELTS (t
), val
);
4662 /* we can just compare by pointer. */
4663 return iterative_hash_pointer (t
, val
);
4666 /* A list of expressions, for a CALL_EXPR or as the elements of a
4668 for (; t
; t
= TREE_CHAIN (t
))
4669 val
= iterative_hash_expr (TREE_VALUE (t
), val
);
4673 unsigned HOST_WIDE_INT idx
;
4675 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t
), idx
, field
, value
)
4677 val
= iterative_hash_expr (field
, val
);
4678 val
= iterative_hash_expr (value
, val
);
4683 /* When referring to a built-in FUNCTION_DECL, use the
4684 __builtin__ form. Otherwise nodes that compare equal
4685 according to operand_equal_p might get different
4687 if (DECL_BUILT_IN (t
))
4689 val
= iterative_hash_pointer (built_in_decls
[DECL_FUNCTION_CODE (t
)],
4693 /* else FALL THROUGH */
4695 class = TREE_CODE_CLASS (code
);
4697 if (class == tcc_declaration
)
4699 /* Otherwise, we can just compare decls by pointer. */
4700 val
= iterative_hash_pointer (t
, val
);
4704 gcc_assert (IS_EXPR_CODE_CLASS (class));
4706 val
= iterative_hash_object (code
, val
);
4708 /* Don't hash the type, that can lead to having nodes which
4709 compare equal according to operand_equal_p, but which
4710 have different hash codes. */
4711 if (code
== NOP_EXPR
4712 || code
== CONVERT_EXPR
4713 || code
== NON_LVALUE_EXPR
)
4715 /* Make sure to include signness in the hash computation. */
4716 val
+= TYPE_UNSIGNED (TREE_TYPE (t
));
4717 val
= iterative_hash_expr (TREE_OPERAND (t
, 0), val
);
4720 else if (commutative_tree_code (code
))
4722 /* It's a commutative expression. We want to hash it the same
4723 however it appears. We do this by first hashing both operands
4724 and then rehashing based on the order of their independent
4726 hashval_t one
= iterative_hash_expr (TREE_OPERAND (t
, 0), 0);
4727 hashval_t two
= iterative_hash_expr (TREE_OPERAND (t
, 1), 0);
4731 t
= one
, one
= two
, two
= t
;
4733 val
= iterative_hash_hashval_t (one
, val
);
4734 val
= iterative_hash_hashval_t (two
, val
);
4737 for (i
= TREE_CODE_LENGTH (code
) - 1; i
>= 0; --i
)
4738 val
= iterative_hash_expr (TREE_OPERAND (t
, i
), val
);
4745 /* Constructors for pointer, array and function types.
4746 (RECORD_TYPE, UNION_TYPE and ENUMERAL_TYPE nodes are
4747 constructed by language-dependent code, not here.) */
4749 /* Construct, lay out and return the type of pointers to TO_TYPE with
4750 mode MODE. If CAN_ALIAS_ALL is TRUE, indicate this type can
4751 reference all of memory. If such a type has already been
4752 constructed, reuse it. */
4755 build_pointer_type_for_mode (tree to_type
, enum machine_mode mode
,
4760 if (to_type
== error_mark_node
)
4761 return error_mark_node
;
4763 /* In some cases, languages will have things that aren't a POINTER_TYPE
4764 (such as a RECORD_TYPE for fat pointers in Ada) as TYPE_POINTER_TO.
4765 In that case, return that type without regard to the rest of our
4768 ??? This is a kludge, but consistent with the way this function has
4769 always operated and there doesn't seem to be a good way to avoid this
4771 if (TYPE_POINTER_TO (to_type
) != 0
4772 && TREE_CODE (TYPE_POINTER_TO (to_type
)) != POINTER_TYPE
)
4773 return TYPE_POINTER_TO (to_type
);
4775 /* First, if we already have a type for pointers to TO_TYPE and it's
4776 the proper mode, use it. */
4777 for (t
= TYPE_POINTER_TO (to_type
); t
; t
= TYPE_NEXT_PTR_TO (t
))
4778 if (TYPE_MODE (t
) == mode
&& TYPE_REF_CAN_ALIAS_ALL (t
) == can_alias_all
)
4781 t
= make_node (POINTER_TYPE
);
4783 TREE_TYPE (t
) = to_type
;
4784 TYPE_MODE (t
) = mode
;
4785 TYPE_REF_CAN_ALIAS_ALL (t
) = can_alias_all
;
4786 TYPE_NEXT_PTR_TO (t
) = TYPE_POINTER_TO (to_type
);
4787 TYPE_POINTER_TO (to_type
) = t
;
4789 /* Lay out the type. This function has many callers that are concerned
4790 with expression-construction, and this simplifies them all. */
4796 /* By default build pointers in ptr_mode. */
4799 build_pointer_type (tree to_type
)
4801 return build_pointer_type_for_mode (to_type
, ptr_mode
, false);
4804 /* Same as build_pointer_type_for_mode, but for REFERENCE_TYPE. */
4807 build_reference_type_for_mode (tree to_type
, enum machine_mode mode
,
4812 /* In some cases, languages will have things that aren't a REFERENCE_TYPE
4813 (such as a RECORD_TYPE for fat pointers in Ada) as TYPE_REFERENCE_TO.
4814 In that case, return that type without regard to the rest of our
4817 ??? This is a kludge, but consistent with the way this function has
4818 always operated and there doesn't seem to be a good way to avoid this
4820 if (TYPE_REFERENCE_TO (to_type
) != 0
4821 && TREE_CODE (TYPE_REFERENCE_TO (to_type
)) != REFERENCE_TYPE
)
4822 return TYPE_REFERENCE_TO (to_type
);
4824 /* First, if we already have a type for pointers to TO_TYPE and it's
4825 the proper mode, use it. */
4826 for (t
= TYPE_REFERENCE_TO (to_type
); t
; t
= TYPE_NEXT_REF_TO (t
))
4827 if (TYPE_MODE (t
) == mode
&& TYPE_REF_CAN_ALIAS_ALL (t
) == can_alias_all
)
4830 t
= make_node (REFERENCE_TYPE
);
4832 TREE_TYPE (t
) = to_type
;
4833 TYPE_MODE (t
) = mode
;
4834 TYPE_REF_CAN_ALIAS_ALL (t
) = can_alias_all
;
4835 TYPE_NEXT_REF_TO (t
) = TYPE_REFERENCE_TO (to_type
);
4836 TYPE_REFERENCE_TO (to_type
) = t
;
4844 /* Build the node for the type of references-to-TO_TYPE by default
4848 build_reference_type (tree to_type
)
4850 return build_reference_type_for_mode (to_type
, ptr_mode
, false);
4853 /* Build a type that is compatible with t but has no cv quals anywhere
4856 const char *const *const * -> char ***. */
4859 build_type_no_quals (tree t
)
4861 switch (TREE_CODE (t
))
4864 return build_pointer_type_for_mode (build_type_no_quals (TREE_TYPE (t
)),
4866 TYPE_REF_CAN_ALIAS_ALL (t
));
4867 case REFERENCE_TYPE
:
4869 build_reference_type_for_mode (build_type_no_quals (TREE_TYPE (t
)),
4871 TYPE_REF_CAN_ALIAS_ALL (t
));
4873 return TYPE_MAIN_VARIANT (t
);
4877 /* Create a type of integers to be the TYPE_DOMAIN of an ARRAY_TYPE.
4878 MAXVAL should be the maximum value in the domain
4879 (one less than the length of the array).
4881 The maximum value that MAXVAL can have is INT_MAX for a HOST_WIDE_INT.
4882 We don't enforce this limit, that is up to caller (e.g. language front end).
4883 The limit exists because the result is a signed type and we don't handle
4884 sizes that use more than one HOST_WIDE_INT. */
4887 build_index_type (tree maxval
)
4889 tree itype
= make_node (INTEGER_TYPE
);
4891 TREE_TYPE (itype
) = sizetype
;
4892 TYPE_PRECISION (itype
) = TYPE_PRECISION (sizetype
);
4893 TYPE_MIN_VALUE (itype
) = size_zero_node
;
4894 TYPE_MAX_VALUE (itype
) = fold_convert (sizetype
, maxval
);
4895 TYPE_MODE (itype
) = TYPE_MODE (sizetype
);
4896 TYPE_SIZE (itype
) = TYPE_SIZE (sizetype
);
4897 TYPE_SIZE_UNIT (itype
) = TYPE_SIZE_UNIT (sizetype
);
4898 TYPE_ALIGN (itype
) = TYPE_ALIGN (sizetype
);
4899 TYPE_USER_ALIGN (itype
) = TYPE_USER_ALIGN (sizetype
);
4901 if (host_integerp (maxval
, 1))
4902 return type_hash_canon (tree_low_cst (maxval
, 1), itype
);
4907 /* Builds a signed or unsigned integer type of precision PRECISION.
4908 Used for C bitfields whose precision does not match that of
4909 built-in target types. */
4911 build_nonstandard_integer_type (unsigned HOST_WIDE_INT precision
,
4914 tree itype
= make_node (INTEGER_TYPE
);
4916 TYPE_PRECISION (itype
) = precision
;
4919 fixup_unsigned_type (itype
);
4921 fixup_signed_type (itype
);
4923 if (host_integerp (TYPE_MAX_VALUE (itype
), 1))
4924 return type_hash_canon (tree_low_cst (TYPE_MAX_VALUE (itype
), 1), itype
);
4929 /* Create a range of some discrete type TYPE (an INTEGER_TYPE,
4930 ENUMERAL_TYPE, BOOLEAN_TYPE, or CHAR_TYPE), with
4931 low bound LOWVAL and high bound HIGHVAL.
4932 if TYPE==NULL_TREE, sizetype is used. */
4935 build_range_type (tree type
, tree lowval
, tree highval
)
4937 tree itype
= make_node (INTEGER_TYPE
);
4939 TREE_TYPE (itype
) = type
;
4940 if (type
== NULL_TREE
)
4943 TYPE_MIN_VALUE (itype
) = convert (type
, lowval
);
4944 TYPE_MAX_VALUE (itype
) = highval
? convert (type
, highval
) : NULL
;
4946 TYPE_PRECISION (itype
) = TYPE_PRECISION (type
);
4947 TYPE_MODE (itype
) = TYPE_MODE (type
);
4948 TYPE_SIZE (itype
) = TYPE_SIZE (type
);
4949 TYPE_SIZE_UNIT (itype
) = TYPE_SIZE_UNIT (type
);
4950 TYPE_ALIGN (itype
) = TYPE_ALIGN (type
);
4951 TYPE_USER_ALIGN (itype
) = TYPE_USER_ALIGN (type
);
4953 if (host_integerp (lowval
, 0) && highval
!= 0 && host_integerp (highval
, 0))
4954 return type_hash_canon (tree_low_cst (highval
, 0)
4955 - tree_low_cst (lowval
, 0),
4961 /* Just like build_index_type, but takes lowval and highval instead
4962 of just highval (maxval). */
4965 build_index_2_type (tree lowval
, tree highval
)
4967 return build_range_type (sizetype
, lowval
, highval
);
4970 /* Construct, lay out and return the type of arrays of elements with ELT_TYPE
4971 and number of elements specified by the range of values of INDEX_TYPE.
4972 If such a type has already been constructed, reuse it. */
4975 build_array_type (tree elt_type
, tree index_type
)
4978 hashval_t hashcode
= 0;
4980 if (TREE_CODE (elt_type
) == FUNCTION_TYPE
)
4982 error ("arrays of functions are not meaningful");
4983 elt_type
= integer_type_node
;
4986 t
= make_node (ARRAY_TYPE
);
4987 TREE_TYPE (t
) = elt_type
;
4988 TYPE_DOMAIN (t
) = index_type
;
4990 if (index_type
== 0)
4996 hashcode
= iterative_hash_object (TYPE_HASH (elt_type
), hashcode
);
4997 hashcode
= iterative_hash_object (TYPE_HASH (index_type
), hashcode
);
4998 t
= type_hash_canon (hashcode
, t
);
5000 if (!COMPLETE_TYPE_P (t
))
5005 /* Return the TYPE of the elements comprising
5006 the innermost dimension of ARRAY. */
5009 get_inner_array_type (tree array
)
5011 tree type
= TREE_TYPE (array
);
5013 while (TREE_CODE (type
) == ARRAY_TYPE
)
5014 type
= TREE_TYPE (type
);
5019 /* Construct, lay out and return
5020 the type of functions returning type VALUE_TYPE
5021 given arguments of types ARG_TYPES.
5022 ARG_TYPES is a chain of TREE_LIST nodes whose TREE_VALUEs
5023 are data type nodes for the arguments of the function.
5024 If such a type has already been constructed, reuse it. */
5027 build_function_type (tree value_type
, tree arg_types
)
5030 hashval_t hashcode
= 0;
5032 if (TREE_CODE (value_type
) == FUNCTION_TYPE
)
5034 error ("function return type cannot be function");
5035 value_type
= integer_type_node
;
5038 /* Make a node of the sort we want. */
5039 t
= make_node (FUNCTION_TYPE
);
5040 TREE_TYPE (t
) = value_type
;
5041 TYPE_ARG_TYPES (t
) = arg_types
;
5043 /* If we already have such a type, use the old one. */
5044 hashcode
= iterative_hash_object (TYPE_HASH (value_type
), hashcode
);
5045 hashcode
= type_hash_list (arg_types
, hashcode
);
5046 t
= type_hash_canon (hashcode
, t
);
5048 if (!COMPLETE_TYPE_P (t
))
5053 /* Build a function type. The RETURN_TYPE is the type returned by the
5054 function. If additional arguments are provided, they are
5055 additional argument types. The list of argument types must always
5056 be terminated by NULL_TREE. */
5059 build_function_type_list (tree return_type
, ...)
5064 va_start (p
, return_type
);
5066 t
= va_arg (p
, tree
);
5067 for (args
= NULL_TREE
; t
!= NULL_TREE
; t
= va_arg (p
, tree
))
5068 args
= tree_cons (NULL_TREE
, t
, args
);
5070 if (args
== NULL_TREE
)
5071 args
= void_list_node
;
5075 args
= nreverse (args
);
5076 TREE_CHAIN (last
) = void_list_node
;
5078 args
= build_function_type (return_type
, args
);
5084 /* Build a METHOD_TYPE for a member of BASETYPE. The RETTYPE (a TYPE)
5085 and ARGTYPES (a TREE_LIST) are the return type and arguments types
5086 for the method. An implicit additional parameter (of type
5087 pointer-to-BASETYPE) is added to the ARGTYPES. */
5090 build_method_type_directly (tree basetype
,
5098 /* Make a node of the sort we want. */
5099 t
= make_node (METHOD_TYPE
);
5101 TYPE_METHOD_BASETYPE (t
) = TYPE_MAIN_VARIANT (basetype
);
5102 TREE_TYPE (t
) = rettype
;
5103 ptype
= build_pointer_type (basetype
);
5105 /* The actual arglist for this function includes a "hidden" argument
5106 which is "this". Put it into the list of argument types. */
5107 argtypes
= tree_cons (NULL_TREE
, ptype
, argtypes
);
5108 TYPE_ARG_TYPES (t
) = argtypes
;
5110 /* If we already have such a type, use the old one. */
5111 hashcode
= iterative_hash_object (TYPE_HASH (basetype
), hashcode
);
5112 hashcode
= iterative_hash_object (TYPE_HASH (rettype
), hashcode
);
5113 hashcode
= type_hash_list (argtypes
, hashcode
);
5114 t
= type_hash_canon (hashcode
, t
);
5116 if (!COMPLETE_TYPE_P (t
))
5122 /* Construct, lay out and return the type of methods belonging to class
5123 BASETYPE and whose arguments and values are described by TYPE.
5124 If that type exists already, reuse it.
5125 TYPE must be a FUNCTION_TYPE node. */
5128 build_method_type (tree basetype
, tree type
)
5130 gcc_assert (TREE_CODE (type
) == FUNCTION_TYPE
);
5132 return build_method_type_directly (basetype
,
5134 TYPE_ARG_TYPES (type
));
5137 /* Construct, lay out and return the type of offsets to a value
5138 of type TYPE, within an object of type BASETYPE.
5139 If a suitable offset type exists already, reuse it. */
5142 build_offset_type (tree basetype
, tree type
)
5145 hashval_t hashcode
= 0;
5147 /* Make a node of the sort we want. */
5148 t
= make_node (OFFSET_TYPE
);
5150 TYPE_OFFSET_BASETYPE (t
) = TYPE_MAIN_VARIANT (basetype
);
5151 TREE_TYPE (t
) = type
;
5153 /* If we already have such a type, use the old one. */
5154 hashcode
= iterative_hash_object (TYPE_HASH (basetype
), hashcode
);
5155 hashcode
= iterative_hash_object (TYPE_HASH (type
), hashcode
);
5156 t
= type_hash_canon (hashcode
, t
);
5158 if (!COMPLETE_TYPE_P (t
))
5164 /* Create a complex type whose components are COMPONENT_TYPE. */
5167 build_complex_type (tree component_type
)
5172 /* Make a node of the sort we want. */
5173 t
= make_node (COMPLEX_TYPE
);
5175 TREE_TYPE (t
) = TYPE_MAIN_VARIANT (component_type
);
5177 /* If we already have such a type, use the old one. */
5178 hashcode
= iterative_hash_object (TYPE_HASH (component_type
), 0);
5179 t
= type_hash_canon (hashcode
, t
);
5181 if (!COMPLETE_TYPE_P (t
))
5184 /* If we are writing Dwarf2 output we need to create a name,
5185 since complex is a fundamental type. */
5186 if ((write_symbols
== DWARF2_DEBUG
|| write_symbols
== VMS_AND_DWARF2_DEBUG
)
5190 if (component_type
== char_type_node
)
5191 name
= "complex char";
5192 else if (component_type
== signed_char_type_node
)
5193 name
= "complex signed char";
5194 else if (component_type
== unsigned_char_type_node
)
5195 name
= "complex unsigned char";
5196 else if (component_type
== short_integer_type_node
)
5197 name
= "complex short int";
5198 else if (component_type
== short_unsigned_type_node
)
5199 name
= "complex short unsigned int";
5200 else if (component_type
== integer_type_node
)
5201 name
= "complex int";
5202 else if (component_type
== unsigned_type_node
)
5203 name
= "complex unsigned int";
5204 else if (component_type
== long_integer_type_node
)
5205 name
= "complex long int";
5206 else if (component_type
== long_unsigned_type_node
)
5207 name
= "complex long unsigned int";
5208 else if (component_type
== long_long_integer_type_node
)
5209 name
= "complex long long int";
5210 else if (component_type
== long_long_unsigned_type_node
)
5211 name
= "complex long long unsigned int";
5216 TYPE_NAME (t
) = get_identifier (name
);
5219 return build_qualified_type (t
, TYPE_QUALS (component_type
));
5222 /* Return OP, stripped of any conversions to wider types as much as is safe.
5223 Converting the value back to OP's type makes a value equivalent to OP.
5225 If FOR_TYPE is nonzero, we return a value which, if converted to
5226 type FOR_TYPE, would be equivalent to converting OP to type FOR_TYPE.
5228 If FOR_TYPE is nonzero, unaligned bit-field references may be changed to the
5229 narrowest type that can hold the value, even if they don't exactly fit.
5230 Otherwise, bit-field references are changed to a narrower type
5231 only if they can be fetched directly from memory in that type.
5233 OP must have integer, real or enumeral type. Pointers are not allowed!
5235 There are some cases where the obvious value we could return
5236 would regenerate to OP if converted to OP's type,
5237 but would not extend like OP to wider types.
5238 If FOR_TYPE indicates such extension is contemplated, we eschew such values.
5239 For example, if OP is (unsigned short)(signed char)-1,
5240 we avoid returning (signed char)-1 if FOR_TYPE is int,
5241 even though extending that to an unsigned short would regenerate OP,
5242 since the result of extending (signed char)-1 to (int)
5243 is different from (int) OP. */
5246 get_unwidened (tree op
, tree for_type
)
5248 /* Set UNS initially if converting OP to FOR_TYPE is a zero-extension. */
5249 tree type
= TREE_TYPE (op
);
5251 = TYPE_PRECISION (for_type
!= 0 ? for_type
: type
);
5253 = (for_type
!= 0 && for_type
!= type
5254 && final_prec
> TYPE_PRECISION (type
)
5255 && TYPE_UNSIGNED (type
));
5258 while (TREE_CODE (op
) == NOP_EXPR
5259 || TREE_CODE (op
) == CONVERT_EXPR
)
5263 /* TYPE_PRECISION on vector types has different meaning
5264 (TYPE_VECTOR_SUBPARTS) and casts from vectors are view conversions,
5265 so avoid them here. */
5266 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (op
, 0))) == VECTOR_TYPE
)
5269 bitschange
= TYPE_PRECISION (TREE_TYPE (op
))
5270 - TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op
, 0)));
5272 /* Truncations are many-one so cannot be removed.
5273 Unless we are later going to truncate down even farther. */
5275 && final_prec
> TYPE_PRECISION (TREE_TYPE (op
)))
5278 /* See what's inside this conversion. If we decide to strip it,
5280 op
= TREE_OPERAND (op
, 0);
5282 /* If we have not stripped any zero-extensions (uns is 0),
5283 we can strip any kind of extension.
5284 If we have previously stripped a zero-extension,
5285 only zero-extensions can safely be stripped.
5286 Any extension can be stripped if the bits it would produce
5287 are all going to be discarded later by truncating to FOR_TYPE. */
5291 if (! uns
|| final_prec
<= TYPE_PRECISION (TREE_TYPE (op
)))
5293 /* TYPE_UNSIGNED says whether this is a zero-extension.
5294 Let's avoid computing it if it does not affect WIN
5295 and if UNS will not be needed again. */
5297 || TREE_CODE (op
) == NOP_EXPR
5298 || TREE_CODE (op
) == CONVERT_EXPR
)
5299 && TYPE_UNSIGNED (TREE_TYPE (op
)))
5307 if (TREE_CODE (op
) == COMPONENT_REF
5308 /* Since type_for_size always gives an integer type. */
5309 && TREE_CODE (type
) != REAL_TYPE
5310 /* Don't crash if field not laid out yet. */
5311 && DECL_SIZE (TREE_OPERAND (op
, 1)) != 0
5312 && host_integerp (DECL_SIZE (TREE_OPERAND (op
, 1)), 1))
5314 unsigned int innerprec
5315 = tree_low_cst (DECL_SIZE (TREE_OPERAND (op
, 1)), 1);
5316 int unsignedp
= (DECL_UNSIGNED (TREE_OPERAND (op
, 1))
5317 || TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op
, 1))));
5318 type
= lang_hooks
.types
.type_for_size (innerprec
, unsignedp
);
5320 /* We can get this structure field in the narrowest type it fits in.
5321 If FOR_TYPE is 0, do this only for a field that matches the
5322 narrower type exactly and is aligned for it
5323 The resulting extension to its nominal type (a fullword type)
5324 must fit the same conditions as for other extensions. */
5327 && INT_CST_LT_UNSIGNED (TYPE_SIZE (type
), TYPE_SIZE (TREE_TYPE (op
)))
5328 && (for_type
|| ! DECL_BIT_FIELD (TREE_OPERAND (op
, 1)))
5329 && (! uns
|| final_prec
<= innerprec
|| unsignedp
))
5331 win
= build3 (COMPONENT_REF
, type
, TREE_OPERAND (op
, 0),
5332 TREE_OPERAND (op
, 1), NULL_TREE
);
5333 TREE_SIDE_EFFECTS (win
) = TREE_SIDE_EFFECTS (op
);
5334 TREE_THIS_VOLATILE (win
) = TREE_THIS_VOLATILE (op
);
5341 /* Return OP or a simpler expression for a narrower value
5342 which can be sign-extended or zero-extended to give back OP.
5343 Store in *UNSIGNEDP_PTR either 1 if the value should be zero-extended
5344 or 0 if the value should be sign-extended. */
5347 get_narrower (tree op
, int *unsignedp_ptr
)
5352 bool integral_p
= INTEGRAL_TYPE_P (TREE_TYPE (op
));
5354 while (TREE_CODE (op
) == NOP_EXPR
)
5357 = (TYPE_PRECISION (TREE_TYPE (op
))
5358 - TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op
, 0))));
5360 /* Truncations are many-one so cannot be removed. */
5364 /* See what's inside this conversion. If we decide to strip it,
5369 op
= TREE_OPERAND (op
, 0);
5370 /* An extension: the outermost one can be stripped,
5371 but remember whether it is zero or sign extension. */
5373 uns
= TYPE_UNSIGNED (TREE_TYPE (op
));
5374 /* Otherwise, if a sign extension has been stripped,
5375 only sign extensions can now be stripped;
5376 if a zero extension has been stripped, only zero-extensions. */
5377 else if (uns
!= TYPE_UNSIGNED (TREE_TYPE (op
)))
5381 else /* bitschange == 0 */
5383 /* A change in nominal type can always be stripped, but we must
5384 preserve the unsignedness. */
5386 uns
= TYPE_UNSIGNED (TREE_TYPE (op
));
5388 op
= TREE_OPERAND (op
, 0);
5389 /* Keep trying to narrow, but don't assign op to win if it
5390 would turn an integral type into something else. */
5391 if (INTEGRAL_TYPE_P (TREE_TYPE (op
)) != integral_p
)
5398 if (TREE_CODE (op
) == COMPONENT_REF
5399 /* Since type_for_size always gives an integer type. */
5400 && TREE_CODE (TREE_TYPE (op
)) != REAL_TYPE
5401 /* Ensure field is laid out already. */
5402 && DECL_SIZE (TREE_OPERAND (op
, 1)) != 0
5403 && host_integerp (DECL_SIZE (TREE_OPERAND (op
, 1)), 1))
5405 unsigned HOST_WIDE_INT innerprec
5406 = tree_low_cst (DECL_SIZE (TREE_OPERAND (op
, 1)), 1);
5407 int unsignedp
= (DECL_UNSIGNED (TREE_OPERAND (op
, 1))
5408 || TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op
, 1))));
5409 tree type
= lang_hooks
.types
.type_for_size (innerprec
, unsignedp
);
5411 /* We can get this structure field in a narrower type that fits it,
5412 but the resulting extension to its nominal type (a fullword type)
5413 must satisfy the same conditions as for other extensions.
5415 Do this only for fields that are aligned (not bit-fields),
5416 because when bit-field insns will be used there is no
5417 advantage in doing this. */
5419 if (innerprec
< TYPE_PRECISION (TREE_TYPE (op
))
5420 && ! DECL_BIT_FIELD (TREE_OPERAND (op
, 1))
5421 && (first
|| uns
== DECL_UNSIGNED (TREE_OPERAND (op
, 1)))
5425 uns
= DECL_UNSIGNED (TREE_OPERAND (op
, 1));
5426 win
= build3 (COMPONENT_REF
, type
, TREE_OPERAND (op
, 0),
5427 TREE_OPERAND (op
, 1), NULL_TREE
);
5428 TREE_SIDE_EFFECTS (win
) = TREE_SIDE_EFFECTS (op
);
5429 TREE_THIS_VOLATILE (win
) = TREE_THIS_VOLATILE (op
);
5432 *unsignedp_ptr
= uns
;
5436 /* Nonzero if integer constant C has a value that is permissible
5437 for type TYPE (an INTEGER_TYPE). */
5440 int_fits_type_p (tree c
, tree type
)
5442 tree type_low_bound
= TYPE_MIN_VALUE (type
);
5443 tree type_high_bound
= TYPE_MAX_VALUE (type
);
5444 bool ok_for_low_bound
, ok_for_high_bound
;
5447 /* If at least one bound of the type is a constant integer, we can check
5448 ourselves and maybe make a decision. If no such decision is possible, but
5449 this type is a subtype, try checking against that. Otherwise, use
5450 force_fit_type, which checks against the precision.
5452 Compute the status for each possibly constant bound, and return if we see
5453 one does not match. Use ok_for_xxx_bound for this purpose, assigning -1
5454 for "unknown if constant fits", 0 for "constant known *not* to fit" and 1
5455 for "constant known to fit". */
5457 /* Check if C >= type_low_bound. */
5458 if (type_low_bound
&& TREE_CODE (type_low_bound
) == INTEGER_CST
)
5460 if (tree_int_cst_lt (c
, type_low_bound
))
5462 ok_for_low_bound
= true;
5465 ok_for_low_bound
= false;
5467 /* Check if c <= type_high_bound. */
5468 if (type_high_bound
&& TREE_CODE (type_high_bound
) == INTEGER_CST
)
5470 if (tree_int_cst_lt (type_high_bound
, c
))
5472 ok_for_high_bound
= true;
5475 ok_for_high_bound
= false;
5477 /* If the constant fits both bounds, the result is known. */
5478 if (ok_for_low_bound
&& ok_for_high_bound
)
5481 /* Perform some generic filtering which may allow making a decision
5482 even if the bounds are not constant. First, negative integers
5483 never fit in unsigned types, */
5484 if (TYPE_UNSIGNED (type
) && tree_int_cst_sgn (c
) < 0)
5487 /* Second, narrower types always fit in wider ones. */
5488 if (TYPE_PRECISION (type
) > TYPE_PRECISION (TREE_TYPE (c
)))
5491 /* Third, unsigned integers with top bit set never fit signed types. */
5492 if (! TYPE_UNSIGNED (type
)
5493 && TYPE_UNSIGNED (TREE_TYPE (c
))
5494 && tree_int_cst_msb (c
))
5497 /* If we haven't been able to decide at this point, there nothing more we
5498 can check ourselves here. Look at the base type if we have one. */
5499 if (TREE_CODE (type
) == INTEGER_TYPE
&& TREE_TYPE (type
) != 0)
5500 return int_fits_type_p (c
, TREE_TYPE (type
));
5502 /* Or to force_fit_type, if nothing else. */
5503 tmp
= copy_node (c
);
5504 TREE_TYPE (tmp
) = type
;
5505 tmp
= force_fit_type (tmp
, -1, false, false);
5506 return TREE_INT_CST_HIGH (tmp
) == TREE_INT_CST_HIGH (c
)
5507 && TREE_INT_CST_LOW (tmp
) == TREE_INT_CST_LOW (c
);
5510 /* Subprogram of following function. Called by walk_tree.
5512 Return *TP if it is an automatic variable or parameter of the
5513 function passed in as DATA. */
5516 find_var_from_fn (tree
*tp
, int *walk_subtrees
, void *data
)
5518 tree fn
= (tree
) data
;
5523 else if (DECL_P (*tp
)
5524 && lang_hooks
.tree_inlining
.auto_var_in_fn_p (*tp
, fn
))
5530 /* Returns true if T is, contains, or refers to a type with variable
5531 size. If FN is nonzero, only return true if a modifier of the type
5532 or position of FN is a variable or parameter inside FN.
5534 This concept is more general than that of C99 'variably modified types':
5535 in C99, a struct type is never variably modified because a VLA may not
5536 appear as a structure member. However, in GNU C code like:
5538 struct S { int i[f()]; };
5540 is valid, and other languages may define similar constructs. */
5543 variably_modified_type_p (tree type
, tree fn
)
5547 /* Test if T is either variable (if FN is zero) or an expression containing
5548 a variable in FN. */
5549 #define RETURN_TRUE_IF_VAR(T) \
5550 do { tree _t = (T); \
5551 if (_t && _t != error_mark_node && TREE_CODE (_t) != INTEGER_CST \
5552 && (!fn || walk_tree (&_t, find_var_from_fn, fn, NULL))) \
5553 return true; } while (0)
5555 if (type
== error_mark_node
)
5558 /* If TYPE itself has variable size, it is variably modified.
5560 We do not yet have a representation of the C99 '[*]' syntax.
5561 When a representation is chosen, this function should be modified
5562 to test for that case as well. */
5563 RETURN_TRUE_IF_VAR (TYPE_SIZE (type
));
5564 RETURN_TRUE_IF_VAR (TYPE_SIZE_UNIT(type
));
5566 switch (TREE_CODE (type
))
5569 case REFERENCE_TYPE
:
5572 if (variably_modified_type_p (TREE_TYPE (type
), fn
))
5578 /* If TYPE is a function type, it is variably modified if any of the
5579 parameters or the return type are variably modified. */
5580 if (variably_modified_type_p (TREE_TYPE (type
), fn
))
5583 for (t
= TYPE_ARG_TYPES (type
);
5584 t
&& t
!= void_list_node
;
5586 if (variably_modified_type_p (TREE_VALUE (t
), fn
))
5595 /* Scalar types are variably modified if their end points
5597 RETURN_TRUE_IF_VAR (TYPE_MIN_VALUE (type
));
5598 RETURN_TRUE_IF_VAR (TYPE_MAX_VALUE (type
));
5603 case QUAL_UNION_TYPE
:
5604 /* We can't see if any of the field are variably-modified by the
5605 definition we normally use, since that would produce infinite
5606 recursion via pointers. */
5607 /* This is variably modified if some field's type is. */
5608 for (t
= TYPE_FIELDS (type
); t
; t
= TREE_CHAIN (t
))
5609 if (TREE_CODE (t
) == FIELD_DECL
)
5611 RETURN_TRUE_IF_VAR (DECL_FIELD_OFFSET (t
));
5612 RETURN_TRUE_IF_VAR (DECL_SIZE (t
));
5613 RETURN_TRUE_IF_VAR (DECL_SIZE_UNIT (t
));
5615 if (TREE_CODE (type
) == QUAL_UNION_TYPE
)
5616 RETURN_TRUE_IF_VAR (DECL_QUALIFIER (t
));
5624 /* The current language may have other cases to check, but in general,
5625 all other types are not variably modified. */
5626 return lang_hooks
.tree_inlining
.var_mod_type_p (type
, fn
);
5628 #undef RETURN_TRUE_IF_VAR
5631 /* Given a DECL or TYPE, return the scope in which it was declared, or
5632 NULL_TREE if there is no containing scope. */
5635 get_containing_scope (tree t
)
5637 return (TYPE_P (t
) ? TYPE_CONTEXT (t
) : DECL_CONTEXT (t
));
5640 /* Return the innermost context enclosing DECL that is
5641 a FUNCTION_DECL, or zero if none. */
5644 decl_function_context (tree decl
)
5648 if (TREE_CODE (decl
) == ERROR_MARK
)
5651 /* C++ virtual functions use DECL_CONTEXT for the class of the vtable
5652 where we look up the function at runtime. Such functions always take
5653 a first argument of type 'pointer to real context'.
5655 C++ should really be fixed to use DECL_CONTEXT for the real context,
5656 and use something else for the "virtual context". */
5657 else if (TREE_CODE (decl
) == FUNCTION_DECL
&& DECL_VINDEX (decl
))
5660 (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl
)))));
5662 context
= DECL_CONTEXT (decl
);
5664 while (context
&& TREE_CODE (context
) != FUNCTION_DECL
)
5666 if (TREE_CODE (context
) == BLOCK
)
5667 context
= BLOCK_SUPERCONTEXT (context
);
5669 context
= get_containing_scope (context
);
5675 /* Return the innermost context enclosing DECL that is
5676 a RECORD_TYPE, UNION_TYPE or QUAL_UNION_TYPE, or zero if none.
5677 TYPE_DECLs and FUNCTION_DECLs are transparent to this function. */
5680 decl_type_context (tree decl
)
5682 tree context
= DECL_CONTEXT (decl
);
5685 switch (TREE_CODE (context
))
5687 case NAMESPACE_DECL
:
5688 case TRANSLATION_UNIT_DECL
:
5693 case QUAL_UNION_TYPE
:
5698 context
= DECL_CONTEXT (context
);
5702 context
= BLOCK_SUPERCONTEXT (context
);
5712 /* CALL is a CALL_EXPR. Return the declaration for the function
5713 called, or NULL_TREE if the called function cannot be
5717 get_callee_fndecl (tree call
)
5721 /* It's invalid to call this function with anything but a
5723 gcc_assert (TREE_CODE (call
) == CALL_EXPR
);
5725 /* The first operand to the CALL is the address of the function
5727 addr
= TREE_OPERAND (call
, 0);
5731 /* If this is a readonly function pointer, extract its initial value. */
5732 if (DECL_P (addr
) && TREE_CODE (addr
) != FUNCTION_DECL
5733 && TREE_READONLY (addr
) && ! TREE_THIS_VOLATILE (addr
)
5734 && DECL_INITIAL (addr
))
5735 addr
= DECL_INITIAL (addr
);
5737 /* If the address is just `&f' for some function `f', then we know
5738 that `f' is being called. */
5739 if (TREE_CODE (addr
) == ADDR_EXPR
5740 && TREE_CODE (TREE_OPERAND (addr
, 0)) == FUNCTION_DECL
)
5741 return TREE_OPERAND (addr
, 0);
5743 /* We couldn't figure out what was being called. Maybe the front
5744 end has some idea. */
5745 return lang_hooks
.lang_get_callee_fndecl (call
);
5748 /* Print debugging information about tree nodes generated during the compile,
5749 and any language-specific information. */
5752 dump_tree_statistics (void)
5754 #ifdef GATHER_STATISTICS
5756 int total_nodes
, total_bytes
;
5759 fprintf (stderr
, "\n??? tree nodes created\n\n");
5760 #ifdef GATHER_STATISTICS
5761 fprintf (stderr
, "Kind Nodes Bytes\n");
5762 fprintf (stderr
, "---------------------------------------\n");
5763 total_nodes
= total_bytes
= 0;
5764 for (i
= 0; i
< (int) all_kinds
; i
++)
5766 fprintf (stderr
, "%-20s %7d %10d\n", tree_node_kind_names
[i
],
5767 tree_node_counts
[i
], tree_node_sizes
[i
]);
5768 total_nodes
+= tree_node_counts
[i
];
5769 total_bytes
+= tree_node_sizes
[i
];
5771 fprintf (stderr
, "---------------------------------------\n");
5772 fprintf (stderr
, "%-20s %7d %10d\n", "Total", total_nodes
, total_bytes
);
5773 fprintf (stderr
, "---------------------------------------\n");
5774 ssanames_print_statistics ();
5775 phinodes_print_statistics ();
5777 fprintf (stderr
, "(No per-node statistics)\n");
5779 print_type_hash_statistics ();
5780 print_debug_expr_statistics ();
5781 print_value_expr_statistics ();
5782 print_restrict_base_statistics ();
5783 lang_hooks
.print_statistics ();
5786 #define FILE_FUNCTION_FORMAT "_GLOBAL__%s_%s"
5788 /* Generate a crc32 of a string. */
5791 crc32_string (unsigned chksum
, const char *string
)
5795 unsigned value
= *string
<< 24;
5798 for (ix
= 8; ix
--; value
<<= 1)
5802 feedback
= (value
^ chksum
) & 0x80000000 ? 0x04c11db7 : 0;
5811 /* P is a string that will be used in a symbol. Mask out any characters
5812 that are not valid in that context. */
5815 clean_symbol_name (char *p
)
5819 #ifndef NO_DOLLAR_IN_LABEL /* this for `$'; unlikely, but... -- kr */
5822 #ifndef NO_DOT_IN_LABEL /* this for `.'; unlikely, but... */
5829 /* Generate a name for a function unique to this translation unit.
5830 TYPE is some string to identify the purpose of this function to the
5831 linker or collect2. */
5834 get_file_function_name_long (const char *type
)
5840 if (first_global_object_name
)
5841 p
= first_global_object_name
;
5844 /* We don't have anything that we know to be unique to this translation
5845 unit, so use what we do have and throw in some randomness. */
5847 const char *name
= weak_global_object_name
;
5848 const char *file
= main_input_filename
;
5853 file
= input_filename
;
5855 len
= strlen (file
);
5856 q
= alloca (9 * 2 + len
+ 1);
5857 memcpy (q
, file
, len
+ 1);
5858 clean_symbol_name (q
);
5860 sprintf (q
+ len
, "_%08X_%08X", crc32_string (0, name
),
5861 crc32_string (0, flag_random_seed
));
5866 buf
= alloca (sizeof (FILE_FUNCTION_FORMAT
) + strlen (p
) + strlen (type
));
5868 /* Set up the name of the file-level functions we may need.
5869 Use a global object (which is already required to be unique over
5870 the program) rather than the file name (which imposes extra
5872 sprintf (buf
, FILE_FUNCTION_FORMAT
, type
, p
);
5874 return get_identifier (buf
);
5877 /* If KIND=='I', return a suitable global initializer (constructor) name.
5878 If KIND=='D', return a suitable global clean-up (destructor) name. */
5881 get_file_function_name (int kind
)
5888 return get_file_function_name_long (p
);
5891 #if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
5893 /* Complain that the tree code of NODE does not match the expected 0
5894 terminated list of trailing codes. The trailing code list can be
5895 empty, for a more vague error message. FILE, LINE, and FUNCTION
5896 are of the caller. */
5899 tree_check_failed (const tree node
, const char *file
,
5900 int line
, const char *function
, ...)
5904 unsigned length
= 0;
5907 va_start (args
, function
);
5908 while ((code
= va_arg (args
, int)))
5909 length
+= 4 + strlen (tree_code_name
[code
]);
5913 va_start (args
, function
);
5914 length
+= strlen ("expected ");
5915 buffer
= alloca (length
);
5917 while ((code
= va_arg (args
, int)))
5919 const char *prefix
= length
? " or " : "expected ";
5921 strcpy (buffer
+ length
, prefix
);
5922 length
+= strlen (prefix
);
5923 strcpy (buffer
+ length
, tree_code_name
[code
]);
5924 length
+= strlen (tree_code_name
[code
]);
5929 buffer
= (char *)"unexpected node";
5931 internal_error ("tree check: %s, have %s in %s, at %s:%d",
5932 buffer
, tree_code_name
[TREE_CODE (node
)],
5933 function
, trim_filename (file
), line
);
5936 /* Complain that the tree code of NODE does match the expected 0
5937 terminated list of trailing codes. FILE, LINE, and FUNCTION are of
5941 tree_not_check_failed (const tree node
, const char *file
,
5942 int line
, const char *function
, ...)
5946 unsigned length
= 0;
5949 va_start (args
, function
);
5950 while ((code
= va_arg (args
, int)))
5951 length
+= 4 + strlen (tree_code_name
[code
]);
5953 va_start (args
, function
);
5954 buffer
= alloca (length
);
5956 while ((code
= va_arg (args
, int)))
5960 strcpy (buffer
+ length
, " or ");
5963 strcpy (buffer
+ length
, tree_code_name
[code
]);
5964 length
+= strlen (tree_code_name
[code
]);
5968 internal_error ("tree check: expected none of %s, have %s in %s, at %s:%d",
5969 buffer
, tree_code_name
[TREE_CODE (node
)],
5970 function
, trim_filename (file
), line
);
5973 /* Similar to tree_check_failed, except that we check for a class of tree
5974 code, given in CL. */
5977 tree_class_check_failed (const tree node
, const enum tree_code_class cl
,
5978 const char *file
, int line
, const char *function
)
5981 ("tree check: expected class %qs, have %qs (%s) in %s, at %s:%d",
5982 TREE_CODE_CLASS_STRING (cl
),
5983 TREE_CODE_CLASS_STRING (TREE_CODE_CLASS (TREE_CODE (node
))),
5984 tree_code_name
[TREE_CODE (node
)], function
, trim_filename (file
), line
);
5986 #undef DEFTREESTRUCT
5987 #define DEFTREESTRUCT(VAL, NAME) NAME,
5989 static const char *ts_enum_names
[] = {
5990 #include "treestruct.def"
5992 #undef DEFTREESTRUCT
5994 #define TS_ENUM_NAME(EN) (ts_enum_names[(EN)])
5996 /* Similar to tree_class_check_failed, except that we check for
5997 whether CODE contains the tree structure identified by EN. */
6000 tree_contains_struct_check_failed (const tree node
,
6001 const enum tree_node_structure_enum en
,
6002 const char *file
, int line
,
6003 const char *function
)
6006 ("tree check: expected tree that contains %qs structure, have %qs in %s, at %s:%d",
6008 tree_code_name
[TREE_CODE (node
)], function
, trim_filename (file
), line
);
6012 /* Similar to above, except that the check is for the bounds of a TREE_VEC's
6013 (dynamically sized) vector. */
6016 tree_vec_elt_check_failed (int idx
, int len
, const char *file
, int line
,
6017 const char *function
)
6020 ("tree check: accessed elt %d of tree_vec with %d elts in %s, at %s:%d",
6021 idx
+ 1, len
, function
, trim_filename (file
), line
);
6024 /* Similar to above, except that the check is for the bounds of a PHI_NODE's
6025 (dynamically sized) vector. */
6028 phi_node_elt_check_failed (int idx
, int len
, const char *file
, int line
,
6029 const char *function
)
6032 ("tree check: accessed elt %d of phi_node with %d elts in %s, at %s:%d",
6033 idx
+ 1, len
, function
, trim_filename (file
), line
);
6036 /* Similar to above, except that the check is for the bounds of the operand
6037 vector of an expression node. */
6040 tree_operand_check_failed (int idx
, enum tree_code code
, const char *file
,
6041 int line
, const char *function
)
6044 ("tree check: accessed operand %d of %s with %d operands in %s, at %s:%d",
6045 idx
+ 1, tree_code_name
[code
], TREE_CODE_LENGTH (code
),
6046 function
, trim_filename (file
), line
);
6048 #endif /* ENABLE_TREE_CHECKING */
6050 /* Create a new vector type node holding SUBPARTS units of type INNERTYPE,
6051 and mapped to the machine mode MODE. Initialize its fields and build
6052 the information necessary for debugging output. */
6055 make_vector_type (tree innertype
, int nunits
, enum machine_mode mode
)
6057 tree t
= make_node (VECTOR_TYPE
);
6059 TREE_TYPE (t
) = TYPE_MAIN_VARIANT (innertype
);
6060 SET_TYPE_VECTOR_SUBPARTS (t
, nunits
);
6061 TYPE_MODE (t
) = mode
;
6062 TYPE_READONLY (t
) = TYPE_READONLY (innertype
);
6063 TYPE_VOLATILE (t
) = TYPE_VOLATILE (innertype
);
6068 tree index
= build_int_cst (NULL_TREE
, nunits
- 1);
6069 tree array
= build_array_type (innertype
, build_index_type (index
));
6070 tree rt
= make_node (RECORD_TYPE
);
6072 TYPE_FIELDS (rt
) = build_decl (FIELD_DECL
, get_identifier ("f"), array
);
6073 DECL_CONTEXT (TYPE_FIELDS (rt
)) = rt
;
6075 TYPE_DEBUG_REPRESENTATION_TYPE (t
) = rt
;
6076 /* In dwarfout.c, type lookup uses TYPE_UID numbers. We want to output
6077 the representation type, and we want to find that die when looking up
6078 the vector type. This is most easily achieved by making the TYPE_UID
6080 TYPE_UID (rt
) = TYPE_UID (t
);
6083 /* Build our main variant, based on the main variant of the inner type. */
6084 if (TYPE_MAIN_VARIANT (innertype
) != innertype
)
6086 tree innertype_main_variant
= TYPE_MAIN_VARIANT (innertype
);
6087 unsigned int hash
= TYPE_HASH (innertype_main_variant
);
6088 TYPE_MAIN_VARIANT (t
)
6089 = type_hash_canon (hash
, make_vector_type (innertype_main_variant
,
6097 make_or_reuse_type (unsigned size
, int unsignedp
)
6099 if (size
== INT_TYPE_SIZE
)
6100 return unsignedp
? unsigned_type_node
: integer_type_node
;
6101 if (size
== CHAR_TYPE_SIZE
)
6102 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
6103 if (size
== SHORT_TYPE_SIZE
)
6104 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
6105 if (size
== LONG_TYPE_SIZE
)
6106 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
6107 if (size
== LONG_LONG_TYPE_SIZE
)
6108 return (unsignedp
? long_long_unsigned_type_node
6109 : long_long_integer_type_node
);
6112 return make_unsigned_type (size
);
6114 return make_signed_type (size
);
6117 /* Create nodes for all integer types (and error_mark_node) using the sizes
6118 of C datatypes. The caller should call set_sizetype soon after calling
6119 this function to select one of the types as sizetype. */
6122 build_common_tree_nodes (bool signed_char
, bool signed_sizetype
)
6124 error_mark_node
= make_node (ERROR_MARK
);
6125 TREE_TYPE (error_mark_node
) = error_mark_node
;
6127 initialize_sizetypes (signed_sizetype
);
6129 /* Define both `signed char' and `unsigned char'. */
6130 signed_char_type_node
= make_signed_type (CHAR_TYPE_SIZE
);
6131 unsigned_char_type_node
= make_unsigned_type (CHAR_TYPE_SIZE
);
6133 /* Define `char', which is like either `signed char' or `unsigned char'
6134 but not the same as either. */
6137 ? make_signed_type (CHAR_TYPE_SIZE
)
6138 : make_unsigned_type (CHAR_TYPE_SIZE
));
6140 short_integer_type_node
= make_signed_type (SHORT_TYPE_SIZE
);
6141 short_unsigned_type_node
= make_unsigned_type (SHORT_TYPE_SIZE
);
6142 integer_type_node
= make_signed_type (INT_TYPE_SIZE
);
6143 unsigned_type_node
= make_unsigned_type (INT_TYPE_SIZE
);
6144 long_integer_type_node
= make_signed_type (LONG_TYPE_SIZE
);
6145 long_unsigned_type_node
= make_unsigned_type (LONG_TYPE_SIZE
);
6146 long_long_integer_type_node
= make_signed_type (LONG_LONG_TYPE_SIZE
);
6147 long_long_unsigned_type_node
= make_unsigned_type (LONG_LONG_TYPE_SIZE
);
6149 /* Define a boolean type. This type only represents boolean values but
6150 may be larger than char depending on the value of BOOL_TYPE_SIZE.
6151 Front ends which want to override this size (i.e. Java) can redefine
6152 boolean_type_node before calling build_common_tree_nodes_2. */
6153 boolean_type_node
= make_unsigned_type (BOOL_TYPE_SIZE
);
6154 TREE_SET_CODE (boolean_type_node
, BOOLEAN_TYPE
);
6155 TYPE_MAX_VALUE (boolean_type_node
) = build_int_cst (boolean_type_node
, 1);
6156 TYPE_PRECISION (boolean_type_node
) = 1;
6158 /* Fill in the rest of the sized types. Reuse existing type nodes
6160 intQI_type_node
= make_or_reuse_type (GET_MODE_BITSIZE (QImode
), 0);
6161 intHI_type_node
= make_or_reuse_type (GET_MODE_BITSIZE (HImode
), 0);
6162 intSI_type_node
= make_or_reuse_type (GET_MODE_BITSIZE (SImode
), 0);
6163 intDI_type_node
= make_or_reuse_type (GET_MODE_BITSIZE (DImode
), 0);
6164 intTI_type_node
= make_or_reuse_type (GET_MODE_BITSIZE (TImode
), 0);
6166 unsigned_intQI_type_node
= make_or_reuse_type (GET_MODE_BITSIZE (QImode
), 1);
6167 unsigned_intHI_type_node
= make_or_reuse_type (GET_MODE_BITSIZE (HImode
), 1);
6168 unsigned_intSI_type_node
= make_or_reuse_type (GET_MODE_BITSIZE (SImode
), 1);
6169 unsigned_intDI_type_node
= make_or_reuse_type (GET_MODE_BITSIZE (DImode
), 1);
6170 unsigned_intTI_type_node
= make_or_reuse_type (GET_MODE_BITSIZE (TImode
), 1);
6172 access_public_node
= get_identifier ("public");
6173 access_protected_node
= get_identifier ("protected");
6174 access_private_node
= get_identifier ("private");
6177 /* Call this function after calling build_common_tree_nodes and set_sizetype.
6178 It will create several other common tree nodes. */
6181 build_common_tree_nodes_2 (int short_double
)
6183 /* Define these next since types below may used them. */
6184 integer_zero_node
= build_int_cst (NULL_TREE
, 0);
6185 integer_one_node
= build_int_cst (NULL_TREE
, 1);
6186 integer_minus_one_node
= build_int_cst (NULL_TREE
, -1);
6188 size_zero_node
= size_int (0);
6189 size_one_node
= size_int (1);
6190 bitsize_zero_node
= bitsize_int (0);
6191 bitsize_one_node
= bitsize_int (1);
6192 bitsize_unit_node
= bitsize_int (BITS_PER_UNIT
);
6194 boolean_false_node
= TYPE_MIN_VALUE (boolean_type_node
);
6195 boolean_true_node
= TYPE_MAX_VALUE (boolean_type_node
);
6197 void_type_node
= make_node (VOID_TYPE
);
6198 layout_type (void_type_node
);
6200 /* We are not going to have real types in C with less than byte alignment,
6201 so we might as well not have any types that claim to have it. */
6202 TYPE_ALIGN (void_type_node
) = BITS_PER_UNIT
;
6203 TYPE_USER_ALIGN (void_type_node
) = 0;
6205 null_pointer_node
= build_int_cst (build_pointer_type (void_type_node
), 0);
6206 layout_type (TREE_TYPE (null_pointer_node
));
6208 ptr_type_node
= build_pointer_type (void_type_node
);
6210 = build_pointer_type (build_type_variant (void_type_node
, 1, 0));
6211 fileptr_type_node
= ptr_type_node
;
6213 float_type_node
= make_node (REAL_TYPE
);
6214 TYPE_PRECISION (float_type_node
) = FLOAT_TYPE_SIZE
;
6215 layout_type (float_type_node
);
6217 double_type_node
= make_node (REAL_TYPE
);
6219 TYPE_PRECISION (double_type_node
) = FLOAT_TYPE_SIZE
;
6221 TYPE_PRECISION (double_type_node
) = DOUBLE_TYPE_SIZE
;
6222 layout_type (double_type_node
);
6224 long_double_type_node
= make_node (REAL_TYPE
);
6225 TYPE_PRECISION (long_double_type_node
) = LONG_DOUBLE_TYPE_SIZE
;
6226 layout_type (long_double_type_node
);
6228 float_ptr_type_node
= build_pointer_type (float_type_node
);
6229 double_ptr_type_node
= build_pointer_type (double_type_node
);
6230 long_double_ptr_type_node
= build_pointer_type (long_double_type_node
);
6231 integer_ptr_type_node
= build_pointer_type (integer_type_node
);
6233 complex_integer_type_node
= make_node (COMPLEX_TYPE
);
6234 TREE_TYPE (complex_integer_type_node
) = integer_type_node
;
6235 layout_type (complex_integer_type_node
);
6237 complex_float_type_node
= make_node (COMPLEX_TYPE
);
6238 TREE_TYPE (complex_float_type_node
) = float_type_node
;
6239 layout_type (complex_float_type_node
);
6241 complex_double_type_node
= make_node (COMPLEX_TYPE
);
6242 TREE_TYPE (complex_double_type_node
) = double_type_node
;
6243 layout_type (complex_double_type_node
);
6245 complex_long_double_type_node
= make_node (COMPLEX_TYPE
);
6246 TREE_TYPE (complex_long_double_type_node
) = long_double_type_node
;
6247 layout_type (complex_long_double_type_node
);
6250 tree t
= targetm
.build_builtin_va_list ();
6252 /* Many back-ends define record types without setting TYPE_NAME.
6253 If we copied the record type here, we'd keep the original
6254 record type without a name. This breaks name mangling. So,
6255 don't copy record types and let c_common_nodes_and_builtins()
6256 declare the type to be __builtin_va_list. */
6257 if (TREE_CODE (t
) != RECORD_TYPE
)
6258 t
= build_variant_type_copy (t
);
6260 va_list_type_node
= t
;
6264 /* A subroutine of build_common_builtin_nodes. Define a builtin function. */
6267 local_define_builtin (const char *name
, tree type
, enum built_in_function code
,
6268 const char *library_name
, int ecf_flags
)
6272 decl
= lang_hooks
.builtin_function (name
, type
, code
, BUILT_IN_NORMAL
,
6273 library_name
, NULL_TREE
);
6274 if (ecf_flags
& ECF_CONST
)
6275 TREE_READONLY (decl
) = 1;
6276 if (ecf_flags
& ECF_PURE
)
6277 DECL_IS_PURE (decl
) = 1;
6278 if (ecf_flags
& ECF_NORETURN
)
6279 TREE_THIS_VOLATILE (decl
) = 1;
6280 if (ecf_flags
& ECF_NOTHROW
)
6281 TREE_NOTHROW (decl
) = 1;
6282 if (ecf_flags
& ECF_MALLOC
)
6283 DECL_IS_MALLOC (decl
) = 1;
6285 built_in_decls
[code
] = decl
;
6286 implicit_built_in_decls
[code
] = decl
;
6289 /* Call this function after instantiating all builtins that the language
6290 front end cares about. This will build the rest of the builtins that
6291 are relied upon by the tree optimizers and the middle-end. */
6294 build_common_builtin_nodes (void)
6298 if (built_in_decls
[BUILT_IN_MEMCPY
] == NULL
6299 || built_in_decls
[BUILT_IN_MEMMOVE
] == NULL
)
6301 tmp
= tree_cons (NULL_TREE
, size_type_node
, void_list_node
);
6302 tmp
= tree_cons (NULL_TREE
, const_ptr_type_node
, tmp
);
6303 tmp
= tree_cons (NULL_TREE
, ptr_type_node
, tmp
);
6304 ftype
= build_function_type (ptr_type_node
, tmp
);
6306 if (built_in_decls
[BUILT_IN_MEMCPY
] == NULL
)
6307 local_define_builtin ("__builtin_memcpy", ftype
, BUILT_IN_MEMCPY
,
6308 "memcpy", ECF_NOTHROW
);
6309 if (built_in_decls
[BUILT_IN_MEMMOVE
] == NULL
)
6310 local_define_builtin ("__builtin_memmove", ftype
, BUILT_IN_MEMMOVE
,
6311 "memmove", ECF_NOTHROW
);
6314 if (built_in_decls
[BUILT_IN_MEMCMP
] == NULL
)
6316 tmp
= tree_cons (NULL_TREE
, size_type_node
, void_list_node
);
6317 tmp
= tree_cons (NULL_TREE
, const_ptr_type_node
, tmp
);
6318 tmp
= tree_cons (NULL_TREE
, const_ptr_type_node
, tmp
);
6319 ftype
= build_function_type (integer_type_node
, tmp
);
6320 local_define_builtin ("__builtin_memcmp", ftype
, BUILT_IN_MEMCMP
,
6321 "memcmp", ECF_PURE
| ECF_NOTHROW
);
6324 if (built_in_decls
[BUILT_IN_MEMSET
] == NULL
)
6326 tmp
= tree_cons (NULL_TREE
, size_type_node
, void_list_node
);
6327 tmp
= tree_cons (NULL_TREE
, integer_type_node
, tmp
);
6328 tmp
= tree_cons (NULL_TREE
, ptr_type_node
, tmp
);
6329 ftype
= build_function_type (ptr_type_node
, tmp
);
6330 local_define_builtin ("__builtin_memset", ftype
, BUILT_IN_MEMSET
,
6331 "memset", ECF_NOTHROW
);
6334 if (built_in_decls
[BUILT_IN_ALLOCA
] == NULL
)
6336 tmp
= tree_cons (NULL_TREE
, size_type_node
, void_list_node
);
6337 ftype
= build_function_type (ptr_type_node
, tmp
);
6338 local_define_builtin ("__builtin_alloca", ftype
, BUILT_IN_ALLOCA
,
6339 "alloca", ECF_NOTHROW
| ECF_MALLOC
);
6342 tmp
= tree_cons (NULL_TREE
, ptr_type_node
, void_list_node
);
6343 tmp
= tree_cons (NULL_TREE
, ptr_type_node
, tmp
);
6344 tmp
= tree_cons (NULL_TREE
, ptr_type_node
, tmp
);
6345 ftype
= build_function_type (void_type_node
, tmp
);
6346 local_define_builtin ("__builtin_init_trampoline", ftype
,
6347 BUILT_IN_INIT_TRAMPOLINE
,
6348 "__builtin_init_trampoline", ECF_NOTHROW
);
6350 tmp
= tree_cons (NULL_TREE
, ptr_type_node
, void_list_node
);
6351 ftype
= build_function_type (ptr_type_node
, tmp
);
6352 local_define_builtin ("__builtin_adjust_trampoline", ftype
,
6353 BUILT_IN_ADJUST_TRAMPOLINE
,
6354 "__builtin_adjust_trampoline",
6355 ECF_CONST
| ECF_NOTHROW
);
6357 tmp
= tree_cons (NULL_TREE
, ptr_type_node
, void_list_node
);
6358 tmp
= tree_cons (NULL_TREE
, ptr_type_node
, tmp
);
6359 ftype
= build_function_type (void_type_node
, tmp
);
6360 local_define_builtin ("__builtin_nonlocal_goto", ftype
,
6361 BUILT_IN_NONLOCAL_GOTO
,
6362 "__builtin_nonlocal_goto",
6363 ECF_NORETURN
| ECF_NOTHROW
);
6365 ftype
= build_function_type (ptr_type_node
, void_list_node
);
6366 local_define_builtin ("__builtin_stack_save", ftype
, BUILT_IN_STACK_SAVE
,
6367 "__builtin_stack_save", ECF_NOTHROW
);
6369 tmp
= tree_cons (NULL_TREE
, ptr_type_node
, void_list_node
);
6370 ftype
= build_function_type (void_type_node
, tmp
);
6371 local_define_builtin ("__builtin_stack_restore", ftype
,
6372 BUILT_IN_STACK_RESTORE
,
6373 "__builtin_stack_restore", ECF_NOTHROW
);
6375 ftype
= build_function_type (void_type_node
, void_list_node
);
6376 local_define_builtin ("__builtin_profile_func_enter", ftype
,
6377 BUILT_IN_PROFILE_FUNC_ENTER
, "profile_func_enter", 0);
6378 local_define_builtin ("__builtin_profile_func_exit", ftype
,
6379 BUILT_IN_PROFILE_FUNC_EXIT
, "profile_func_exit", 0);
6381 /* Complex multiplication and division. These are handled as builtins
6382 rather than optabs because emit_library_call_value doesn't support
6383 complex. Further, we can do slightly better with folding these
6384 beasties if the real and complex parts of the arguments are separate. */
6386 enum machine_mode mode
;
6388 for (mode
= MIN_MODE_COMPLEX_FLOAT
; mode
<= MAX_MODE_COMPLEX_FLOAT
; ++mode
)
6390 char mode_name_buf
[4], *q
;
6392 enum built_in_function mcode
, dcode
;
6393 tree type
, inner_type
;
6395 type
= lang_hooks
.types
.type_for_mode (mode
, 0);
6398 inner_type
= TREE_TYPE (type
);
6400 tmp
= tree_cons (NULL_TREE
, inner_type
, void_list_node
);
6401 tmp
= tree_cons (NULL_TREE
, inner_type
, tmp
);
6402 tmp
= tree_cons (NULL_TREE
, inner_type
, tmp
);
6403 tmp
= tree_cons (NULL_TREE
, inner_type
, tmp
);
6404 ftype
= build_function_type (type
, tmp
);
6406 mcode
= BUILT_IN_COMPLEX_MUL_MIN
+ mode
- MIN_MODE_COMPLEX_FLOAT
;
6407 dcode
= BUILT_IN_COMPLEX_DIV_MIN
+ mode
- MIN_MODE_COMPLEX_FLOAT
;
6409 for (p
= GET_MODE_NAME (mode
), q
= mode_name_buf
; *p
; p
++, q
++)
6413 built_in_names
[mcode
] = concat ("__mul", mode_name_buf
, "3", NULL
);
6414 local_define_builtin (built_in_names
[mcode
], ftype
, mcode
,
6415 built_in_names
[mcode
], ECF_CONST
| ECF_NOTHROW
);
6417 built_in_names
[dcode
] = concat ("__div", mode_name_buf
, "3", NULL
);
6418 local_define_builtin (built_in_names
[dcode
], ftype
, dcode
,
6419 built_in_names
[dcode
], ECF_CONST
| ECF_NOTHROW
);
6424 /* HACK. GROSS. This is absolutely disgusting. I wish there was a
6427 If we requested a pointer to a vector, build up the pointers that
6428 we stripped off while looking for the inner type. Similarly for
6429 return values from functions.
6431 The argument TYPE is the top of the chain, and BOTTOM is the
6432 new type which we will point to. */
6435 reconstruct_complex_type (tree type
, tree bottom
)
6439 if (POINTER_TYPE_P (type
))
6441 inner
= reconstruct_complex_type (TREE_TYPE (type
), bottom
);
6442 outer
= build_pointer_type (inner
);
6444 else if (TREE_CODE (type
) == ARRAY_TYPE
)
6446 inner
= reconstruct_complex_type (TREE_TYPE (type
), bottom
);
6447 outer
= build_array_type (inner
, TYPE_DOMAIN (type
));
6449 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
6451 inner
= reconstruct_complex_type (TREE_TYPE (type
), bottom
);
6452 outer
= build_function_type (inner
, TYPE_ARG_TYPES (type
));
6454 else if (TREE_CODE (type
) == METHOD_TYPE
)
6457 inner
= reconstruct_complex_type (TREE_TYPE (type
), bottom
);
6458 /* The build_method_type_directly() routine prepends 'this' to argument list,
6459 so we must compensate by getting rid of it. */
6460 argtypes
= TYPE_ARG_TYPES (type
);
6461 outer
= build_method_type_directly (TYPE_METHOD_BASETYPE (type
),
6463 TYPE_ARG_TYPES (type
));
6464 TYPE_ARG_TYPES (outer
) = argtypes
;
6469 TYPE_READONLY (outer
) = TYPE_READONLY (type
);
6470 TYPE_VOLATILE (outer
) = TYPE_VOLATILE (type
);
6475 /* Returns a vector tree node given a mode (integer, vector, or BLKmode) and
6478 build_vector_type_for_mode (tree innertype
, enum machine_mode mode
)
6482 switch (GET_MODE_CLASS (mode
))
6484 case MODE_VECTOR_INT
:
6485 case MODE_VECTOR_FLOAT
:
6486 nunits
= GET_MODE_NUNITS (mode
);
6490 /* Check that there are no leftover bits. */
6491 gcc_assert (GET_MODE_BITSIZE (mode
)
6492 % TREE_INT_CST_LOW (TYPE_SIZE (innertype
)) == 0);
6494 nunits
= GET_MODE_BITSIZE (mode
)
6495 / TREE_INT_CST_LOW (TYPE_SIZE (innertype
));
6502 return make_vector_type (innertype
, nunits
, mode
);
6505 /* Similarly, but takes the inner type and number of units, which must be
6509 build_vector_type (tree innertype
, int nunits
)
6511 return make_vector_type (innertype
, nunits
, VOIDmode
);
6514 /* Build RESX_EXPR with given REGION_NUMBER. */
6516 build_resx (int region_number
)
6519 t
= build1 (RESX_EXPR
, void_type_node
,
6520 build_int_cst (NULL_TREE
, region_number
));
6524 /* Given an initializer INIT, return TRUE if INIT is zero or some
6525 aggregate of zeros. Otherwise return FALSE. */
6527 initializer_zerop (tree init
)
6533 switch (TREE_CODE (init
))
6536 return integer_zerop (init
);
6539 /* ??? Note that this is not correct for C4X float formats. There,
6540 a bit pattern of all zeros is 1.0; 0.0 is encoded with the most
6541 negative exponent. */
6542 return real_zerop (init
)
6543 && ! REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (init
));
6546 return integer_zerop (init
)
6547 || (real_zerop (init
)
6548 && ! REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (TREE_REALPART (init
)))
6549 && ! REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (TREE_IMAGPART (init
))));
6552 for (elt
= TREE_VECTOR_CST_ELTS (init
); elt
; elt
= TREE_CHAIN (elt
))
6553 if (!initializer_zerop (TREE_VALUE (elt
)))
6559 unsigned HOST_WIDE_INT idx
;
6561 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (init
), idx
, elt
)
6562 if (!initializer_zerop (elt
))
6573 add_var_to_bind_expr (tree bind_expr
, tree var
)
6575 BIND_EXPR_VARS (bind_expr
)
6576 = chainon (BIND_EXPR_VARS (bind_expr
), var
);
6577 if (BIND_EXPR_BLOCK (bind_expr
))
6578 BLOCK_VARS (BIND_EXPR_BLOCK (bind_expr
))
6579 = BIND_EXPR_VARS (bind_expr
);
6582 /* Build an empty statement. */
6585 build_empty_stmt (void)
6587 return build1 (NOP_EXPR
, void_type_node
, size_zero_node
);
6591 /* Returns true if it is possible to prove that the index of
6592 an array access REF (an ARRAY_REF expression) falls into the
6596 in_array_bounds_p (tree ref
)
6598 tree idx
= TREE_OPERAND (ref
, 1);
6601 if (TREE_CODE (idx
) != INTEGER_CST
)
6604 min
= array_ref_low_bound (ref
);
6605 max
= array_ref_up_bound (ref
);
6608 || TREE_CODE (min
) != INTEGER_CST
6609 || TREE_CODE (max
) != INTEGER_CST
)
6612 if (tree_int_cst_lt (idx
, min
)
6613 || tree_int_cst_lt (max
, idx
))
6619 /* Return true if T (assumed to be a DECL) is a global variable. */
6622 is_global_var (tree t
)
6624 return (TREE_STATIC (t
) || DECL_EXTERNAL (t
));
6627 /* Return true if T (assumed to be a DECL) must be assigned a memory
6631 needs_to_live_in_memory (tree t
)
6633 return (TREE_ADDRESSABLE (t
)
6634 || is_global_var (t
)
6635 || (TREE_CODE (t
) == RESULT_DECL
6636 && aggregate_value_p (t
, current_function_decl
)));
6639 /* There are situations in which a language considers record types
6640 compatible which have different field lists. Decide if two fields
6641 are compatible. It is assumed that the parent records are compatible. */
6644 fields_compatible_p (tree f1
, tree f2
)
6646 if (!operand_equal_p (DECL_FIELD_BIT_OFFSET (f1
),
6647 DECL_FIELD_BIT_OFFSET (f2
), OEP_ONLY_CONST
))
6650 if (!operand_equal_p (DECL_FIELD_OFFSET (f1
),
6651 DECL_FIELD_OFFSET (f2
), OEP_ONLY_CONST
))
6654 if (!lang_hooks
.types_compatible_p (TREE_TYPE (f1
), TREE_TYPE (f2
)))
6660 /* Locate within RECORD a field that is compatible with ORIG_FIELD. */
6663 find_compatible_field (tree record
, tree orig_field
)
6667 for (f
= TYPE_FIELDS (record
); f
; f
= TREE_CHAIN (f
))
6668 if (TREE_CODE (f
) == FIELD_DECL
6669 && fields_compatible_p (f
, orig_field
))
6672 /* ??? Why isn't this on the main fields list? */
6673 f
= TYPE_VFIELD (record
);
6674 if (f
&& TREE_CODE (f
) == FIELD_DECL
6675 && fields_compatible_p (f
, orig_field
))
6678 /* ??? We should abort here, but Java appears to do Bad Things
6679 with inherited fields. */
6683 /* Return value of a constant X. */
6686 int_cst_value (tree x
)
6688 unsigned bits
= TYPE_PRECISION (TREE_TYPE (x
));
6689 unsigned HOST_WIDE_INT val
= TREE_INT_CST_LOW (x
);
6690 bool negative
= ((val
>> (bits
- 1)) & 1) != 0;
6692 gcc_assert (bits
<= HOST_BITS_PER_WIDE_INT
);
6695 val
|= (~(unsigned HOST_WIDE_INT
) 0) << (bits
- 1) << 1;
6697 val
&= ~((~(unsigned HOST_WIDE_INT
) 0) << (bits
- 1) << 1);
6702 /* Returns the greatest common divisor of A and B, which must be
6706 tree_fold_gcd (tree a
, tree b
)
6709 tree type
= TREE_TYPE (a
);
6711 gcc_assert (TREE_CODE (a
) == INTEGER_CST
);
6712 gcc_assert (TREE_CODE (b
) == INTEGER_CST
);
6714 if (integer_zerop (a
))
6717 if (integer_zerop (b
))
6720 if (tree_int_cst_sgn (a
) == -1)
6721 a
= fold_build2 (MULT_EXPR
, type
, a
,
6722 convert (type
, integer_minus_one_node
));
6724 if (tree_int_cst_sgn (b
) == -1)
6725 b
= fold_build2 (MULT_EXPR
, type
, b
,
6726 convert (type
, integer_minus_one_node
));
6730 a_mod_b
= fold_build2 (FLOOR_MOD_EXPR
, type
, a
, b
);
6732 if (!TREE_INT_CST_LOW (a_mod_b
)
6733 && !TREE_INT_CST_HIGH (a_mod_b
))
6741 /* Returns unsigned variant of TYPE. */
6744 unsigned_type_for (tree type
)
6746 return lang_hooks
.types
.unsigned_type (type
);
6749 /* Returns signed variant of TYPE. */
6752 signed_type_for (tree type
)
6754 return lang_hooks
.types
.signed_type (type
);
6757 /* Returns the largest value obtainable by casting something in INNER type to
6761 upper_bound_in_type (tree outer
, tree inner
)
6763 unsigned HOST_WIDE_INT lo
, hi
;
6764 unsigned int det
= 0;
6765 unsigned oprec
= TYPE_PRECISION (outer
);
6766 unsigned iprec
= TYPE_PRECISION (inner
);
6769 /* Compute a unique number for every combination. */
6770 det
|= (oprec
> iprec
) ? 4 : 0;
6771 det
|= TYPE_UNSIGNED (outer
) ? 2 : 0;
6772 det
|= TYPE_UNSIGNED (inner
) ? 1 : 0;
6774 /* Determine the exponent to use. */
6779 /* oprec <= iprec, outer: signed, inner: don't care. */
6784 /* oprec <= iprec, outer: unsigned, inner: don't care. */
6788 /* oprec > iprec, outer: signed, inner: signed. */
6792 /* oprec > iprec, outer: signed, inner: unsigned. */
6796 /* oprec > iprec, outer: unsigned, inner: signed. */
6800 /* oprec > iprec, outer: unsigned, inner: unsigned. */
6807 /* Compute 2^^prec - 1. */
6808 if (prec
<= HOST_BITS_PER_WIDE_INT
)
6811 lo
= ((~(unsigned HOST_WIDE_INT
) 0)
6812 >> (HOST_BITS_PER_WIDE_INT
- prec
));
6816 hi
= ((~(unsigned HOST_WIDE_INT
) 0)
6817 >> (2 * HOST_BITS_PER_WIDE_INT
- prec
));
6818 lo
= ~(unsigned HOST_WIDE_INT
) 0;
6821 return build_int_cst_wide (outer
, lo
, hi
);
6824 /* Returns the smallest value obtainable by casting something in INNER type to
6828 lower_bound_in_type (tree outer
, tree inner
)
6830 unsigned HOST_WIDE_INT lo
, hi
;
6831 unsigned oprec
= TYPE_PRECISION (outer
);
6832 unsigned iprec
= TYPE_PRECISION (inner
);
6834 /* If OUTER type is unsigned, we can definitely cast 0 to OUTER type
6836 if (TYPE_UNSIGNED (outer
)
6837 /* If we are widening something of an unsigned type, OUTER type
6838 contains all values of INNER type. In particular, both INNER
6839 and OUTER types have zero in common. */
6840 || (oprec
> iprec
&& TYPE_UNSIGNED (inner
)))
6844 /* If we are widening a signed type to another signed type, we
6845 want to obtain -2^^(iprec-1). If we are keeping the
6846 precision or narrowing to a signed type, we want to obtain
6848 unsigned prec
= oprec
> iprec
? iprec
: oprec
;
6850 if (prec
<= HOST_BITS_PER_WIDE_INT
)
6852 hi
= ~(unsigned HOST_WIDE_INT
) 0;
6853 lo
= (~(unsigned HOST_WIDE_INT
) 0) << (prec
- 1);
6857 hi
= ((~(unsigned HOST_WIDE_INT
) 0)
6858 << (prec
- HOST_BITS_PER_WIDE_INT
- 1));
6863 return build_int_cst_wide (outer
, lo
, hi
);
6866 /* Return nonzero if two operands that are suitable for PHI nodes are
6867 necessarily equal. Specifically, both ARG0 and ARG1 must be either
6868 SSA_NAME or invariant. Note that this is strictly an optimization.
6869 That is, callers of this function can directly call operand_equal_p
6870 and get the same result, only slower. */
6873 operand_equal_for_phi_arg_p (tree arg0
, tree arg1
)
6877 if (TREE_CODE (arg0
) == SSA_NAME
|| TREE_CODE (arg1
) == SSA_NAME
)
6879 return operand_equal_p (arg0
, arg1
, 0);
6882 /* Returns number of zeros at the end of binary representation of X.
6884 ??? Use ffs if available? */
6887 num_ending_zeros (tree x
)
6889 unsigned HOST_WIDE_INT fr
, nfr
;
6890 unsigned num
, abits
;
6891 tree type
= TREE_TYPE (x
);
6893 if (TREE_INT_CST_LOW (x
) == 0)
6895 num
= HOST_BITS_PER_WIDE_INT
;
6896 fr
= TREE_INT_CST_HIGH (x
);
6901 fr
= TREE_INT_CST_LOW (x
);
6904 for (abits
= HOST_BITS_PER_WIDE_INT
/ 2; abits
; abits
/= 2)
6907 if (nfr
<< abits
== fr
)
6914 if (num
> TYPE_PRECISION (type
))
6915 num
= TYPE_PRECISION (type
);
6917 return build_int_cst_type (type
, num
);
6921 #define WALK_SUBTREE(NODE) \
6924 result = walk_tree (&(NODE), func, data, pset); \
6930 /* This is a subroutine of walk_tree that walks field of TYPE that are to
6931 be walked whenever a type is seen in the tree. Rest of operands and return
6932 value are as for walk_tree. */
6935 walk_type_fields (tree type
, walk_tree_fn func
, void *data
,
6936 struct pointer_set_t
*pset
)
6938 tree result
= NULL_TREE
;
6940 switch (TREE_CODE (type
))
6943 case REFERENCE_TYPE
:
6944 /* We have to worry about mutually recursive pointers. These can't
6945 be written in C. They can in Ada. It's pathological, but
6946 there's an ACATS test (c38102a) that checks it. Deal with this
6947 by checking if we're pointing to another pointer, that one
6948 points to another pointer, that one does too, and we have no htab.
6949 If so, get a hash table. We check three levels deep to avoid
6950 the cost of the hash table if we don't need one. */
6951 if (POINTER_TYPE_P (TREE_TYPE (type
))
6952 && POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (type
)))
6953 && POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (TREE_TYPE (type
))))
6956 result
= walk_tree_without_duplicates (&TREE_TYPE (type
),
6964 /* ... fall through ... */
6967 WALK_SUBTREE (TREE_TYPE (type
));
6971 WALK_SUBTREE (TYPE_METHOD_BASETYPE (type
));
6976 WALK_SUBTREE (TREE_TYPE (type
));
6980 /* We never want to walk into default arguments. */
6981 for (arg
= TYPE_ARG_TYPES (type
); arg
; arg
= TREE_CHAIN (arg
))
6982 WALK_SUBTREE (TREE_VALUE (arg
));
6987 /* Don't follow this nodes's type if a pointer for fear that we'll
6988 have infinite recursion. Those types are uninteresting anyway. */
6989 if (!POINTER_TYPE_P (TREE_TYPE (type
))
6990 && TREE_CODE (TREE_TYPE (type
)) != OFFSET_TYPE
)
6991 WALK_SUBTREE (TREE_TYPE (type
));
6992 WALK_SUBTREE (TYPE_DOMAIN (type
));
7000 WALK_SUBTREE (TYPE_MIN_VALUE (type
));
7001 WALK_SUBTREE (TYPE_MAX_VALUE (type
));
7005 WALK_SUBTREE (TREE_TYPE (type
));
7006 WALK_SUBTREE (TYPE_OFFSET_BASETYPE (type
));
7016 /* Apply FUNC to all the sub-trees of TP in a pre-order traversal. FUNC is
7017 called with the DATA and the address of each sub-tree. If FUNC returns a
7018 non-NULL value, the traversal is stopped, and the value returned by FUNC
7019 is returned. If PSET is non-NULL it is used to record the nodes visited,
7020 and to avoid visiting a node more than once. */
7023 walk_tree (tree
*tp
, walk_tree_fn func
, void *data
, struct pointer_set_t
*pset
)
7025 enum tree_code code
;
7029 #define WALK_SUBTREE_TAIL(NODE) \
7033 goto tail_recurse; \
7038 /* Skip empty subtrees. */
7042 /* Don't walk the same tree twice, if the user has requested
7043 that we avoid doing so. */
7044 if (pset
&& pointer_set_insert (pset
, *tp
))
7047 /* Call the function. */
7049 result
= (*func
) (tp
, &walk_subtrees
, data
);
7051 /* If we found something, return it. */
7055 code
= TREE_CODE (*tp
);
7057 /* Even if we didn't, FUNC may have decided that there was nothing
7058 interesting below this point in the tree. */
7061 if (code
== TREE_LIST
)
7062 /* But we still need to check our siblings. */
7063 WALK_SUBTREE_TAIL (TREE_CHAIN (*tp
));
7068 result
= lang_hooks
.tree_inlining
.walk_subtrees (tp
, &walk_subtrees
, func
,
7070 if (result
|| ! walk_subtrees
)
7073 /* If this is a DECL_EXPR, walk into various fields of the type that it's
7074 defining. We only want to walk into these fields of a type in this
7075 case. Note that decls get walked as part of the processing of a
7078 ??? Precisely which fields of types that we are supposed to walk in
7079 this case vs. the normal case aren't well defined. */
7080 if (code
== DECL_EXPR
7081 && TREE_CODE (DECL_EXPR_DECL (*tp
)) == TYPE_DECL
7082 && TREE_CODE (TREE_TYPE (DECL_EXPR_DECL (*tp
))) != ERROR_MARK
)
7084 tree
*type_p
= &TREE_TYPE (DECL_EXPR_DECL (*tp
));
7086 /* Call the function for the type. See if it returns anything or
7087 doesn't want us to continue. If we are to continue, walk both
7088 the normal fields and those for the declaration case. */
7089 result
= (*func
) (type_p
, &walk_subtrees
, data
);
7090 if (result
|| !walk_subtrees
)
7093 result
= walk_type_fields (*type_p
, func
, data
, pset
);
7097 WALK_SUBTREE (TYPE_SIZE (*type_p
));
7098 WALK_SUBTREE (TYPE_SIZE_UNIT (*type_p
));
7100 /* If this is a record type, also walk the fields. */
7101 if (TREE_CODE (*type_p
) == RECORD_TYPE
7102 || TREE_CODE (*type_p
) == UNION_TYPE
7103 || TREE_CODE (*type_p
) == QUAL_UNION_TYPE
)
7107 for (field
= TYPE_FIELDS (*type_p
); field
;
7108 field
= TREE_CHAIN (field
))
7110 /* We'd like to look at the type of the field, but we can easily
7111 get infinite recursion. So assume it's pointed to elsewhere
7112 in the tree. Also, ignore things that aren't fields. */
7113 if (TREE_CODE (field
) != FIELD_DECL
)
7116 WALK_SUBTREE (DECL_FIELD_OFFSET (field
));
7117 WALK_SUBTREE (DECL_SIZE (field
));
7118 WALK_SUBTREE (DECL_SIZE_UNIT (field
));
7119 if (TREE_CODE (*type_p
) == QUAL_UNION_TYPE
)
7120 WALK_SUBTREE (DECL_QUALIFIER (field
));
7125 else if (code
!= SAVE_EXPR
7126 && code
!= BIND_EXPR
7127 && IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (code
)))
7131 /* Walk over all the sub-trees of this operand. */
7132 len
= TREE_CODE_LENGTH (code
);
7133 /* TARGET_EXPRs are peculiar: operands 1 and 3 can be the same.
7134 But, we only want to walk once. */
7135 if (code
== TARGET_EXPR
7136 && TREE_OPERAND (*tp
, 3) == TREE_OPERAND (*tp
, 1))
7139 /* Go through the subtrees. We need to do this in forward order so
7140 that the scope of a FOR_EXPR is handled properly. */
7141 #ifdef DEBUG_WALK_TREE
7142 for (i
= 0; i
< len
; ++i
)
7143 WALK_SUBTREE (TREE_OPERAND (*tp
, i
));
7145 for (i
= 0; i
< len
- 1; ++i
)
7146 WALK_SUBTREE (TREE_OPERAND (*tp
, i
));
7150 /* The common case is that we may tail recurse here. */
7151 if (code
!= BIND_EXPR
7152 && !TREE_CHAIN (*tp
))
7153 WALK_SUBTREE_TAIL (TREE_OPERAND (*tp
, len
- 1));
7155 WALK_SUBTREE (TREE_OPERAND (*tp
, len
- 1));
7160 /* If this is a type, walk the needed fields in the type. */
7161 else if (TYPE_P (*tp
))
7163 result
= walk_type_fields (*tp
, func
, data
, pset
);
7169 /* Not one of the easy cases. We must explicitly go through the
7174 case IDENTIFIER_NODE
:
7180 case PLACEHOLDER_EXPR
:
7184 /* None of these have subtrees other than those already walked
7189 WALK_SUBTREE (TREE_VALUE (*tp
));
7190 WALK_SUBTREE_TAIL (TREE_CHAIN (*tp
));
7195 int len
= TREE_VEC_LENGTH (*tp
);
7200 /* Walk all elements but the first. */
7202 WALK_SUBTREE (TREE_VEC_ELT (*tp
, len
));
7204 /* Now walk the first one as a tail call. */
7205 WALK_SUBTREE_TAIL (TREE_VEC_ELT (*tp
, 0));
7209 WALK_SUBTREE (TREE_REALPART (*tp
));
7210 WALK_SUBTREE_TAIL (TREE_IMAGPART (*tp
));
7214 unsigned HOST_WIDE_INT idx
;
7215 constructor_elt
*ce
;
7218 VEC_iterate(constructor_elt
, CONSTRUCTOR_ELTS (*tp
), idx
, ce
);
7220 WALK_SUBTREE (ce
->value
);
7225 WALK_SUBTREE_TAIL (TREE_OPERAND (*tp
, 0));
7230 for (decl
= BIND_EXPR_VARS (*tp
); decl
; decl
= TREE_CHAIN (decl
))
7232 /* Walk the DECL_INITIAL and DECL_SIZE. We don't want to walk
7233 into declarations that are just mentioned, rather than
7234 declared; they don't really belong to this part of the tree.
7235 And, we can see cycles: the initializer for a declaration
7236 can refer to the declaration itself. */
7237 WALK_SUBTREE (DECL_INITIAL (decl
));
7238 WALK_SUBTREE (DECL_SIZE (decl
));
7239 WALK_SUBTREE (DECL_SIZE_UNIT (decl
));
7241 WALK_SUBTREE_TAIL (BIND_EXPR_BODY (*tp
));
7244 case STATEMENT_LIST
:
7246 tree_stmt_iterator i
;
7247 for (i
= tsi_start (*tp
); !tsi_end_p (i
); tsi_next (&i
))
7248 WALK_SUBTREE (*tsi_stmt_ptr (i
));
7253 /* ??? This could be a language-defined node. We really should make
7254 a hook for it, but right now just ignore it. */
7259 /* We didn't find what we were looking for. */
7262 #undef WALK_SUBTREE_TAIL
7266 /* Like walk_tree, but does not walk duplicate nodes more than once. */
7269 walk_tree_without_duplicates (tree
*tp
, walk_tree_fn func
, void *data
)
7272 struct pointer_set_t
*pset
;
7274 pset
= pointer_set_create ();
7275 result
= walk_tree (tp
, func
, data
, pset
);
7276 pointer_set_destroy (pset
);
7280 #include "gt-tree.h"