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 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, 59 Temple Place - Suite 330, 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.
32 The low-level allocation routines oballoc and permalloc
33 are used also for allocating many other kinds of objects
34 by all passes of the compiler. */
49 #define obstack_chunk_alloc xmalloc
50 #define obstack_chunk_free free
51 /* obstack.[ch] explicitly declined to prototype this. */
52 extern int _obstack_allocated_p PARAMS ((struct obstack *h, PTR obj));
54 static void unsave_expr_now_r PARAMS ((tree));
56 /* Objects allocated on this obstack last forever. */
58 struct obstack permanent_obstack;
60 /* Table indexed by tree code giving a string containing a character
61 classifying the tree code. Possibilities are
62 t, d, s, c, r, <, 1, 2 and e. See tree.def for details. */
64 #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) TYPE,
66 char tree_code_type[MAX_TREE_CODES] = {
71 /* Table indexed by tree code giving number of expression
72 operands beyond the fixed part of the node structure.
73 Not used for types or decls. */
75 #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) LENGTH,
77 int tree_code_length[MAX_TREE_CODES] = {
82 /* Names of tree components.
83 Used for printing out the tree and error messages. */
84 #define DEFTREECODE(SYM, NAME, TYPE, LEN) NAME,
86 const char *tree_code_name[MAX_TREE_CODES] = {
91 /* Statistics-gathering stuff. */
111 int tree_node_counts[(int) all_kinds];
112 int tree_node_sizes[(int) all_kinds];
114 static const char * const tree_node_kind_names[] = {
131 /* Unique id for next decl created. */
132 static int next_decl_uid;
133 /* Unique id for next type created. */
134 static int next_type_uid = 1;
136 /* Since we cannot rehash a type after it is in the table, we have to
137 keep the hash code. */
145 /* Initial size of the hash table (rounded to next prime). */
146 #define TYPE_HASH_INITIAL_SIZE 1000
148 /* Now here is the hash table. When recording a type, it is added to
149 the slot whose index is the hash code. Note that the hash table is
150 used for several kinds of types (function types, array types and
151 array index range types, for now). While all these live in the
152 same table, they are completely independent, and the hash code is
153 computed differently for each of these. */
155 htab_t type_hash_table;
157 static void build_real_from_int_cst_1 PARAMS ((PTR));
158 static void set_type_quals PARAMS ((tree, int));
159 static void append_random_chars PARAMS ((char *));
160 static int type_hash_eq PARAMS ((const void*, const void*));
161 static unsigned int type_hash_hash PARAMS ((const void*));
162 static void print_type_hash_statistics PARAMS((void));
163 static void finish_vector_type PARAMS((tree));
164 static int type_hash_marked_p PARAMS ((const void *));
165 static void type_hash_mark PARAMS ((const void *));
166 static int mark_tree_hashtable_entry PARAMS((void **, void *));
168 /* If non-null, these are language-specific helper functions for
169 unsave_expr_now. If present, LANG_UNSAVE is called before its
170 argument (an UNSAVE_EXPR) is to be unsaved, and all other
171 processing in unsave_expr_now is aborted. LANG_UNSAVE_EXPR_NOW is
172 called from unsave_expr_1 for language-specific tree codes. */
173 void (*lang_unsave) PARAMS ((tree *));
174 void (*lang_unsave_expr_now) PARAMS ((tree));
176 /* If non-null, these are language-specific helper functions for
177 unsafe_for_reeval. Return negative to not handle some tree. */
178 int (*lang_unsafe_for_reeval) PARAMS ((tree));
180 /* Set the DECL_ASSEMBLER_NAME for a node. If it is the sort of thing
181 that the assembler should talk about, set DECL_ASSEMBLER_NAME to an
182 appropriate IDENTIFIER_NODE. Otherwise, set it to the
183 ERROR_MARK_NODE to ensure that the assembler does not talk about
185 void (*lang_set_decl_assembler_name) PARAMS ((tree));
187 tree global_trees[TI_MAX];
188 tree integer_types[itk_none];
190 /* Set the DECL_ASSEMBLER_NAME for DECL. */
192 set_decl_assembler_name (decl)
195 /* The language-independent code should never use the
196 DECL_ASSEMBLER_NAME for lots of DECLs. Only FUNCTION_DECLs and
197 VAR_DECLs for variables with static storage duration need a real
198 DECL_ASSEMBLER_NAME. */
199 if (TREE_CODE (decl) == FUNCTION_DECL
200 || (TREE_CODE (decl) == VAR_DECL
201 && (TREE_STATIC (decl)
202 || DECL_EXTERNAL (decl)
203 || TREE_PUBLIC (decl))))
204 /* By default, assume the name to use in assembly code is the
205 same as that used in the source language. (That's correct
206 for C, and GCC used to set DECL_ASSEMBLER_NAME to the same
207 value as DECL_NAME in build_decl, so this choice provides
208 backwards compatibility with existing front-ends. */
209 SET_DECL_ASSEMBLER_NAME (decl, DECL_NAME (decl));
211 /* Nobody should ever be asking for the DECL_ASSEMBLER_NAME of
212 these DECLs -- unless they're in language-dependent code, in
213 which case lang_set_decl_assembler_name should handle things. */
217 /* Init the principal obstacks. */
222 gcc_obstack_init (&permanent_obstack);
224 /* Initialize the hash table of types. */
225 type_hash_table = htab_create (TYPE_HASH_INITIAL_SIZE, type_hash_hash,
227 ggc_add_deletable_htab (type_hash_table, type_hash_marked_p,
229 ggc_add_tree_root (global_trees, TI_MAX);
230 ggc_add_tree_root (integer_types, itk_none);
232 /* Set lang_set_decl_set_assembler_name to a default value. */
233 lang_set_decl_assembler_name = set_decl_assembler_name;
237 /* Allocate SIZE bytes in the permanent obstack
238 and return a pointer to them. */
244 return (char *) obstack_alloc (&permanent_obstack, size);
247 /* Allocate NELEM items of SIZE bytes in the permanent obstack
248 and return a pointer to them. The storage is cleared before
249 returning the value. */
252 perm_calloc (nelem, size)
256 char *rval = (char *) obstack_alloc (&permanent_obstack, nelem * size);
257 memset (rval, 0, nelem * size);
261 /* Compute the number of bytes occupied by 'node'. This routine only
262 looks at TREE_CODE and, if the code is TREE_VEC, TREE_VEC_LENGTH. */
267 enum tree_code code = TREE_CODE (node);
269 switch (TREE_CODE_CLASS (code))
271 case 'd': /* A decl node */
272 return sizeof (struct tree_decl);
274 case 't': /* a type node */
275 return sizeof (struct tree_type);
277 case 'b': /* a lexical block node */
278 return sizeof (struct tree_block);
280 case 'r': /* a reference */
281 case 'e': /* an expression */
282 case 's': /* an expression with side effects */
283 case '<': /* a comparison expression */
284 case '1': /* a unary arithmetic expression */
285 case '2': /* a binary arithmetic expression */
286 return (sizeof (struct tree_exp)
287 + (TREE_CODE_LENGTH (code) - 1) * sizeof (char *));
289 case 'c': /* a constant */
290 /* We can't use TREE_CODE_LENGTH for INTEGER_CST, since the number of
291 words is machine-dependent due to varying length of HOST_WIDE_INT,
292 which might be wider than a pointer (e.g., long long). Similarly
293 for REAL_CST, since the number of words is machine-dependent due
294 to varying size and alignment of `double'. */
295 if (code == INTEGER_CST)
296 return sizeof (struct tree_int_cst);
297 else if (code == REAL_CST)
298 return sizeof (struct tree_real_cst);
300 return (sizeof (struct tree_common)
301 + TREE_CODE_LENGTH (code) * sizeof (char *));
303 case 'x': /* something random, like an identifier. */
306 length = (sizeof (struct tree_common)
307 + TREE_CODE_LENGTH (code) * sizeof (char *));
308 if (code == TREE_VEC)
309 length += (TREE_VEC_LENGTH (node) - 1) * sizeof (char *);
318 /* Return a newly allocated node of code CODE.
319 For decl and type nodes, some other fields are initialized.
320 The rest of the node is initialized to zero.
322 Achoo! I got a code in the node. */
329 int type = TREE_CODE_CLASS (code);
331 #ifdef GATHER_STATISTICS
334 struct tree_common ttmp;
336 /* We can't allocate a TREE_VEC without knowing how many elements
338 if (code == TREE_VEC)
341 TREE_SET_CODE ((tree)&ttmp, code);
342 length = tree_size ((tree)&ttmp);
344 #ifdef GATHER_STATISTICS
347 case 'd': /* A decl node */
351 case 't': /* a type node */
355 case 'b': /* a lexical block */
359 case 's': /* an expression with side effects */
363 case 'r': /* a reference */
367 case 'e': /* an expression */
368 case '<': /* a comparison expression */
369 case '1': /* a unary arithmetic expression */
370 case '2': /* a binary arithmetic expression */
374 case 'c': /* a constant */
378 case 'x': /* something random, like an identifier. */
379 if (code == IDENTIFIER_NODE)
381 else if (code == TREE_VEC)
391 tree_node_counts[(int) kind]++;
392 tree_node_sizes[(int) kind] += length;
395 t = ggc_alloc_tree (length);
397 memset ((PTR) t, 0, length);
399 TREE_SET_CODE (t, code);
404 TREE_SIDE_EFFECTS (t) = 1;
405 TREE_TYPE (t) = void_type_node;
409 if (code != FUNCTION_DECL)
411 DECL_USER_ALIGN (t) = 0;
412 DECL_IN_SYSTEM_HEADER (t) = in_system_header;
413 DECL_SOURCE_LINE (t) = lineno;
414 DECL_SOURCE_FILE (t) =
415 (input_filename) ? input_filename : "<built-in>";
416 DECL_UID (t) = next_decl_uid++;
418 /* We have not yet computed the alias set for this declaration. */
419 DECL_POINTER_ALIAS_SET (t) = -1;
423 TYPE_UID (t) = next_type_uid++;
424 TYPE_ALIGN (t) = char_type_node ? TYPE_ALIGN (char_type_node) : 0;
425 TYPE_USER_ALIGN (t) = 0;
426 TYPE_MAIN_VARIANT (t) = t;
428 /* Default to no attributes for type, but let target change that. */
429 TYPE_ATTRIBUTES (t) = NULL_TREE;
430 (*targetm.set_default_type_attributes) (t);
432 /* We have not yet computed the alias set for this type. */
433 TYPE_ALIAS_SET (t) = -1;
437 TREE_CONSTANT (t) = 1;
447 case PREDECREMENT_EXPR:
448 case PREINCREMENT_EXPR:
449 case POSTDECREMENT_EXPR:
450 case POSTINCREMENT_EXPR:
451 /* All of these have side-effects, no matter what their
453 TREE_SIDE_EFFECTS (t) = 1;
465 /* A front-end can reset this to an appropriate function if types need
468 tree (*make_lang_type_fn) PARAMS ((enum tree_code)) = make_node;
470 /* Return a new type (with the indicated CODE), doing whatever
471 language-specific processing is required. */
474 make_lang_type (code)
477 return (*make_lang_type_fn) (code);
480 /* Return a new node with the same contents as NODE except that its
481 TREE_CHAIN is zero and it has a fresh uid. */
488 enum tree_code code = TREE_CODE (node);
491 length = tree_size (node);
492 t = ggc_alloc_tree (length);
493 memcpy (t, node, length);
496 TREE_ASM_WRITTEN (t) = 0;
498 if (TREE_CODE_CLASS (code) == 'd')
499 DECL_UID (t) = next_decl_uid++;
500 else if (TREE_CODE_CLASS (code) == 't')
502 TYPE_UID (t) = next_type_uid++;
503 /* The following is so that the debug code for
504 the copy is different from the original type.
505 The two statements usually duplicate each other
506 (because they clear fields of the same union),
507 but the optimizer should catch that. */
508 TYPE_SYMTAB_POINTER (t) = 0;
509 TYPE_SYMTAB_ADDRESS (t) = 0;
515 /* Return a copy of a chain of nodes, chained through the TREE_CHAIN field.
516 For example, this can copy a list made of TREE_LIST nodes. */
528 head = prev = copy_node (list);
529 next = TREE_CHAIN (list);
532 TREE_CHAIN (prev) = copy_node (next);
533 prev = TREE_CHAIN (prev);
534 next = TREE_CHAIN (next);
540 /* Return a newly constructed INTEGER_CST node whose constant value
541 is specified by the two ints LOW and HI.
542 The TREE_TYPE is set to `int'.
544 This function should be used via the `build_int_2' macro. */
547 build_int_2_wide (low, hi)
548 unsigned HOST_WIDE_INT low;
551 tree t = make_node (INTEGER_CST);
553 TREE_INT_CST_LOW (t) = low;
554 TREE_INT_CST_HIGH (t) = hi;
555 TREE_TYPE (t) = integer_type_node;
559 /* Return a new REAL_CST node whose type is TYPE and value is D. */
569 /* Check for valid float value for this type on this target machine;
570 if not, can print error message and store a valid value in D. */
571 #ifdef CHECK_FLOAT_VALUE
572 CHECK_FLOAT_VALUE (TYPE_MODE (type), d, overflow);
575 v = make_node (REAL_CST);
576 TREE_TYPE (v) = type;
577 TREE_REAL_CST (v) = d;
578 TREE_OVERFLOW (v) = TREE_CONSTANT_OVERFLOW (v) = overflow;
582 /* Return a new REAL_CST node whose type is TYPE
583 and whose value is the integer value of the INTEGER_CST node I. */
585 #if !defined (REAL_IS_NOT_DOUBLE) || defined (REAL_ARITHMETIC)
588 real_value_from_int_cst (type, i)
589 tree type ATTRIBUTE_UNUSED, i;
593 #ifdef REAL_ARITHMETIC
594 /* Clear all bits of the real value type so that we can later do
595 bitwise comparisons to see if two values are the same. */
596 memset ((char *) &d, 0, sizeof d);
598 if (! TREE_UNSIGNED (TREE_TYPE (i)))
599 REAL_VALUE_FROM_INT (d, TREE_INT_CST_LOW (i), TREE_INT_CST_HIGH (i),
602 REAL_VALUE_FROM_UNSIGNED_INT (d, TREE_INT_CST_LOW (i),
603 TREE_INT_CST_HIGH (i), TYPE_MODE (type));
604 #else /* not REAL_ARITHMETIC */
605 /* Some 386 compilers mishandle unsigned int to float conversions,
606 so introduce a temporary variable E to avoid those bugs. */
607 if (TREE_INT_CST_HIGH (i) < 0 && ! TREE_UNSIGNED (TREE_TYPE (i)))
611 d = (double) (~TREE_INT_CST_HIGH (i));
612 e = ((double) ((HOST_WIDE_INT) 1 << (HOST_BITS_PER_WIDE_INT / 2))
613 * (double) ((HOST_WIDE_INT) 1 << (HOST_BITS_PER_WIDE_INT / 2)));
615 e = (double) (~TREE_INT_CST_LOW (i));
623 d = (double) (unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (i);
624 e = ((double) ((HOST_WIDE_INT) 1 << (HOST_BITS_PER_WIDE_INT / 2))
625 * (double) ((HOST_WIDE_INT) 1 << (HOST_BITS_PER_WIDE_INT / 2)));
627 e = (double) TREE_INT_CST_LOW (i);
630 #endif /* not REAL_ARITHMETIC */
634 /* Args to pass to and from build_real_from_int_cst_1. */
638 tree type; /* Input: type to conver to. */
639 tree i; /* Input: operand to convert. */
640 REAL_VALUE_TYPE d; /* Output: floating point value. */
643 /* Convert an integer to a floating point value while protected by a floating
644 point exception handler. */
647 build_real_from_int_cst_1 (data)
650 struct brfic_args *args = (struct brfic_args *) data;
652 #ifdef REAL_ARITHMETIC
653 args->d = real_value_from_int_cst (args->type, args->i);
656 = REAL_VALUE_TRUNCATE (TYPE_MODE (args->type),
657 real_value_from_int_cst (args->type, args->i));
661 /* Given a tree representing an integer constant I, return a tree
662 representing the same value as a floating-point constant of type TYPE.
663 We cannot perform this operation if there is no way of doing arithmetic
664 on floating-point values. */
667 build_real_from_int_cst (type, i)
672 int overflow = TREE_OVERFLOW (i);
674 struct brfic_args args;
676 v = make_node (REAL_CST);
677 TREE_TYPE (v) = type;
679 /* Setup input for build_real_from_int_cst_1() */
683 if (do_float_handler (build_real_from_int_cst_1, (PTR) &args))
684 /* Receive output from build_real_from_int_cst_1() */
688 /* We got an exception from build_real_from_int_cst_1() */
693 /* Check for valid float value for this type on this target machine. */
695 #ifdef CHECK_FLOAT_VALUE
696 CHECK_FLOAT_VALUE (TYPE_MODE (type), d, overflow);
699 TREE_REAL_CST (v) = d;
700 TREE_OVERFLOW (v) = TREE_CONSTANT_OVERFLOW (v) = overflow;
704 #endif /* not REAL_IS_NOT_DOUBLE, or REAL_ARITHMETIC */
706 /* Return a newly constructed STRING_CST node whose value is
707 the LEN characters at STR.
708 The TREE_TYPE is not initialized. */
711 build_string (len, str)
715 tree s = make_node (STRING_CST);
717 TREE_STRING_LENGTH (s) = len;
718 TREE_STRING_POINTER (s) = ggc_alloc_string (str, len);
723 /* Return a newly constructed COMPLEX_CST node whose value is
724 specified by the real and imaginary parts REAL and IMAG.
725 Both REAL and IMAG should be constant nodes. TYPE, if specified,
726 will be the type of the COMPLEX_CST; otherwise a new type will be made. */
729 build_complex (type, real, imag)
733 tree t = make_node (COMPLEX_CST);
735 TREE_REALPART (t) = real;
736 TREE_IMAGPART (t) = imag;
737 TREE_TYPE (t) = type ? type : build_complex_type (TREE_TYPE (real));
738 TREE_OVERFLOW (t) = TREE_OVERFLOW (real) | TREE_OVERFLOW (imag);
739 TREE_CONSTANT_OVERFLOW (t)
740 = TREE_CONSTANT_OVERFLOW (real) | TREE_CONSTANT_OVERFLOW (imag);
744 /* Build a newly constructed TREE_VEC node of length LEN. */
751 int length = (len-1) * sizeof (tree) + sizeof (struct tree_vec);
753 #ifdef GATHER_STATISTICS
754 tree_node_counts[(int)vec_kind]++;
755 tree_node_sizes[(int)vec_kind] += length;
758 t = ggc_alloc_tree (length);
760 memset ((PTR) t, 0, length);
761 TREE_SET_CODE (t, TREE_VEC);
762 TREE_VEC_LENGTH (t) = len;
767 /* Return 1 if EXPR is the integer constant zero or a complex constant
776 return ((TREE_CODE (expr) == INTEGER_CST
777 && ! TREE_CONSTANT_OVERFLOW (expr)
778 && TREE_INT_CST_LOW (expr) == 0
779 && TREE_INT_CST_HIGH (expr) == 0)
780 || (TREE_CODE (expr) == COMPLEX_CST
781 && integer_zerop (TREE_REALPART (expr))
782 && integer_zerop (TREE_IMAGPART (expr))));
785 /* Return 1 if EXPR is the integer constant one or the corresponding
794 return ((TREE_CODE (expr) == INTEGER_CST
795 && ! TREE_CONSTANT_OVERFLOW (expr)
796 && TREE_INT_CST_LOW (expr) == 1
797 && TREE_INT_CST_HIGH (expr) == 0)
798 || (TREE_CODE (expr) == COMPLEX_CST
799 && integer_onep (TREE_REALPART (expr))
800 && integer_zerop (TREE_IMAGPART (expr))));
803 /* Return 1 if EXPR is an integer containing all 1's in as much precision as
804 it contains. Likewise for the corresponding complex constant. */
807 integer_all_onesp (expr)
815 if (TREE_CODE (expr) == COMPLEX_CST
816 && integer_all_onesp (TREE_REALPART (expr))
817 && integer_zerop (TREE_IMAGPART (expr)))
820 else if (TREE_CODE (expr) != INTEGER_CST
821 || TREE_CONSTANT_OVERFLOW (expr))
824 uns = TREE_UNSIGNED (TREE_TYPE (expr));
826 return (TREE_INT_CST_LOW (expr) == ~(unsigned HOST_WIDE_INT) 0
827 && TREE_INT_CST_HIGH (expr) == -1);
829 /* Note that using TYPE_PRECISION here is wrong. We care about the
830 actual bits, not the (arbitrary) range of the type. */
831 prec = GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (expr)));
832 if (prec >= HOST_BITS_PER_WIDE_INT)
834 HOST_WIDE_INT high_value;
837 shift_amount = prec - HOST_BITS_PER_WIDE_INT;
839 if (shift_amount > HOST_BITS_PER_WIDE_INT)
840 /* Can not handle precisions greater than twice the host int size. */
842 else if (shift_amount == HOST_BITS_PER_WIDE_INT)
843 /* Shifting by the host word size is undefined according to the ANSI
844 standard, so we must handle this as a special case. */
847 high_value = ((HOST_WIDE_INT) 1 << shift_amount) - 1;
849 return (TREE_INT_CST_LOW (expr) == ~(unsigned HOST_WIDE_INT) 0
850 && TREE_INT_CST_HIGH (expr) == high_value);
853 return TREE_INT_CST_LOW (expr) == ((unsigned HOST_WIDE_INT) 1 << prec) - 1;
856 /* Return 1 if EXPR is an integer constant that is a power of 2 (i.e., has only
864 HOST_WIDE_INT high, low;
868 if (TREE_CODE (expr) == COMPLEX_CST
869 && integer_pow2p (TREE_REALPART (expr))
870 && integer_zerop (TREE_IMAGPART (expr)))
873 if (TREE_CODE (expr) != INTEGER_CST || TREE_CONSTANT_OVERFLOW (expr))
876 prec = (POINTER_TYPE_P (TREE_TYPE (expr))
877 ? POINTER_SIZE : TYPE_PRECISION (TREE_TYPE (expr)));
878 high = TREE_INT_CST_HIGH (expr);
879 low = TREE_INT_CST_LOW (expr);
881 /* First clear all bits that are beyond the type's precision in case
882 we've been sign extended. */
884 if (prec == 2 * HOST_BITS_PER_WIDE_INT)
886 else if (prec > HOST_BITS_PER_WIDE_INT)
887 high &= ~((HOST_WIDE_INT) (-1) << (prec - HOST_BITS_PER_WIDE_INT));
891 if (prec < HOST_BITS_PER_WIDE_INT)
892 low &= ~((HOST_WIDE_INT) (-1) << prec);
895 if (high == 0 && low == 0)
898 return ((high == 0 && (low & (low - 1)) == 0)
899 || (low == 0 && (high & (high - 1)) == 0));
902 /* Return the power of two represented by a tree node known to be a
910 HOST_WIDE_INT high, low;
914 if (TREE_CODE (expr) == COMPLEX_CST)
915 return tree_log2 (TREE_REALPART (expr));
917 prec = (POINTER_TYPE_P (TREE_TYPE (expr))
918 ? POINTER_SIZE : TYPE_PRECISION (TREE_TYPE (expr)));
920 high = TREE_INT_CST_HIGH (expr);
921 low = TREE_INT_CST_LOW (expr);
923 /* First clear all bits that are beyond the type's precision in case
924 we've been sign extended. */
926 if (prec == 2 * HOST_BITS_PER_WIDE_INT)
928 else if (prec > HOST_BITS_PER_WIDE_INT)
929 high &= ~((HOST_WIDE_INT) (-1) << (prec - HOST_BITS_PER_WIDE_INT));
933 if (prec < HOST_BITS_PER_WIDE_INT)
934 low &= ~((HOST_WIDE_INT) (-1) << prec);
937 return (high != 0 ? HOST_BITS_PER_WIDE_INT + exact_log2 (high)
941 /* Similar, but return the largest integer Y such that 2 ** Y is less
942 than or equal to EXPR. */
945 tree_floor_log2 (expr)
949 HOST_WIDE_INT high, low;
953 if (TREE_CODE (expr) == COMPLEX_CST)
954 return tree_log2 (TREE_REALPART (expr));
956 prec = (POINTER_TYPE_P (TREE_TYPE (expr))
957 ? POINTER_SIZE : TYPE_PRECISION (TREE_TYPE (expr)));
959 high = TREE_INT_CST_HIGH (expr);
960 low = TREE_INT_CST_LOW (expr);
962 /* First clear all bits that are beyond the type's precision in case
963 we've been sign extended. Ignore if type's precision hasn't been set
964 since what we are doing is setting it. */
966 if (prec == 2 * HOST_BITS_PER_WIDE_INT || prec == 0)
968 else if (prec > HOST_BITS_PER_WIDE_INT)
969 high &= ~((HOST_WIDE_INT) (-1) << (prec - HOST_BITS_PER_WIDE_INT));
973 if (prec < HOST_BITS_PER_WIDE_INT)
974 low &= ~((HOST_WIDE_INT) (-1) << prec);
977 return (high != 0 ? HOST_BITS_PER_WIDE_INT + floor_log2 (high)
981 /* Return 1 if EXPR is the real constant zero. */
989 return ((TREE_CODE (expr) == REAL_CST
990 && ! TREE_CONSTANT_OVERFLOW (expr)
991 && REAL_VALUES_EQUAL (TREE_REAL_CST (expr), dconst0))
992 || (TREE_CODE (expr) == COMPLEX_CST
993 && real_zerop (TREE_REALPART (expr))
994 && real_zerop (TREE_IMAGPART (expr))));
997 /* Return 1 if EXPR is the real constant one in real or complex form. */
1005 return ((TREE_CODE (expr) == REAL_CST
1006 && ! TREE_CONSTANT_OVERFLOW (expr)
1007 && REAL_VALUES_EQUAL (TREE_REAL_CST (expr), dconst1))
1008 || (TREE_CODE (expr) == COMPLEX_CST
1009 && real_onep (TREE_REALPART (expr))
1010 && real_zerop (TREE_IMAGPART (expr))));
1013 /* Return 1 if EXPR is the real constant two. */
1021 return ((TREE_CODE (expr) == REAL_CST
1022 && ! TREE_CONSTANT_OVERFLOW (expr)
1023 && REAL_VALUES_EQUAL (TREE_REAL_CST (expr), dconst2))
1024 || (TREE_CODE (expr) == COMPLEX_CST
1025 && real_twop (TREE_REALPART (expr))
1026 && real_zerop (TREE_IMAGPART (expr))));
1029 /* Nonzero if EXP is a constant or a cast of a constant. */
1032 really_constant_p (exp)
1035 /* This is not quite the same as STRIP_NOPS. It does more. */
1036 while (TREE_CODE (exp) == NOP_EXPR
1037 || TREE_CODE (exp) == CONVERT_EXPR
1038 || TREE_CODE (exp) == NON_LVALUE_EXPR)
1039 exp = TREE_OPERAND (exp, 0);
1040 return TREE_CONSTANT (exp);
1043 /* Return first list element whose TREE_VALUE is ELEM.
1044 Return 0 if ELEM is not in LIST. */
1047 value_member (elem, list)
1052 if (elem == TREE_VALUE (list))
1054 list = TREE_CHAIN (list);
1059 /* Return first list element whose TREE_PURPOSE is ELEM.
1060 Return 0 if ELEM is not in LIST. */
1063 purpose_member (elem, list)
1068 if (elem == TREE_PURPOSE (list))
1070 list = TREE_CHAIN (list);
1075 /* Return first list element whose BINFO_TYPE is ELEM.
1076 Return 0 if ELEM is not in LIST. */
1079 binfo_member (elem, list)
1084 if (elem == BINFO_TYPE (list))
1086 list = TREE_CHAIN (list);
1091 /* Return nonzero if ELEM is part of the chain CHAIN. */
1094 chain_member (elem, chain)
1101 chain = TREE_CHAIN (chain);
1107 /* Return nonzero if ELEM is equal to TREE_VALUE (CHAIN) for any piece of
1108 chain CHAIN. This and the next function are currently unused, but
1109 are retained for completeness. */
1112 chain_member_value (elem, chain)
1117 if (elem == TREE_VALUE (chain))
1119 chain = TREE_CHAIN (chain);
1125 /* Return nonzero if ELEM is equal to TREE_PURPOSE (CHAIN)
1126 for any piece of chain CHAIN. */
1129 chain_member_purpose (elem, chain)
1134 if (elem == TREE_PURPOSE (chain))
1136 chain = TREE_CHAIN (chain);
1142 /* Return the length of a chain of nodes chained through TREE_CHAIN.
1143 We expect a null pointer to mark the end of the chain.
1144 This is the Lisp primitive `length'. */
1153 for (tail = t; tail; tail = TREE_CHAIN (tail))
1159 /* Returns the number of FIELD_DECLs in TYPE. */
1162 fields_length (type)
1165 tree t = TYPE_FIELDS (type);
1168 for (; t; t = TREE_CHAIN (t))
1169 if (TREE_CODE (t) == FIELD_DECL)
1175 /* Concatenate two chains of nodes (chained through TREE_CHAIN)
1176 by modifying the last node in chain 1 to point to chain 2.
1177 This is the Lisp primitive `nconc'. */
1187 #ifdef ENABLE_TREE_CHECKING
1191 for (t1 = op1; TREE_CHAIN (t1); t1 = TREE_CHAIN (t1))
1193 TREE_CHAIN (t1) = op2;
1194 #ifdef ENABLE_TREE_CHECKING
1195 for (t2 = op2; t2; t2 = TREE_CHAIN (t2))
1197 abort (); /* Circularity created. */
1205 /* Return the last node in a chain of nodes (chained through TREE_CHAIN). */
1213 while ((next = TREE_CHAIN (chain)))
1218 /* Reverse the order of elements in the chain T,
1219 and return the new head of the chain (old last element). */
1225 tree prev = 0, decl, next;
1226 for (decl = t; decl; decl = next)
1228 next = TREE_CHAIN (decl);
1229 TREE_CHAIN (decl) = prev;
1235 /* Given a chain CHAIN of tree nodes,
1236 construct and return a list of those nodes. */
1242 tree result = NULL_TREE;
1243 tree in_tail = chain;
1244 tree out_tail = NULL_TREE;
1248 tree next = tree_cons (NULL_TREE, in_tail, NULL_TREE);
1250 TREE_CHAIN (out_tail) = next;
1254 in_tail = TREE_CHAIN (in_tail);
1260 /* Return a newly created TREE_LIST node whose
1261 purpose and value fields are PARM and VALUE. */
1264 build_tree_list (parm, value)
1267 tree t = make_node (TREE_LIST);
1268 TREE_PURPOSE (t) = parm;
1269 TREE_VALUE (t) = value;
1273 /* Return a newly created TREE_LIST node whose
1274 purpose and value fields are PARM and VALUE
1275 and whose TREE_CHAIN is CHAIN. */
1278 tree_cons (purpose, value, chain)
1279 tree purpose, value, chain;
1283 node = ggc_alloc_tree (sizeof (struct tree_list));
1285 memset (node, 0, sizeof (struct tree_common));
1287 #ifdef GATHER_STATISTICS
1288 tree_node_counts[(int) x_kind]++;
1289 tree_node_sizes[(int) x_kind] += sizeof (struct tree_list);
1292 TREE_SET_CODE (node, TREE_LIST);
1293 TREE_CHAIN (node) = chain;
1294 TREE_PURPOSE (node) = purpose;
1295 TREE_VALUE (node) = value;
1300 /* Return the size nominally occupied by an object of type TYPE
1301 when it resides in memory. The value is measured in units of bytes,
1302 and its data type is that normally used for type sizes
1303 (which is the first type created by make_signed_type or
1304 make_unsigned_type). */
1307 size_in_bytes (type)
1312 if (type == error_mark_node)
1313 return integer_zero_node;
1315 type = TYPE_MAIN_VARIANT (type);
1316 t = TYPE_SIZE_UNIT (type);
1320 incomplete_type_error (NULL_TREE, type);
1321 return size_zero_node;
1324 if (TREE_CODE (t) == INTEGER_CST)
1325 force_fit_type (t, 0);
1330 /* Return the size of TYPE (in bytes) as a wide integer
1331 or return -1 if the size can vary or is larger than an integer. */
1334 int_size_in_bytes (type)
1339 if (type == error_mark_node)
1342 type = TYPE_MAIN_VARIANT (type);
1343 t = TYPE_SIZE_UNIT (type);
1345 || TREE_CODE (t) != INTEGER_CST
1346 || TREE_OVERFLOW (t)
1347 || TREE_INT_CST_HIGH (t) != 0
1348 /* If the result would appear negative, it's too big to represent. */
1349 || (HOST_WIDE_INT) TREE_INT_CST_LOW (t) < 0)
1352 return TREE_INT_CST_LOW (t);
1355 /* Return the bit position of FIELD, in bits from the start of the record.
1356 This is a tree of type bitsizetype. */
1359 bit_position (field)
1363 return bit_from_pos (DECL_FIELD_OFFSET (field),
1364 DECL_FIELD_BIT_OFFSET (field));
1367 /* Likewise, but return as an integer. Abort if it cannot be represented
1368 in that way (since it could be a signed value, we don't have the option
1369 of returning -1 like int_size_in_byte can. */
1372 int_bit_position (field)
1375 return tree_low_cst (bit_position (field), 0);
1378 /* Return the byte position of FIELD, in bytes from the start of the record.
1379 This is a tree of type sizetype. */
1382 byte_position (field)
1385 return byte_from_pos (DECL_FIELD_OFFSET (field),
1386 DECL_FIELD_BIT_OFFSET (field));
1389 /* Likewise, but return as an integer. Abort if it cannot be represented
1390 in that way (since it could be a signed value, we don't have the option
1391 of returning -1 like int_size_in_byte can. */
1394 int_byte_position (field)
1397 return tree_low_cst (byte_position (field), 0);
1400 /* Return the strictest alignment, in bits, that T is known to have. */
1406 unsigned int align0, align1;
1408 switch (TREE_CODE (t))
1410 case NOP_EXPR: case CONVERT_EXPR: case NON_LVALUE_EXPR:
1411 /* If we have conversions, we know that the alignment of the
1412 object must meet each of the alignments of the types. */
1413 align0 = expr_align (TREE_OPERAND (t, 0));
1414 align1 = TYPE_ALIGN (TREE_TYPE (t));
1415 return MAX (align0, align1);
1417 case SAVE_EXPR: case COMPOUND_EXPR: case MODIFY_EXPR:
1418 case INIT_EXPR: case TARGET_EXPR: case WITH_CLEANUP_EXPR:
1419 case WITH_RECORD_EXPR: case CLEANUP_POINT_EXPR: case UNSAVE_EXPR:
1420 /* These don't change the alignment of an object. */
1421 return expr_align (TREE_OPERAND (t, 0));
1424 /* The best we can do is say that the alignment is the least aligned
1426 align0 = expr_align (TREE_OPERAND (t, 1));
1427 align1 = expr_align (TREE_OPERAND (t, 2));
1428 return MIN (align0, align1);
1430 case LABEL_DECL: case CONST_DECL:
1431 case VAR_DECL: case PARM_DECL: case RESULT_DECL:
1432 if (DECL_ALIGN (t) != 0)
1433 return DECL_ALIGN (t);
1437 return FUNCTION_BOUNDARY;
1443 /* Otherwise take the alignment from that of the type. */
1444 return TYPE_ALIGN (TREE_TYPE (t));
1447 /* Return, as a tree node, the number of elements for TYPE (which is an
1448 ARRAY_TYPE) minus one. This counts only elements of the top array. */
1451 array_type_nelts (type)
1454 tree index_type, min, max;
1456 /* If they did it with unspecified bounds, then we should have already
1457 given an error about it before we got here. */
1458 if (! TYPE_DOMAIN (type))
1459 return error_mark_node;
1461 index_type = TYPE_DOMAIN (type);
1462 min = TYPE_MIN_VALUE (index_type);
1463 max = TYPE_MAX_VALUE (index_type);
1465 return (integer_zerop (min)
1467 : fold (build (MINUS_EXPR, TREE_TYPE (max), max, min)));
1470 /* Return nonzero if arg is static -- a reference to an object in
1471 static storage. This is not the same as the C meaning of `static'. */
1477 switch (TREE_CODE (arg))
1480 /* Nested functions aren't static, since taking their address
1481 involves a trampoline. */
1482 return (decl_function_context (arg) == 0 || DECL_NO_STATIC_CHAIN (arg))
1483 && ! DECL_NON_ADDR_CONST_P (arg);
1486 return (TREE_STATIC (arg) || DECL_EXTERNAL (arg))
1487 && ! DECL_NON_ADDR_CONST_P (arg);
1490 return TREE_STATIC (arg);
1496 /* If we are referencing a bitfield, we can't evaluate an
1497 ADDR_EXPR at compile time and so it isn't a constant. */
1499 return (! DECL_BIT_FIELD (TREE_OPERAND (arg, 1))
1500 && staticp (TREE_OPERAND (arg, 0)));
1506 /* This case is technically correct, but results in setting
1507 TREE_CONSTANT on ADDR_EXPRs that cannot be evaluated at
1510 return TREE_CONSTANT (TREE_OPERAND (arg, 0));
1514 case ARRAY_RANGE_REF:
1515 if (TREE_CODE (TYPE_SIZE (TREE_TYPE (arg))) == INTEGER_CST
1516 && TREE_CODE (TREE_OPERAND (arg, 1)) == INTEGER_CST)
1517 return staticp (TREE_OPERAND (arg, 0));
1524 /* Wrap a SAVE_EXPR around EXPR, if appropriate.
1525 Do this to any expression which may be used in more than one place,
1526 but must be evaluated only once.
1528 Normally, expand_expr would reevaluate the expression each time.
1529 Calling save_expr produces something that is evaluated and recorded
1530 the first time expand_expr is called on it. Subsequent calls to
1531 expand_expr just reuse the recorded value.
1533 The call to expand_expr that generates code that actually computes
1534 the value is the first call *at compile time*. Subsequent calls
1535 *at compile time* generate code to use the saved value.
1536 This produces correct result provided that *at run time* control
1537 always flows through the insns made by the first expand_expr
1538 before reaching the other places where the save_expr was evaluated.
1539 You, the caller of save_expr, must make sure this is so.
1541 Constants, and certain read-only nodes, are returned with no
1542 SAVE_EXPR because that is safe. Expressions containing placeholders
1543 are not touched; see tree.def for an explanation of what these
1550 tree t = fold (expr);
1552 /* We don't care about whether this can be used as an lvalue in this
1554 while (TREE_CODE (t) == NON_LVALUE_EXPR)
1555 t = TREE_OPERAND (t, 0);
1557 /* If the tree evaluates to a constant, then we don't want to hide that
1558 fact (i.e. this allows further folding, and direct checks for constants).
1559 However, a read-only object that has side effects cannot be bypassed.
1560 Since it is no problem to reevaluate literals, we just return the
1563 if (TREE_CONSTANT (t) || (TREE_READONLY (t) && ! TREE_SIDE_EFFECTS (t))
1564 || TREE_CODE (t) == SAVE_EXPR || TREE_CODE (t) == ERROR_MARK)
1567 /* If T contains a PLACEHOLDER_EXPR, we must evaluate it each time, since
1568 it means that the size or offset of some field of an object depends on
1569 the value within another field.
1571 Note that it must not be the case that T contains both a PLACEHOLDER_EXPR
1572 and some variable since it would then need to be both evaluated once and
1573 evaluated more than once. Front-ends must assure this case cannot
1574 happen by surrounding any such subexpressions in their own SAVE_EXPR
1575 and forcing evaluation at the proper time. */
1576 if (contains_placeholder_p (t))
1579 t = build (SAVE_EXPR, TREE_TYPE (expr), t, current_function_decl, NULL_TREE);
1581 /* This expression might be placed ahead of a jump to ensure that the
1582 value was computed on both sides of the jump. So make sure it isn't
1583 eliminated as dead. */
1584 TREE_SIDE_EFFECTS (t) = 1;
1585 TREE_READONLY (t) = 1;
1589 /* Arrange for an expression to be expanded multiple independent
1590 times. This is useful for cleanup actions, as the backend can
1591 expand them multiple times in different places. */
1599 /* If this is already protected, no sense in protecting it again. */
1600 if (TREE_CODE (expr) == UNSAVE_EXPR)
1603 t = build1 (UNSAVE_EXPR, TREE_TYPE (expr), expr);
1604 TREE_SIDE_EFFECTS (t) = TREE_SIDE_EFFECTS (expr);
1608 /* Returns the index of the first non-tree operand for CODE, or the number
1609 of operands if all are trees. */
1613 enum tree_code code;
1619 case GOTO_SUBROUTINE_EXPR:
1622 case WITH_CLEANUP_EXPR:
1624 case METHOD_CALL_EXPR:
1627 return TREE_CODE_LENGTH (code);
1631 /* Perform any modifications to EXPR required when it is unsaved. Does
1632 not recurse into EXPR's subtrees. */
1635 unsave_expr_1 (expr)
1638 switch (TREE_CODE (expr))
1641 if (! SAVE_EXPR_PERSISTENT_P (expr))
1642 SAVE_EXPR_RTL (expr) = 0;
1646 /* Don't mess with a TARGET_EXPR that hasn't been expanded.
1647 It's OK for this to happen if it was part of a subtree that
1648 isn't immediately expanded, such as operand 2 of another
1650 if (TREE_OPERAND (expr, 1))
1653 TREE_OPERAND (expr, 1) = TREE_OPERAND (expr, 3);
1654 TREE_OPERAND (expr, 3) = NULL_TREE;
1658 /* I don't yet know how to emit a sequence multiple times. */
1659 if (RTL_EXPR_SEQUENCE (expr) != 0)
1664 if (lang_unsave_expr_now != 0)
1665 (*lang_unsave_expr_now) (expr);
1670 /* Helper function for unsave_expr_now. */
1673 unsave_expr_now_r (expr)
1676 enum tree_code code;
1678 /* There's nothing to do for NULL_TREE. */
1682 unsave_expr_1 (expr);
1684 code = TREE_CODE (expr);
1685 switch (TREE_CODE_CLASS (code))
1687 case 'c': /* a constant */
1688 case 't': /* a type node */
1689 case 'd': /* A decl node */
1690 case 'b': /* A block node */
1693 case 'x': /* miscellaneous: e.g., identifier, TREE_LIST or ERROR_MARK. */
1694 if (code == TREE_LIST)
1696 unsave_expr_now_r (TREE_VALUE (expr));
1697 unsave_expr_now_r (TREE_CHAIN (expr));
1701 case 'e': /* an expression */
1702 case 'r': /* a reference */
1703 case 's': /* an expression with side effects */
1704 case '<': /* a comparison expression */
1705 case '2': /* a binary arithmetic expression */
1706 case '1': /* a unary arithmetic expression */
1710 for (i = first_rtl_op (code) - 1; i >= 0; i--)
1711 unsave_expr_now_r (TREE_OPERAND (expr, i));
1720 /* Modify a tree in place so that all the evaluate only once things
1721 are cleared out. Return the EXPR given. */
1724 unsave_expr_now (expr)
1727 if (lang_unsave!= 0)
1728 (*lang_unsave) (&expr);
1730 unsave_expr_now_r (expr);
1735 /* Return 0 if it is safe to evaluate EXPR multiple times,
1736 return 1 if it is safe if EXPR is unsaved afterward, or
1737 return 2 if it is completely unsafe.
1739 This assumes that CALL_EXPRs and TARGET_EXPRs are never replicated in
1740 an expression tree, so that it safe to unsave them and the surrounding
1741 context will be correct.
1743 SAVE_EXPRs basically *only* appear replicated in an expression tree,
1744 occasionally across the whole of a function. It is therefore only
1745 safe to unsave a SAVE_EXPR if you know that all occurrences appear
1746 below the UNSAVE_EXPR.
1748 RTL_EXPRs consume their rtl during evaluation. It is therefore
1749 never possible to unsave them. */
1752 unsafe_for_reeval (expr)
1756 enum tree_code code;
1761 if (expr == NULL_TREE)
1764 code = TREE_CODE (expr);
1765 first_rtl = first_rtl_op (code);
1774 for (exp = expr; exp != 0; exp = TREE_CHAIN (exp))
1776 tmp = unsafe_for_reeval (TREE_VALUE (exp));
1777 unsafeness = MAX (tmp, unsafeness);
1783 tmp = unsafe_for_reeval (TREE_OPERAND (expr, 1));
1784 return MAX (tmp, 1);
1791 if (lang_unsafe_for_reeval != 0)
1793 tmp = (*lang_unsafe_for_reeval) (expr);
1800 switch (TREE_CODE_CLASS (code))
1802 case 'c': /* a constant */
1803 case 't': /* a type node */
1804 case 'x': /* something random, like an identifier or an ERROR_MARK. */
1805 case 'd': /* A decl node */
1806 case 'b': /* A block node */
1809 case 'e': /* an expression */
1810 case 'r': /* a reference */
1811 case 's': /* an expression with side effects */
1812 case '<': /* a comparison expression */
1813 case '2': /* a binary arithmetic expression */
1814 case '1': /* a unary arithmetic expression */
1815 for (i = first_rtl - 1; i >= 0; i--)
1817 tmp = unsafe_for_reeval (TREE_OPERAND (expr, i));
1818 unsafeness = MAX (tmp, unsafeness);
1828 /* Return 1 if EXP contains a PLACEHOLDER_EXPR; i.e., if it represents a size
1829 or offset that depends on a field within a record. */
1832 contains_placeholder_p (exp)
1835 enum tree_code code;
1841 /* If we have a WITH_RECORD_EXPR, it "cancels" any PLACEHOLDER_EXPR
1842 in it since it is supplying a value for it. */
1843 code = TREE_CODE (exp);
1844 if (code == WITH_RECORD_EXPR)
1846 else if (code == PLACEHOLDER_EXPR)
1849 switch (TREE_CODE_CLASS (code))
1852 /* Don't look at any PLACEHOLDER_EXPRs that might be in index or bit
1853 position computations since they will be converted into a
1854 WITH_RECORD_EXPR involving the reference, which will assume
1855 here will be valid. */
1856 return contains_placeholder_p (TREE_OPERAND (exp, 0));
1859 if (code == TREE_LIST)
1860 return (contains_placeholder_p (TREE_VALUE (exp))
1861 || (TREE_CHAIN (exp) != 0
1862 && contains_placeholder_p (TREE_CHAIN (exp))));
1871 /* Ignoring the first operand isn't quite right, but works best. */
1872 return contains_placeholder_p (TREE_OPERAND (exp, 1));
1879 return (contains_placeholder_p (TREE_OPERAND (exp, 0))
1880 || contains_placeholder_p (TREE_OPERAND (exp, 1))
1881 || contains_placeholder_p (TREE_OPERAND (exp, 2)));
1884 /* If we already know this doesn't have a placeholder, don't
1886 if (SAVE_EXPR_NOPLACEHOLDER (exp) || SAVE_EXPR_RTL (exp) != 0)
1889 SAVE_EXPR_NOPLACEHOLDER (exp) = 1;
1890 result = contains_placeholder_p (TREE_OPERAND (exp, 0));
1892 SAVE_EXPR_NOPLACEHOLDER (exp) = 0;
1897 return (TREE_OPERAND (exp, 1) != 0
1898 && contains_placeholder_p (TREE_OPERAND (exp, 1)));
1904 switch (TREE_CODE_LENGTH (code))
1907 return contains_placeholder_p (TREE_OPERAND (exp, 0));
1909 return (contains_placeholder_p (TREE_OPERAND (exp, 0))
1910 || contains_placeholder_p (TREE_OPERAND (exp, 1)));
1921 /* Return 1 if EXP contains any expressions that produce cleanups for an
1922 outer scope to deal with. Used by fold. */
1930 if (! TREE_SIDE_EFFECTS (exp))
1933 switch (TREE_CODE (exp))
1936 case GOTO_SUBROUTINE_EXPR:
1937 case WITH_CLEANUP_EXPR:
1940 case CLEANUP_POINT_EXPR:
1944 for (exp = TREE_OPERAND (exp, 1); exp; exp = TREE_CHAIN (exp))
1946 cmp = has_cleanups (TREE_VALUE (exp));
1956 /* This general rule works for most tree codes. All exceptions should be
1957 handled above. If this is a language-specific tree code, we can't
1958 trust what might be in the operand, so say we don't know
1960 if ((int) TREE_CODE (exp) >= (int) LAST_AND_UNUSED_TREE_CODE)
1963 nops = first_rtl_op (TREE_CODE (exp));
1964 for (i = 0; i < nops; i++)
1965 if (TREE_OPERAND (exp, i) != 0)
1967 int type = TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp, i)));
1968 if (type == 'e' || type == '<' || type == '1' || type == '2'
1969 || type == 'r' || type == 's')
1971 cmp = has_cleanups (TREE_OPERAND (exp, i));
1980 /* Given a tree EXP, a FIELD_DECL F, and a replacement value R,
1981 return a tree with all occurrences of references to F in a
1982 PLACEHOLDER_EXPR replaced by R. Note that we assume here that EXP
1983 contains only arithmetic expressions or a CALL_EXPR with a
1984 PLACEHOLDER_EXPR occurring only in its arglist. */
1987 substitute_in_expr (exp, f, r)
1992 enum tree_code code = TREE_CODE (exp);
1997 switch (TREE_CODE_CLASS (code))
2004 if (code == PLACEHOLDER_EXPR)
2006 else if (code == TREE_LIST)
2008 op0 = (TREE_CHAIN (exp) == 0
2009 ? 0 : substitute_in_expr (TREE_CHAIN (exp), f, r));
2010 op1 = substitute_in_expr (TREE_VALUE (exp), f, r);
2011 if (op0 == TREE_CHAIN (exp) && op1 == TREE_VALUE (exp))
2014 return tree_cons (TREE_PURPOSE (exp), op1, op0);
2023 switch (TREE_CODE_LENGTH (code))
2026 op0 = substitute_in_expr (TREE_OPERAND (exp, 0), f, r);
2027 if (op0 == TREE_OPERAND (exp, 0))
2030 if (code == NON_LVALUE_EXPR)
2033 new = fold (build1 (code, TREE_TYPE (exp), op0));
2037 /* An RTL_EXPR cannot contain a PLACEHOLDER_EXPR; a CONSTRUCTOR
2038 could, but we don't support it. */
2039 if (code == RTL_EXPR)
2041 else if (code == CONSTRUCTOR)
2044 op0 = substitute_in_expr (TREE_OPERAND (exp, 0), f, r);
2045 op1 = substitute_in_expr (TREE_OPERAND (exp, 1), f, r);
2046 if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1))
2049 new = fold (build (code, TREE_TYPE (exp), op0, op1));
2053 /* It cannot be that anything inside a SAVE_EXPR contains a
2054 PLACEHOLDER_EXPR. */
2055 if (code == SAVE_EXPR)
2058 else if (code == CALL_EXPR)
2060 op1 = substitute_in_expr (TREE_OPERAND (exp, 1), f, r);
2061 if (op1 == TREE_OPERAND (exp, 1))
2064 return build (code, TREE_TYPE (exp),
2065 TREE_OPERAND (exp, 0), op1, NULL_TREE);
2068 else if (code != COND_EXPR)
2071 op0 = substitute_in_expr (TREE_OPERAND (exp, 0), f, r);
2072 op1 = substitute_in_expr (TREE_OPERAND (exp, 1), f, r);
2073 op2 = substitute_in_expr (TREE_OPERAND (exp, 2), f, r);
2074 if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1)
2075 && op2 == TREE_OPERAND (exp, 2))
2078 new = fold (build (code, TREE_TYPE (exp), op0, op1, op2));
2091 /* If this expression is getting a value from a PLACEHOLDER_EXPR
2092 and it is the right field, replace it with R. */
2093 for (inner = TREE_OPERAND (exp, 0);
2094 TREE_CODE_CLASS (TREE_CODE (inner)) == 'r';
2095 inner = TREE_OPERAND (inner, 0))
2097 if (TREE_CODE (inner) == PLACEHOLDER_EXPR
2098 && TREE_OPERAND (exp, 1) == f)
2101 /* If this expression hasn't been completed let, leave it
2103 if (TREE_CODE (inner) == PLACEHOLDER_EXPR
2104 && TREE_TYPE (inner) == 0)
2107 op0 = substitute_in_expr (TREE_OPERAND (exp, 0), f, r);
2108 if (op0 == TREE_OPERAND (exp, 0))
2111 new = fold (build (code, TREE_TYPE (exp), op0,
2112 TREE_OPERAND (exp, 1)));
2116 op0 = substitute_in_expr (TREE_OPERAND (exp, 0), f, r);
2117 op1 = substitute_in_expr (TREE_OPERAND (exp, 1), f, r);
2118 op2 = substitute_in_expr (TREE_OPERAND (exp, 2), f, r);
2119 if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1)
2120 && op2 == TREE_OPERAND (exp, 2))
2123 new = fold (build (code, TREE_TYPE (exp), op0, op1, op2));
2128 op0 = substitute_in_expr (TREE_OPERAND (exp, 0), f, r);
2129 if (op0 == TREE_OPERAND (exp, 0))
2132 new = fold (build1 (code, TREE_TYPE (exp), op0));
2144 TREE_READONLY (new) = TREE_READONLY (exp);
2148 /* Stabilize a reference so that we can use it any number of times
2149 without causing its operands to be evaluated more than once.
2150 Returns the stabilized reference. This works by means of save_expr,
2151 so see the caveats in the comments about save_expr.
2153 Also allows conversion expressions whose operands are references.
2154 Any other kind of expression is returned unchanged. */
2157 stabilize_reference (ref)
2161 enum tree_code code = TREE_CODE (ref);
2168 /* No action is needed in this case. */
2174 case FIX_TRUNC_EXPR:
2175 case FIX_FLOOR_EXPR:
2176 case FIX_ROUND_EXPR:
2178 result = build_nt (code, stabilize_reference (TREE_OPERAND (ref, 0)));
2182 result = build_nt (INDIRECT_REF,
2183 stabilize_reference_1 (TREE_OPERAND (ref, 0)));
2187 result = build_nt (COMPONENT_REF,
2188 stabilize_reference (TREE_OPERAND (ref, 0)),
2189 TREE_OPERAND (ref, 1));
2193 result = build_nt (BIT_FIELD_REF,
2194 stabilize_reference (TREE_OPERAND (ref, 0)),
2195 stabilize_reference_1 (TREE_OPERAND (ref, 1)),
2196 stabilize_reference_1 (TREE_OPERAND (ref, 2)));
2200 result = build_nt (ARRAY_REF,
2201 stabilize_reference (TREE_OPERAND (ref, 0)),
2202 stabilize_reference_1 (TREE_OPERAND (ref, 1)));
2205 case ARRAY_RANGE_REF:
2206 result = build_nt (ARRAY_RANGE_REF,
2207 stabilize_reference (TREE_OPERAND (ref, 0)),
2208 stabilize_reference_1 (TREE_OPERAND (ref, 1)));
2212 /* We cannot wrap the first expression in a SAVE_EXPR, as then
2213 it wouldn't be ignored. This matters when dealing with
2215 return stabilize_reference_1 (ref);
2218 result = build1 (INDIRECT_REF, TREE_TYPE (ref),
2219 save_expr (build1 (ADDR_EXPR,
2220 build_pointer_type (TREE_TYPE (ref)),
2224 /* If arg isn't a kind of lvalue we recognize, make no change.
2225 Caller should recognize the error for an invalid lvalue. */
2230 return error_mark_node;
2233 TREE_TYPE (result) = TREE_TYPE (ref);
2234 TREE_READONLY (result) = TREE_READONLY (ref);
2235 TREE_SIDE_EFFECTS (result) = TREE_SIDE_EFFECTS (ref);
2236 TREE_THIS_VOLATILE (result) = TREE_THIS_VOLATILE (ref);
2241 /* Subroutine of stabilize_reference; this is called for subtrees of
2242 references. Any expression with side-effects must be put in a SAVE_EXPR
2243 to ensure that it is only evaluated once.
2245 We don't put SAVE_EXPR nodes around everything, because assigning very
2246 simple expressions to temporaries causes us to miss good opportunities
2247 for optimizations. Among other things, the opportunity to fold in the
2248 addition of a constant into an addressing mode often gets lost, e.g.
2249 "y[i+1] += x;". In general, we take the approach that we should not make
2250 an assignment unless we are forced into it - i.e., that any non-side effect
2251 operator should be allowed, and that cse should take care of coalescing
2252 multiple utterances of the same expression should that prove fruitful. */
2255 stabilize_reference_1 (e)
2259 enum tree_code code = TREE_CODE (e);
2261 /* We cannot ignore const expressions because it might be a reference
2262 to a const array but whose index contains side-effects. But we can
2263 ignore things that are actual constant or that already have been
2264 handled by this function. */
2266 if (TREE_CONSTANT (e) || code == SAVE_EXPR)
2269 switch (TREE_CODE_CLASS (code))
2279 /* If the expression has side-effects, then encase it in a SAVE_EXPR
2280 so that it will only be evaluated once. */
2281 /* The reference (r) and comparison (<) classes could be handled as
2282 below, but it is generally faster to only evaluate them once. */
2283 if (TREE_SIDE_EFFECTS (e))
2284 return save_expr (e);
2288 /* Constants need no processing. In fact, we should never reach
2293 /* Division is slow and tends to be compiled with jumps,
2294 especially the division by powers of 2 that is often
2295 found inside of an array reference. So do it just once. */
2296 if (code == TRUNC_DIV_EXPR || code == TRUNC_MOD_EXPR
2297 || code == FLOOR_DIV_EXPR || code == FLOOR_MOD_EXPR
2298 || code == CEIL_DIV_EXPR || code == CEIL_MOD_EXPR
2299 || code == ROUND_DIV_EXPR || code == ROUND_MOD_EXPR)
2300 return save_expr (e);
2301 /* Recursively stabilize each operand. */
2302 result = build_nt (code, stabilize_reference_1 (TREE_OPERAND (e, 0)),
2303 stabilize_reference_1 (TREE_OPERAND (e, 1)));
2307 /* Recursively stabilize each operand. */
2308 result = build_nt (code, stabilize_reference_1 (TREE_OPERAND (e, 0)));
2315 TREE_TYPE (result) = TREE_TYPE (e);
2316 TREE_READONLY (result) = TREE_READONLY (e);
2317 TREE_SIDE_EFFECTS (result) = TREE_SIDE_EFFECTS (e);
2318 TREE_THIS_VOLATILE (result) = TREE_THIS_VOLATILE (e);
2323 /* Low-level constructors for expressions. */
2325 /* Build an expression of code CODE, data type TYPE,
2326 and operands as specified by the arguments ARG1 and following arguments.
2327 Expressions and reference nodes can be created this way.
2328 Constants, decls, types and misc nodes cannot be. */
2331 build VPARAMS ((enum tree_code code, tree tt, ...))
2340 VA_FIXEDARG (p, enum tree_code, code);
2341 VA_FIXEDARG (p, tree, tt);
2343 t = make_node (code);
2344 length = TREE_CODE_LENGTH (code);
2347 /* Below, we automatically set TREE_SIDE_EFFECTS and TREE_READONLY for the
2348 result based on those same flags for the arguments. But if the
2349 arguments aren't really even `tree' expressions, we shouldn't be trying
2351 fro = first_rtl_op (code);
2353 /* Expressions without side effects may be constant if their
2354 arguments are as well. */
2355 constant = (TREE_CODE_CLASS (code) == '<'
2356 || TREE_CODE_CLASS (code) == '1'
2357 || TREE_CODE_CLASS (code) == '2'
2358 || TREE_CODE_CLASS (code) == 'c');
2362 /* This is equivalent to the loop below, but faster. */
2363 tree arg0 = va_arg (p, tree);
2364 tree arg1 = va_arg (p, tree);
2366 TREE_OPERAND (t, 0) = arg0;
2367 TREE_OPERAND (t, 1) = arg1;
2368 TREE_READONLY (t) = 1;
2369 if (arg0 && fro > 0)
2371 if (TREE_SIDE_EFFECTS (arg0))
2372 TREE_SIDE_EFFECTS (t) = 1;
2373 if (!TREE_READONLY (arg0))
2374 TREE_READONLY (t) = 0;
2375 if (!TREE_CONSTANT (arg0))
2379 if (arg1 && fro > 1)
2381 if (TREE_SIDE_EFFECTS (arg1))
2382 TREE_SIDE_EFFECTS (t) = 1;
2383 if (!TREE_READONLY (arg1))
2384 TREE_READONLY (t) = 0;
2385 if (!TREE_CONSTANT (arg1))
2389 else if (length == 1)
2391 tree arg0 = va_arg (p, tree);
2393 /* The only one-operand cases we handle here are those with side-effects.
2394 Others are handled with build1. So don't bother checked if the
2395 arg has side-effects since we'll already have set it.
2397 ??? This really should use build1 too. */
2398 if (TREE_CODE_CLASS (code) != 's')
2400 TREE_OPERAND (t, 0) = arg0;
2404 for (i = 0; i < length; i++)
2406 tree operand = va_arg (p, tree);
2408 TREE_OPERAND (t, i) = operand;
2409 if (operand && fro > i)
2411 if (TREE_SIDE_EFFECTS (operand))
2412 TREE_SIDE_EFFECTS (t) = 1;
2413 if (!TREE_CONSTANT (operand))
2420 TREE_CONSTANT (t) = constant;
2424 /* Same as above, but only builds for unary operators.
2425 Saves lions share of calls to `build'; cuts down use
2426 of varargs, which is expensive for RISC machines. */
2429 build1 (code, type, node)
2430 enum tree_code code;
2435 #ifdef GATHER_STATISTICS
2436 tree_node_kind kind;
2440 #ifdef GATHER_STATISTICS
2441 if (TREE_CODE_CLASS (code) == 'r')
2447 #ifdef ENABLE_CHECKING
2448 if (TREE_CODE_CLASS (code) == '2'
2449 || TREE_CODE_CLASS (code) == '<'
2450 || TREE_CODE_LENGTH (code) != 1)
2452 #endif /* ENABLE_CHECKING */
2454 length = sizeof (struct tree_exp);
2456 t = ggc_alloc_tree (length);
2458 memset ((PTR) t, 0, sizeof (struct tree_common));
2460 #ifdef GATHER_STATISTICS
2461 tree_node_counts[(int) kind]++;
2462 tree_node_sizes[(int) kind] += length;
2465 TREE_SET_CODE (t, code);
2467 TREE_TYPE (t) = type;
2468 TREE_COMPLEXITY (t) = 0;
2469 TREE_OPERAND (t, 0) = node;
2470 if (node && first_rtl_op (code) != 0)
2472 TREE_SIDE_EFFECTS (t) = TREE_SIDE_EFFECTS (node);
2473 TREE_READONLY (t) = TREE_READONLY (node);
2482 case PREDECREMENT_EXPR:
2483 case PREINCREMENT_EXPR:
2484 case POSTDECREMENT_EXPR:
2485 case POSTINCREMENT_EXPR:
2486 /* All of these have side-effects, no matter what their
2488 TREE_SIDE_EFFECTS (t) = 1;
2489 TREE_READONLY (t) = 0;
2493 if (TREE_CODE_CLASS (code) == '1' && node && TREE_CONSTANT (node))
2494 TREE_CONSTANT (t) = 1;
2501 /* Similar except don't specify the TREE_TYPE
2502 and leave the TREE_SIDE_EFFECTS as 0.
2503 It is permissible for arguments to be null,
2504 or even garbage if their values do not matter. */
2507 build_nt VPARAMS ((enum tree_code code, ...))
2514 VA_FIXEDARG (p, enum tree_code, code);
2516 t = make_node (code);
2517 length = TREE_CODE_LENGTH (code);
2519 for (i = 0; i < length; i++)
2520 TREE_OPERAND (t, i) = va_arg (p, tree);
2526 /* Create a DECL_... node of code CODE, name NAME and data type TYPE.
2527 We do NOT enter this node in any sort of symbol table.
2529 layout_decl is used to set up the decl's storage layout.
2530 Other slots are initialized to 0 or null pointers. */
2533 build_decl (code, name, type)
2534 enum tree_code code;
2539 t = make_node (code);
2541 /* if (type == error_mark_node)
2542 type = integer_type_node; */
2543 /* That is not done, deliberately, so that having error_mark_node
2544 as the type can suppress useless errors in the use of this variable. */
2546 DECL_NAME (t) = name;
2547 TREE_TYPE (t) = type;
2549 if (code == VAR_DECL || code == PARM_DECL || code == RESULT_DECL)
2551 else if (code == FUNCTION_DECL)
2552 DECL_MODE (t) = FUNCTION_MODE;
2557 /* BLOCK nodes are used to represent the structure of binding contours
2558 and declarations, once those contours have been exited and their contents
2559 compiled. This information is used for outputting debugging info. */
2562 build_block (vars, tags, subblocks, supercontext, chain)
2563 tree vars, tags ATTRIBUTE_UNUSED, subblocks, supercontext, chain;
2565 tree block = make_node (BLOCK);
2567 BLOCK_VARS (block) = vars;
2568 BLOCK_SUBBLOCKS (block) = subblocks;
2569 BLOCK_SUPERCONTEXT (block) = supercontext;
2570 BLOCK_CHAIN (block) = chain;
2574 /* EXPR_WITH_FILE_LOCATION are used to keep track of the exact
2575 location where an expression or an identifier were encountered. It
2576 is necessary for languages where the frontend parser will handle
2577 recursively more than one file (Java is one of them). */
2580 build_expr_wfl (node, file, line, col)
2585 static const char *last_file = 0;
2586 static tree last_filenode = NULL_TREE;
2587 tree wfl = make_node (EXPR_WITH_FILE_LOCATION);
2589 EXPR_WFL_NODE (wfl) = node;
2590 EXPR_WFL_SET_LINECOL (wfl, line, col);
2591 if (file != last_file)
2594 last_filenode = file ? get_identifier (file) : NULL_TREE;
2597 EXPR_WFL_FILENAME_NODE (wfl) = last_filenode;
2600 TREE_SIDE_EFFECTS (wfl) = TREE_SIDE_EFFECTS (node);
2601 TREE_TYPE (wfl) = TREE_TYPE (node);
2607 /* Return a declaration like DDECL except that its DECL_ATTRIBUTES
2611 build_decl_attribute_variant (ddecl, attribute)
2612 tree ddecl, attribute;
2614 DECL_ATTRIBUTES (ddecl) = attribute;
2618 /* Return a type like TTYPE except that its TYPE_ATTRIBUTE
2621 Record such modified types already made so we don't make duplicates. */
2624 build_type_attribute_variant (ttype, attribute)
2625 tree ttype, attribute;
2627 if ( ! attribute_list_equal (TYPE_ATTRIBUTES (ttype), attribute))
2629 unsigned int hashcode;
2632 ntype = copy_node (ttype);
2634 TYPE_POINTER_TO (ntype) = 0;
2635 TYPE_REFERENCE_TO (ntype) = 0;
2636 TYPE_ATTRIBUTES (ntype) = attribute;
2638 /* Create a new main variant of TYPE. */
2639 TYPE_MAIN_VARIANT (ntype) = ntype;
2640 TYPE_NEXT_VARIANT (ntype) = 0;
2641 set_type_quals (ntype, TYPE_UNQUALIFIED);
2643 hashcode = (TYPE_HASH (TREE_CODE (ntype))
2644 + TYPE_HASH (TREE_TYPE (ntype))
2645 + attribute_hash_list (attribute));
2647 switch (TREE_CODE (ntype))
2650 hashcode += TYPE_HASH (TYPE_ARG_TYPES (ntype));
2653 hashcode += TYPE_HASH (TYPE_DOMAIN (ntype));
2656 hashcode += TYPE_HASH (TYPE_MAX_VALUE (ntype));
2659 hashcode += TYPE_HASH (TYPE_PRECISION (ntype));
2665 ntype = type_hash_canon (hashcode, ntype);
2666 ttype = build_qualified_type (ntype, TYPE_QUALS (ttype));
2672 /* Default value of targetm.comp_type_attributes that always returns 1. */
2675 default_comp_type_attributes (type1, type2)
2676 tree type1 ATTRIBUTE_UNUSED;
2677 tree type2 ATTRIBUTE_UNUSED;
2682 /* Default version of targetm.set_default_type_attributes that always does
2686 default_set_default_type_attributes (type)
2687 tree type ATTRIBUTE_UNUSED;
2691 /* Default version of targetm.insert_attributes that always does nothing. */
2693 default_insert_attributes (decl, attr_ptr)
2694 tree decl ATTRIBUTE_UNUSED;
2695 tree *attr_ptr ATTRIBUTE_UNUSED;
2699 /* Default value of targetm.attribute_table that is empty. */
2700 const struct attribute_spec default_target_attribute_table[] =
2702 { NULL, 0, 0, false, false, false, NULL }
2705 /* Default value of targetm.function_attribute_inlinable_p that always
2708 default_function_attribute_inlinable_p (fndecl)
2709 tree fndecl ATTRIBUTE_UNUSED;
2711 /* By default, functions with machine attributes cannot be inlined. */
2715 /* Return non-zero if IDENT is a valid name for attribute ATTR,
2718 We try both `text' and `__text__', ATTR may be either one. */
2719 /* ??? It might be a reasonable simplification to require ATTR to be only
2720 `text'. One might then also require attribute lists to be stored in
2721 their canonicalized form. */
2724 is_attribute_p (attr, ident)
2728 int ident_len, attr_len;
2731 if (TREE_CODE (ident) != IDENTIFIER_NODE)
2734 if (strcmp (attr, IDENTIFIER_POINTER (ident)) == 0)
2737 p = IDENTIFIER_POINTER (ident);
2738 ident_len = strlen (p);
2739 attr_len = strlen (attr);
2741 /* If ATTR is `__text__', IDENT must be `text'; and vice versa. */
2745 || attr[attr_len - 2] != '_'
2746 || attr[attr_len - 1] != '_')
2748 if (ident_len == attr_len - 4
2749 && strncmp (attr + 2, p, attr_len - 4) == 0)
2754 if (ident_len == attr_len + 4
2755 && p[0] == '_' && p[1] == '_'
2756 && p[ident_len - 2] == '_' && p[ident_len - 1] == '_'
2757 && strncmp (attr, p + 2, attr_len) == 0)
2764 /* Given an attribute name and a list of attributes, return a pointer to the
2765 attribute's list element if the attribute is part of the list, or NULL_TREE
2766 if not found. If the attribute appears more than once, this only
2767 returns the first occurrence; the TREE_CHAIN of the return value should
2768 be passed back in if further occurrences are wanted. */
2771 lookup_attribute (attr_name, list)
2772 const char *attr_name;
2777 for (l = list; l; l = TREE_CHAIN (l))
2779 if (TREE_CODE (TREE_PURPOSE (l)) != IDENTIFIER_NODE)
2781 if (is_attribute_p (attr_name, TREE_PURPOSE (l)))
2788 /* Return an attribute list that is the union of a1 and a2. */
2791 merge_attributes (a1, a2)
2796 /* Either one unset? Take the set one. */
2798 if ((attributes = a1) == 0)
2801 /* One that completely contains the other? Take it. */
2803 else if (a2 != 0 && ! attribute_list_contained (a1, a2))
2805 if (attribute_list_contained (a2, a1))
2809 /* Pick the longest list, and hang on the other list. */
2811 if (list_length (a1) < list_length (a2))
2812 attributes = a2, a2 = a1;
2814 for (; a2 != 0; a2 = TREE_CHAIN (a2))
2817 for (a = lookup_attribute (IDENTIFIER_POINTER (TREE_PURPOSE (a2)),
2820 a = lookup_attribute (IDENTIFIER_POINTER (TREE_PURPOSE (a2)),
2823 if (simple_cst_equal (TREE_VALUE (a), TREE_VALUE (a2)) == 1)
2828 a1 = copy_node (a2);
2829 TREE_CHAIN (a1) = attributes;
2838 /* Given types T1 and T2, merge their attributes and return
2842 merge_type_attributes (t1, t2)
2845 return merge_attributes (TYPE_ATTRIBUTES (t1),
2846 TYPE_ATTRIBUTES (t2));
2849 /* Given decls OLDDECL and NEWDECL, merge their attributes and return
2853 merge_decl_attributes (olddecl, newdecl)
2854 tree olddecl, newdecl;
2856 return merge_attributes (DECL_ATTRIBUTES (olddecl),
2857 DECL_ATTRIBUTES (newdecl));
2860 #ifdef TARGET_DLLIMPORT_DECL_ATTRIBUTES
2862 /* Specialization of merge_decl_attributes for various Windows targets.
2864 This handles the following situation:
2866 __declspec (dllimport) int foo;
2869 The second instance of `foo' nullifies the dllimport. */
2872 merge_dllimport_decl_attributes (old, new)
2877 int delete_dllimport_p;
2879 old = DECL_ATTRIBUTES (old);
2880 new = DECL_ATTRIBUTES (new);
2882 /* What we need to do here is remove from `old' dllimport if it doesn't
2883 appear in `new'. dllimport behaves like extern: if a declaration is
2884 marked dllimport and a definition appears later, then the object
2885 is not dllimport'd. */
2886 if (lookup_attribute ("dllimport", old) != NULL_TREE
2887 && lookup_attribute ("dllimport", new) == NULL_TREE)
2888 delete_dllimport_p = 1;
2890 delete_dllimport_p = 0;
2892 a = merge_attributes (old, new);
2894 if (delete_dllimport_p)
2898 /* Scan the list for dllimport and delete it. */
2899 for (prev = NULL_TREE, t = a; t; prev = t, t = TREE_CHAIN (t))
2901 if (is_attribute_p ("dllimport", TREE_PURPOSE (t)))
2903 if (prev == NULL_TREE)
2906 TREE_CHAIN (prev) = TREE_CHAIN (t);
2915 #endif /* TARGET_DLLIMPORT_DECL_ATTRIBUTES */
2917 /* Set the type qualifiers for TYPE to TYPE_QUALS, which is a bitmask
2918 of the various TYPE_QUAL values. */
2921 set_type_quals (type, type_quals)
2925 TYPE_READONLY (type) = (type_quals & TYPE_QUAL_CONST) != 0;
2926 TYPE_VOLATILE (type) = (type_quals & TYPE_QUAL_VOLATILE) != 0;
2927 TYPE_RESTRICT (type) = (type_quals & TYPE_QUAL_RESTRICT) != 0;
2930 /* Return a version of the TYPE, qualified as indicated by the
2931 TYPE_QUALS, if one exists. If no qualified version exists yet,
2932 return NULL_TREE. */
2935 get_qualified_type (type, type_quals)
2941 /* Search the chain of variants to see if there is already one there just
2942 like the one we need to have. If so, use that existing one. We must
2943 preserve the TYPE_NAME, since there is code that depends on this. */
2944 for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
2945 if (TYPE_QUALS (t) == type_quals && TYPE_NAME (t) == TYPE_NAME (type))
2951 /* Like get_qualified_type, but creates the type if it does not
2952 exist. This function never returns NULL_TREE. */
2955 build_qualified_type (type, type_quals)
2961 /* See if we already have the appropriate qualified variant. */
2962 t = get_qualified_type (type, type_quals);
2964 /* If not, build it. */
2967 t = build_type_copy (type);
2968 set_type_quals (t, type_quals);
2974 /* Create a new variant of TYPE, equivalent but distinct.
2975 This is so the caller can modify it. */
2978 build_type_copy (type)
2981 tree t, m = TYPE_MAIN_VARIANT (type);
2983 t = copy_node (type);
2985 TYPE_POINTER_TO (t) = 0;
2986 TYPE_REFERENCE_TO (t) = 0;
2988 /* Add this type to the chain of variants of TYPE. */
2989 TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (m);
2990 TYPE_NEXT_VARIANT (m) = t;
2995 /* Hashing of types so that we don't make duplicates.
2996 The entry point is `type_hash_canon'. */
2998 /* Compute a hash code for a list of types (chain of TREE_LIST nodes
2999 with types in the TREE_VALUE slots), by adding the hash codes
3000 of the individual types. */
3003 type_hash_list (list)
3006 unsigned int hashcode;
3009 for (hashcode = 0, tail = list; tail; tail = TREE_CHAIN (tail))
3010 hashcode += TYPE_HASH (TREE_VALUE (tail));
3015 /* These are the Hashtable callback functions. */
3017 /* Returns true if the types are equal. */
3020 type_hash_eq (va, vb)
3024 const struct type_hash *a = va, *b = vb;
3025 if (a->hash == b->hash
3026 && TREE_CODE (a->type) == TREE_CODE (b->type)
3027 && TREE_TYPE (a->type) == TREE_TYPE (b->type)
3028 && attribute_list_equal (TYPE_ATTRIBUTES (a->type),
3029 TYPE_ATTRIBUTES (b->type))
3030 && TYPE_ALIGN (a->type) == TYPE_ALIGN (b->type)
3031 && (TYPE_MAX_VALUE (a->type) == TYPE_MAX_VALUE (b->type)
3032 || tree_int_cst_equal (TYPE_MAX_VALUE (a->type),
3033 TYPE_MAX_VALUE (b->type)))
3034 && (TYPE_MIN_VALUE (a->type) == TYPE_MIN_VALUE (b->type)
3035 || tree_int_cst_equal (TYPE_MIN_VALUE (a->type),
3036 TYPE_MIN_VALUE (b->type)))
3037 /* Note that TYPE_DOMAIN is TYPE_ARG_TYPES for FUNCTION_TYPE. */
3038 && (TYPE_DOMAIN (a->type) == TYPE_DOMAIN (b->type)
3039 || (TYPE_DOMAIN (a->type)
3040 && TREE_CODE (TYPE_DOMAIN (a->type)) == TREE_LIST
3041 && TYPE_DOMAIN (b->type)
3042 && TREE_CODE (TYPE_DOMAIN (b->type)) == TREE_LIST
3043 && type_list_equal (TYPE_DOMAIN (a->type),
3044 TYPE_DOMAIN (b->type)))))
3049 /* Return the cached hash value. */
3052 type_hash_hash (item)
3055 return ((const struct type_hash *) item)->hash;
3058 /* Look in the type hash table for a type isomorphic to TYPE.
3059 If one is found, return it. Otherwise return 0. */
3062 type_hash_lookup (hashcode, type)
3063 unsigned int hashcode;
3066 struct type_hash *h, in;
3068 /* The TYPE_ALIGN field of a type is set by layout_type(), so we
3069 must call that routine before comparing TYPE_ALIGNs. */
3075 h = htab_find_with_hash (type_hash_table, &in, hashcode);
3081 /* Add an entry to the type-hash-table
3082 for a type TYPE whose hash code is HASHCODE. */
3085 type_hash_add (hashcode, type)
3086 unsigned int hashcode;
3089 struct type_hash *h;
3092 h = (struct type_hash *) ggc_alloc (sizeof (struct type_hash));
3095 loc = htab_find_slot_with_hash (type_hash_table, h, hashcode, INSERT);
3096 *(struct type_hash **) loc = h;
3099 /* Given TYPE, and HASHCODE its hash code, return the canonical
3100 object for an identical type if one already exists.
3101 Otherwise, return TYPE, and record it as the canonical object
3102 if it is a permanent object.
3104 To use this function, first create a type of the sort you want.
3105 Then compute its hash code from the fields of the type that
3106 make it different from other similar types.
3107 Then call this function and use the value.
3108 This function frees the type you pass in if it is a duplicate. */
3110 /* Set to 1 to debug without canonicalization. Never set by program. */
3111 int debug_no_type_hash = 0;
3114 type_hash_canon (hashcode, type)
3115 unsigned int hashcode;
3120 if (debug_no_type_hash)
3123 /* See if the type is in the hash table already. If so, return it.
3124 Otherwise, add the type. */
3125 t1 = type_hash_lookup (hashcode, type);
3128 #ifdef GATHER_STATISTICS
3129 tree_node_counts[(int) t_kind]--;
3130 tree_node_sizes[(int) t_kind] -= sizeof (struct tree_type);
3136 type_hash_add (hashcode, type);
3141 /* See if the data pointed to by the type hash table is marked. We consider
3142 it marked if the type is marked or if a debug type number or symbol
3143 table entry has been made for the type. This reduces the amount of
3144 debugging output and eliminates that dependency of the debug output on
3145 the number of garbage collections. */
3148 type_hash_marked_p (p)
3151 tree type = ((struct type_hash *) p)->type;
3153 return ggc_marked_p (type) || TYPE_SYMTAB_POINTER (type);
3156 /* Mark the entry in the type hash table the type it points to is marked.
3157 Also mark the type in case we are considering this entry "marked" by
3158 virtue of TYPE_SYMTAB_POINTER being set. */
3165 ggc_mark_tree (((struct type_hash *) p)->type);
3168 /* Mark the hashtable slot pointed to by ENTRY (which is really a
3169 `tree**') for GC. */
3172 mark_tree_hashtable_entry (entry, data)
3174 void *data ATTRIBUTE_UNUSED;
3176 ggc_mark_tree ((tree) *entry);
3180 /* Mark ARG (which is really a htab_t whose slots are trees) for
3184 mark_tree_hashtable (arg)
3187 htab_t t = *(htab_t *) arg;
3188 htab_traverse (t, mark_tree_hashtable_entry, 0);
3192 print_type_hash_statistics ()
3194 fprintf (stderr, "Type hash: size %ld, %ld elements, %f collisions\n",
3195 (long) htab_size (type_hash_table),
3196 (long) htab_elements (type_hash_table),
3197 htab_collisions (type_hash_table));
3200 /* Compute a hash code for a list of attributes (chain of TREE_LIST nodes
3201 with names in the TREE_PURPOSE slots and args in the TREE_VALUE slots),
3202 by adding the hash codes of the individual attributes. */
3205 attribute_hash_list (list)
3208 unsigned int hashcode;
3211 for (hashcode = 0, tail = list; tail; tail = TREE_CHAIN (tail))
3212 /* ??? Do we want to add in TREE_VALUE too? */
3213 hashcode += TYPE_HASH (TREE_PURPOSE (tail));
3217 /* Given two lists of attributes, return true if list l2 is
3218 equivalent to l1. */
3221 attribute_list_equal (l1, l2)
3224 return attribute_list_contained (l1, l2)
3225 && attribute_list_contained (l2, l1);
3228 /* Given two lists of attributes, return true if list L2 is
3229 completely contained within L1. */
3230 /* ??? This would be faster if attribute names were stored in a canonicalized
3231 form. Otherwise, if L1 uses `foo' and L2 uses `__foo__', the long method
3232 must be used to show these elements are equivalent (which they are). */
3233 /* ??? It's not clear that attributes with arguments will always be handled
3237 attribute_list_contained (l1, l2)
3242 /* First check the obvious, maybe the lists are identical. */
3246 /* Maybe the lists are similar. */
3247 for (t1 = l1, t2 = l2;
3249 && TREE_PURPOSE (t1) == TREE_PURPOSE (t2)
3250 && TREE_VALUE (t1) == TREE_VALUE (t2);
3251 t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2));
3253 /* Maybe the lists are equal. */
3254 if (t1 == 0 && t2 == 0)
3257 for (; t2 != 0; t2 = TREE_CHAIN (t2))
3260 for (attr = lookup_attribute (IDENTIFIER_POINTER (TREE_PURPOSE (t2)), l1);
3262 attr = lookup_attribute (IDENTIFIER_POINTER (TREE_PURPOSE (t2)),
3265 if (simple_cst_equal (TREE_VALUE (t2), TREE_VALUE (attr)) == 1)
3272 if (simple_cst_equal (TREE_VALUE (t2), TREE_VALUE (attr)) != 1)
3279 /* Given two lists of types
3280 (chains of TREE_LIST nodes with types in the TREE_VALUE slots)
3281 return 1 if the lists contain the same types in the same order.
3282 Also, the TREE_PURPOSEs must match. */
3285 type_list_equal (l1, l2)
3290 for (t1 = l1, t2 = l2; t1 && t2; t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2))
3291 if (TREE_VALUE (t1) != TREE_VALUE (t2)
3292 || (TREE_PURPOSE (t1) != TREE_PURPOSE (t2)
3293 && ! (1 == simple_cst_equal (TREE_PURPOSE (t1), TREE_PURPOSE (t2))
3294 && (TREE_TYPE (TREE_PURPOSE (t1))
3295 == TREE_TYPE (TREE_PURPOSE (t2))))))
3301 /* Returns the number of arguments to the FUNCTION_TYPE or METHOD_TYPE
3302 given by TYPE. If the argument list accepts variable arguments,
3303 then this function counts only the ordinary arguments. */
3306 type_num_arguments (type)
3312 for (t = TYPE_ARG_TYPES (type); t; t = TREE_CHAIN (t))
3313 /* If the function does not take a variable number of arguments,
3314 the last element in the list will have type `void'. */
3315 if (VOID_TYPE_P (TREE_VALUE (t)))
3323 /* Nonzero if integer constants T1 and T2
3324 represent the same constant value. */
3327 tree_int_cst_equal (t1, t2)
3333 if (t1 == 0 || t2 == 0)
3336 if (TREE_CODE (t1) == INTEGER_CST
3337 && TREE_CODE (t2) == INTEGER_CST
3338 && TREE_INT_CST_LOW (t1) == TREE_INT_CST_LOW (t2)
3339 && TREE_INT_CST_HIGH (t1) == TREE_INT_CST_HIGH (t2))
3345 /* Nonzero if integer constants T1 and T2 represent values that satisfy <.
3346 The precise way of comparison depends on their data type. */
3349 tree_int_cst_lt (t1, t2)
3355 if (! TREE_UNSIGNED (TREE_TYPE (t1)))
3356 return INT_CST_LT (t1, t2);
3358 return INT_CST_LT_UNSIGNED (t1, t2);
3361 /* Returns -1 if T1 < T2, 0 if T1 == T2, and 1 if T1 > T2. */
3364 tree_int_cst_compare (t1, t2)
3368 if (tree_int_cst_lt (t1, t2))
3370 else if (tree_int_cst_lt (t2, t1))
3376 /* Return 1 if T is an INTEGER_CST that can be represented in a single
3377 HOST_WIDE_INT value. If POS is nonzero, the result must be positive. */
3380 host_integerp (t, pos)
3384 return (TREE_CODE (t) == INTEGER_CST
3385 && ! TREE_OVERFLOW (t)
3386 && ((TREE_INT_CST_HIGH (t) == 0
3387 && (HOST_WIDE_INT) TREE_INT_CST_LOW (t) >= 0)
3388 || (! pos && TREE_INT_CST_HIGH (t) == -1
3389 && (HOST_WIDE_INT) TREE_INT_CST_LOW (t) < 0)
3390 || (! pos && TREE_INT_CST_HIGH (t) == 0
3391 && TREE_UNSIGNED (TREE_TYPE (t)))));
3394 /* Return the HOST_WIDE_INT least significant bits of T if it is an
3395 INTEGER_CST and there is no overflow. POS is nonzero if the result must
3396 be positive. Abort if we cannot satisfy the above conditions. */
3399 tree_low_cst (t, pos)
3403 if (host_integerp (t, pos))
3404 return TREE_INT_CST_LOW (t);
3409 /* Return the most significant bit of the integer constant T. */
3412 tree_int_cst_msb (t)
3417 unsigned HOST_WIDE_INT l;
3419 /* Note that using TYPE_PRECISION here is wrong. We care about the
3420 actual bits, not the (arbitrary) range of the type. */
3421 prec = GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (t))) - 1;
3422 rshift_double (TREE_INT_CST_LOW (t), TREE_INT_CST_HIGH (t), prec,
3423 2 * HOST_BITS_PER_WIDE_INT, &l, &h, 0);
3424 return (l & 1) == 1;
3427 /* Return an indication of the sign of the integer constant T.
3428 The return value is -1 if T < 0, 0 if T == 0, and 1 if T > 0.
3429 Note that -1 will never be returned it T's type is unsigned. */
3432 tree_int_cst_sgn (t)
3435 if (TREE_INT_CST_LOW (t) == 0 && TREE_INT_CST_HIGH (t) == 0)
3437 else if (TREE_UNSIGNED (TREE_TYPE (t)))
3439 else if (TREE_INT_CST_HIGH (t) < 0)
3445 /* Compare two constructor-element-type constants. Return 1 if the lists
3446 are known to be equal; otherwise return 0. */
3449 simple_cst_list_equal (l1, l2)
3452 while (l1 != NULL_TREE && l2 != NULL_TREE)
3454 if (simple_cst_equal (TREE_VALUE (l1), TREE_VALUE (l2)) != 1)
3457 l1 = TREE_CHAIN (l1);
3458 l2 = TREE_CHAIN (l2);
3464 /* Return truthvalue of whether T1 is the same tree structure as T2.
3465 Return 1 if they are the same.
3466 Return 0 if they are understandably different.
3467 Return -1 if either contains tree structure not understood by
3471 simple_cst_equal (t1, t2)
3474 enum tree_code code1, code2;
3480 if (t1 == 0 || t2 == 0)
3483 code1 = TREE_CODE (t1);
3484 code2 = TREE_CODE (t2);
3486 if (code1 == NOP_EXPR || code1 == CONVERT_EXPR || code1 == NON_LVALUE_EXPR)
3488 if (code2 == NOP_EXPR || code2 == CONVERT_EXPR
3489 || code2 == NON_LVALUE_EXPR)
3490 return simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
3492 return simple_cst_equal (TREE_OPERAND (t1, 0), t2);
3495 else if (code2 == NOP_EXPR || code2 == CONVERT_EXPR
3496 || code2 == NON_LVALUE_EXPR)
3497 return simple_cst_equal (t1, TREE_OPERAND (t2, 0));
3505 return (TREE_INT_CST_LOW (t1) == TREE_INT_CST_LOW (t2)
3506 && TREE_INT_CST_HIGH (t1) == TREE_INT_CST_HIGH (t2));
3509 return REAL_VALUES_IDENTICAL (TREE_REAL_CST (t1), TREE_REAL_CST (t2));
3512 return (TREE_STRING_LENGTH (t1) == TREE_STRING_LENGTH (t2)
3513 && ! memcmp (TREE_STRING_POINTER (t1), TREE_STRING_POINTER (t2),
3514 TREE_STRING_LENGTH (t1)));
3517 if (CONSTRUCTOR_ELTS (t1) == CONSTRUCTOR_ELTS (t2))
3523 return simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
3526 cmp = simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
3530 simple_cst_list_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1));
3533 /* Special case: if either target is an unallocated VAR_DECL,
3534 it means that it's going to be unified with whatever the
3535 TARGET_EXPR is really supposed to initialize, so treat it
3536 as being equivalent to anything. */
3537 if ((TREE_CODE (TREE_OPERAND (t1, 0)) == VAR_DECL
3538 && DECL_NAME (TREE_OPERAND (t1, 0)) == NULL_TREE
3539 && !DECL_RTL_SET_P (TREE_OPERAND (t1, 0)))
3540 || (TREE_CODE (TREE_OPERAND (t2, 0)) == VAR_DECL
3541 && DECL_NAME (TREE_OPERAND (t2, 0)) == NULL_TREE
3542 && !DECL_RTL_SET_P (TREE_OPERAND (t2, 0))))
3545 cmp = simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
3550 return simple_cst_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1));
3552 case WITH_CLEANUP_EXPR:
3553 cmp = simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
3557 return simple_cst_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t1, 1));
3560 if (TREE_OPERAND (t1, 1) == TREE_OPERAND (t2, 1))
3561 return simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
3575 /* This general rule works for most tree codes. All exceptions should be
3576 handled above. If this is a language-specific tree code, we can't
3577 trust what might be in the operand, so say we don't know
3579 if ((int) code1 >= (int) LAST_AND_UNUSED_TREE_CODE)
3582 switch (TREE_CODE_CLASS (code1))
3591 for (i = 0; i < TREE_CODE_LENGTH (code1); i++)
3593 cmp = simple_cst_equal (TREE_OPERAND (t1, i), TREE_OPERAND (t2, i));
3605 /* Compare the value of T, an INTEGER_CST, with U, an unsigned integer value.
3606 Return -1, 0, or 1 if the value of T is less than, equal to, or greater
3607 than U, respectively. */
3610 compare_tree_int (t, u)
3614 if (tree_int_cst_sgn (t) < 0)
3616 else if (TREE_INT_CST_HIGH (t) != 0)
3618 else if (TREE_INT_CST_LOW (t) == u)
3620 else if (TREE_INT_CST_LOW (t) < u)
3626 /* Constructors for pointer, array and function types.
3627 (RECORD_TYPE, UNION_TYPE and ENUMERAL_TYPE nodes are
3628 constructed by language-dependent code, not here.) */
3630 /* Construct, lay out and return the type of pointers to TO_TYPE.
3631 If such a type has already been constructed, reuse it. */
3634 build_pointer_type (to_type)
3637 tree t = TYPE_POINTER_TO (to_type);
3639 /* First, if we already have a type for pointers to TO_TYPE, use it. */
3644 /* We need a new one. */
3645 t = make_node (POINTER_TYPE);
3647 TREE_TYPE (t) = to_type;
3649 /* Record this type as the pointer to TO_TYPE. */
3650 TYPE_POINTER_TO (to_type) = t;
3652 /* Lay out the type. This function has many callers that are concerned
3653 with expression-construction, and this simplifies them all.
3654 Also, it guarantees the TYPE_SIZE is in the same obstack as the type. */
3660 /* Build the node for the type of references-to-TO_TYPE. */
3663 build_reference_type (to_type)
3666 tree t = TYPE_REFERENCE_TO (to_type);
3668 /* First, if we already have a type for pointers to TO_TYPE, use it. */
3673 /* We need a new one. */
3674 t = make_node (REFERENCE_TYPE);
3676 TREE_TYPE (t) = to_type;
3678 /* Record this type as the pointer to TO_TYPE. */
3679 TYPE_REFERENCE_TO (to_type) = t;
3686 /* Build a type that is compatible with t but has no cv quals anywhere
3689 const char *const *const * -> char ***. */
3692 build_type_no_quals (t)
3695 switch (TREE_CODE (t))
3698 return build_pointer_type (build_type_no_quals (TREE_TYPE (t)));
3699 case REFERENCE_TYPE:
3700 return build_reference_type (build_type_no_quals (TREE_TYPE (t)));
3702 return TYPE_MAIN_VARIANT (t);
3706 /* Create a type of integers to be the TYPE_DOMAIN of an ARRAY_TYPE.
3707 MAXVAL should be the maximum value in the domain
3708 (one less than the length of the array).
3710 The maximum value that MAXVAL can have is INT_MAX for a HOST_WIDE_INT.
3711 We don't enforce this limit, that is up to caller (e.g. language front end).
3712 The limit exists because the result is a signed type and we don't handle
3713 sizes that use more than one HOST_WIDE_INT. */
3716 build_index_type (maxval)
3719 tree itype = make_node (INTEGER_TYPE);
3721 TREE_TYPE (itype) = sizetype;
3722 TYPE_PRECISION (itype) = TYPE_PRECISION (sizetype);
3723 TYPE_MIN_VALUE (itype) = size_zero_node;
3724 TYPE_MAX_VALUE (itype) = convert (sizetype, maxval);
3725 TYPE_MODE (itype) = TYPE_MODE (sizetype);
3726 TYPE_SIZE (itype) = TYPE_SIZE (sizetype);
3727 TYPE_SIZE_UNIT (itype) = TYPE_SIZE_UNIT (sizetype);
3728 TYPE_ALIGN (itype) = TYPE_ALIGN (sizetype);
3729 TYPE_USER_ALIGN (itype) = TYPE_USER_ALIGN (sizetype);
3731 if (host_integerp (maxval, 1))
3732 return type_hash_canon (tree_low_cst (maxval, 1), itype);
3737 /* Create a range of some discrete type TYPE (an INTEGER_TYPE,
3738 ENUMERAL_TYPE, BOOLEAN_TYPE, or CHAR_TYPE), with
3739 low bound LOWVAL and high bound HIGHVAL.
3740 if TYPE==NULL_TREE, sizetype is used. */
3743 build_range_type (type, lowval, highval)
3744 tree type, lowval, highval;
3746 tree itype = make_node (INTEGER_TYPE);
3748 TREE_TYPE (itype) = type;
3749 if (type == NULL_TREE)
3752 TYPE_MIN_VALUE (itype) = convert (type, lowval);
3753 TYPE_MAX_VALUE (itype) = highval ? convert (type, highval) : NULL;
3755 TYPE_PRECISION (itype) = TYPE_PRECISION (type);
3756 TYPE_MODE (itype) = TYPE_MODE (type);
3757 TYPE_SIZE (itype) = TYPE_SIZE (type);
3758 TYPE_SIZE_UNIT (itype) = TYPE_SIZE_UNIT (type);
3759 TYPE_ALIGN (itype) = TYPE_ALIGN (type);
3760 TYPE_USER_ALIGN (itype) = TYPE_USER_ALIGN (type);
3762 if (host_integerp (lowval, 0) && highval != 0 && host_integerp (highval, 0))
3763 return type_hash_canon (tree_low_cst (highval, 0)
3764 - tree_low_cst (lowval, 0),
3770 /* Just like build_index_type, but takes lowval and highval instead
3771 of just highval (maxval). */
3774 build_index_2_type (lowval,highval)
3775 tree lowval, highval;
3777 return build_range_type (sizetype, lowval, highval);
3780 /* Return nonzero iff ITYPE1 and ITYPE2 are equal (in the LISP sense).
3781 Needed because when index types are not hashed, equal index types
3782 built at different times appear distinct, even though structurally,
3786 index_type_equal (itype1, itype2)
3787 tree itype1, itype2;
3789 if (TREE_CODE (itype1) != TREE_CODE (itype2))
3792 if (TREE_CODE (itype1) == INTEGER_TYPE)
3794 if (TYPE_PRECISION (itype1) != TYPE_PRECISION (itype2)
3795 || TYPE_MODE (itype1) != TYPE_MODE (itype2)
3796 || simple_cst_equal (TYPE_SIZE (itype1), TYPE_SIZE (itype2)) != 1
3797 || TYPE_ALIGN (itype1) != TYPE_ALIGN (itype2))
3800 if (1 == simple_cst_equal (TYPE_MIN_VALUE (itype1),
3801 TYPE_MIN_VALUE (itype2))
3802 && 1 == simple_cst_equal (TYPE_MAX_VALUE (itype1),
3803 TYPE_MAX_VALUE (itype2)))
3810 /* Construct, lay out and return the type of arrays of elements with ELT_TYPE
3811 and number of elements specified by the range of values of INDEX_TYPE.
3812 If such a type has already been constructed, reuse it. */
3815 build_array_type (elt_type, index_type)
3816 tree elt_type, index_type;
3819 unsigned int hashcode;
3821 if (TREE_CODE (elt_type) == FUNCTION_TYPE)
3823 error ("arrays of functions are not meaningful");
3824 elt_type = integer_type_node;
3827 /* Make sure TYPE_POINTER_TO (elt_type) is filled in. */
3828 build_pointer_type (elt_type);
3830 /* Allocate the array after the pointer type,
3831 in case we free it in type_hash_canon. */
3832 t = make_node (ARRAY_TYPE);
3833 TREE_TYPE (t) = elt_type;
3834 TYPE_DOMAIN (t) = index_type;
3836 if (index_type == 0)
3841 hashcode = TYPE_HASH (elt_type) + TYPE_HASH (index_type);
3842 t = type_hash_canon (hashcode, t);
3844 if (!COMPLETE_TYPE_P (t))
3849 /* Return the TYPE of the elements comprising
3850 the innermost dimension of ARRAY. */
3853 get_inner_array_type (array)
3856 tree type = TREE_TYPE (array);
3858 while (TREE_CODE (type) == ARRAY_TYPE)
3859 type = TREE_TYPE (type);
3864 /* Construct, lay out and return
3865 the type of functions returning type VALUE_TYPE
3866 given arguments of types ARG_TYPES.
3867 ARG_TYPES is a chain of TREE_LIST nodes whose TREE_VALUEs
3868 are data type nodes for the arguments of the function.
3869 If such a type has already been constructed, reuse it. */
3872 build_function_type (value_type, arg_types)
3873 tree value_type, arg_types;
3876 unsigned int hashcode;
3878 if (TREE_CODE (value_type) == FUNCTION_TYPE)
3880 error ("function return type cannot be function");
3881 value_type = integer_type_node;
3884 /* Make a node of the sort we want. */
3885 t = make_node (FUNCTION_TYPE);
3886 TREE_TYPE (t) = value_type;
3887 TYPE_ARG_TYPES (t) = arg_types;
3889 /* If we already have such a type, use the old one and free this one. */
3890 hashcode = TYPE_HASH (value_type) + type_hash_list (arg_types);
3891 t = type_hash_canon (hashcode, t);
3893 if (!COMPLETE_TYPE_P (t))
3898 /* Construct, lay out and return the type of methods belonging to class
3899 BASETYPE and whose arguments and values are described by TYPE.
3900 If that type exists already, reuse it.
3901 TYPE must be a FUNCTION_TYPE node. */
3904 build_method_type (basetype, type)
3905 tree basetype, type;
3908 unsigned int hashcode;
3910 /* Make a node of the sort we want. */
3911 t = make_node (METHOD_TYPE);
3913 if (TREE_CODE (type) != FUNCTION_TYPE)
3916 TYPE_METHOD_BASETYPE (t) = TYPE_MAIN_VARIANT (basetype);
3917 TREE_TYPE (t) = TREE_TYPE (type);
3919 /* The actual arglist for this function includes a "hidden" argument
3920 which is "this". Put it into the list of argument types. */
3923 = tree_cons (NULL_TREE,
3924 build_pointer_type (basetype), TYPE_ARG_TYPES (type));
3926 /* If we already have such a type, use the old one and free this one. */
3927 hashcode = TYPE_HASH (basetype) + TYPE_HASH (type);
3928 t = type_hash_canon (hashcode, t);
3930 if (!COMPLETE_TYPE_P (t))
3936 /* Construct, lay out and return the type of offsets to a value
3937 of type TYPE, within an object of type BASETYPE.
3938 If a suitable offset type exists already, reuse it. */
3941 build_offset_type (basetype, type)
3942 tree basetype, type;
3945 unsigned int hashcode;
3947 /* Make a node of the sort we want. */
3948 t = make_node (OFFSET_TYPE);
3950 TYPE_OFFSET_BASETYPE (t) = TYPE_MAIN_VARIANT (basetype);
3951 TREE_TYPE (t) = type;
3953 /* If we already have such a type, use the old one and free this one. */
3954 hashcode = TYPE_HASH (basetype) + TYPE_HASH (type);
3955 t = type_hash_canon (hashcode, t);
3957 if (!COMPLETE_TYPE_P (t))
3963 /* Create a complex type whose components are COMPONENT_TYPE. */
3966 build_complex_type (component_type)
3967 tree component_type;
3970 unsigned int hashcode;
3972 /* Make a node of the sort we want. */
3973 t = make_node (COMPLEX_TYPE);
3975 TREE_TYPE (t) = TYPE_MAIN_VARIANT (component_type);
3976 set_type_quals (t, TYPE_QUALS (component_type));
3978 /* If we already have such a type, use the old one and free this one. */
3979 hashcode = TYPE_HASH (component_type);
3980 t = type_hash_canon (hashcode, t);
3982 if (!COMPLETE_TYPE_P (t))
3985 /* If we are writing Dwarf2 output we need to create a name,
3986 since complex is a fundamental type. */
3987 if (write_symbols == DWARF2_DEBUG && ! TYPE_NAME (t))
3990 if (component_type == char_type_node)
3991 name = "complex char";
3992 else if (component_type == signed_char_type_node)
3993 name = "complex signed char";
3994 else if (component_type == unsigned_char_type_node)
3995 name = "complex unsigned char";
3996 else if (component_type == short_integer_type_node)
3997 name = "complex short int";
3998 else if (component_type == short_unsigned_type_node)
3999 name = "complex short unsigned int";
4000 else if (component_type == integer_type_node)
4001 name = "complex int";
4002 else if (component_type == unsigned_type_node)
4003 name = "complex unsigned int";
4004 else if (component_type == long_integer_type_node)
4005 name = "complex long int";
4006 else if (component_type == long_unsigned_type_node)
4007 name = "complex long unsigned int";
4008 else if (component_type == long_long_integer_type_node)
4009 name = "complex long long int";
4010 else if (component_type == long_long_unsigned_type_node)
4011 name = "complex long long unsigned int";
4016 TYPE_NAME (t) = get_identifier (name);
4022 /* Return OP, stripped of any conversions to wider types as much as is safe.
4023 Converting the value back to OP's type makes a value equivalent to OP.
4025 If FOR_TYPE is nonzero, we return a value which, if converted to
4026 type FOR_TYPE, would be equivalent to converting OP to type FOR_TYPE.
4028 If FOR_TYPE is nonzero, unaligned bit-field references may be changed to the
4029 narrowest type that can hold the value, even if they don't exactly fit.
4030 Otherwise, bit-field references are changed to a narrower type
4031 only if they can be fetched directly from memory in that type.
4033 OP must have integer, real or enumeral type. Pointers are not allowed!
4035 There are some cases where the obvious value we could return
4036 would regenerate to OP if converted to OP's type,
4037 but would not extend like OP to wider types.
4038 If FOR_TYPE indicates such extension is contemplated, we eschew such values.
4039 For example, if OP is (unsigned short)(signed char)-1,
4040 we avoid returning (signed char)-1 if FOR_TYPE is int,
4041 even though extending that to an unsigned short would regenerate OP,
4042 since the result of extending (signed char)-1 to (int)
4043 is different from (int) OP. */
4046 get_unwidened (op, for_type)
4050 /* Set UNS initially if converting OP to FOR_TYPE is a zero-extension. */
4051 tree type = TREE_TYPE (op);
4053 = TYPE_PRECISION (for_type != 0 ? for_type : type);
4055 = (for_type != 0 && for_type != type
4056 && final_prec > TYPE_PRECISION (type)
4057 && TREE_UNSIGNED (type));
4060 while (TREE_CODE (op) == NOP_EXPR)
4063 = TYPE_PRECISION (TREE_TYPE (op))
4064 - TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op, 0)));
4066 /* Truncations are many-one so cannot be removed.
4067 Unless we are later going to truncate down even farther. */
4069 && final_prec > TYPE_PRECISION (TREE_TYPE (op)))
4072 /* See what's inside this conversion. If we decide to strip it,
4074 op = TREE_OPERAND (op, 0);
4076 /* If we have not stripped any zero-extensions (uns is 0),
4077 we can strip any kind of extension.
4078 If we have previously stripped a zero-extension,
4079 only zero-extensions can safely be stripped.
4080 Any extension can be stripped if the bits it would produce
4081 are all going to be discarded later by truncating to FOR_TYPE. */
4085 if (! uns || final_prec <= TYPE_PRECISION (TREE_TYPE (op)))
4087 /* TREE_UNSIGNED says whether this is a zero-extension.
4088 Let's avoid computing it if it does not affect WIN
4089 and if UNS will not be needed again. */
4090 if ((uns || TREE_CODE (op) == NOP_EXPR)
4091 && TREE_UNSIGNED (TREE_TYPE (op)))
4099 if (TREE_CODE (op) == COMPONENT_REF
4100 /* Since type_for_size always gives an integer type. */
4101 && TREE_CODE (type) != REAL_TYPE
4102 /* Don't crash if field not laid out yet. */
4103 && DECL_SIZE (TREE_OPERAND (op, 1)) != 0
4104 && host_integerp (DECL_SIZE (TREE_OPERAND (op, 1)), 1))
4106 unsigned int innerprec
4107 = tree_low_cst (DECL_SIZE (TREE_OPERAND (op, 1)), 1);
4109 type = type_for_size (innerprec, TREE_UNSIGNED (TREE_OPERAND (op, 1)));
4111 /* We can get this structure field in the narrowest type it fits in.
4112 If FOR_TYPE is 0, do this only for a field that matches the
4113 narrower type exactly and is aligned for it
4114 The resulting extension to its nominal type (a fullword type)
4115 must fit the same conditions as for other extensions. */
4117 if (innerprec < TYPE_PRECISION (TREE_TYPE (op))
4118 && (for_type || ! DECL_BIT_FIELD (TREE_OPERAND (op, 1)))
4119 && (! uns || final_prec <= innerprec
4120 || TREE_UNSIGNED (TREE_OPERAND (op, 1)))
4123 win = build (COMPONENT_REF, type, TREE_OPERAND (op, 0),
4124 TREE_OPERAND (op, 1));
4125 TREE_SIDE_EFFECTS (win) = TREE_SIDE_EFFECTS (op);
4126 TREE_THIS_VOLATILE (win) = TREE_THIS_VOLATILE (op);
4133 /* Return OP or a simpler expression for a narrower value
4134 which can be sign-extended or zero-extended to give back OP.
4135 Store in *UNSIGNEDP_PTR either 1 if the value should be zero-extended
4136 or 0 if the value should be sign-extended. */
4139 get_narrower (op, unsignedp_ptr)
4147 while (TREE_CODE (op) == NOP_EXPR)
4150 = (TYPE_PRECISION (TREE_TYPE (op))
4151 - TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op, 0))));
4153 /* Truncations are many-one so cannot be removed. */
4157 /* See what's inside this conversion. If we decide to strip it,
4159 op = TREE_OPERAND (op, 0);
4163 /* An extension: the outermost one can be stripped,
4164 but remember whether it is zero or sign extension. */
4166 uns = TREE_UNSIGNED (TREE_TYPE (op));
4167 /* Otherwise, if a sign extension has been stripped,
4168 only sign extensions can now be stripped;
4169 if a zero extension has been stripped, only zero-extensions. */
4170 else if (uns != TREE_UNSIGNED (TREE_TYPE (op)))
4174 else /* bitschange == 0 */
4176 /* A change in nominal type can always be stripped, but we must
4177 preserve the unsignedness. */
4179 uns = TREE_UNSIGNED (TREE_TYPE (op));
4186 if (TREE_CODE (op) == COMPONENT_REF
4187 /* Since type_for_size always gives an integer type. */
4188 && TREE_CODE (TREE_TYPE (op)) != REAL_TYPE
4189 /* Ensure field is laid out already. */
4190 && DECL_SIZE (TREE_OPERAND (op, 1)) != 0)
4192 unsigned HOST_WIDE_INT innerprec
4193 = tree_low_cst (DECL_SIZE (TREE_OPERAND (op, 1)), 1);
4194 tree type = type_for_size (innerprec, TREE_UNSIGNED (op));
4196 /* We can get this structure field in a narrower type that fits it,
4197 but the resulting extension to its nominal type (a fullword type)
4198 must satisfy the same conditions as for other extensions.
4200 Do this only for fields that are aligned (not bit-fields),
4201 because when bit-field insns will be used there is no
4202 advantage in doing this. */
4204 if (innerprec < TYPE_PRECISION (TREE_TYPE (op))
4205 && ! DECL_BIT_FIELD (TREE_OPERAND (op, 1))
4206 && (first || uns == TREE_UNSIGNED (TREE_OPERAND (op, 1)))
4210 uns = TREE_UNSIGNED (TREE_OPERAND (op, 1));
4211 win = build (COMPONENT_REF, type, TREE_OPERAND (op, 0),
4212 TREE_OPERAND (op, 1));
4213 TREE_SIDE_EFFECTS (win) = TREE_SIDE_EFFECTS (op);
4214 TREE_THIS_VOLATILE (win) = TREE_THIS_VOLATILE (op);
4217 *unsignedp_ptr = uns;
4221 /* Nonzero if integer constant C has a value that is permissible
4222 for type TYPE (an INTEGER_TYPE). */
4225 int_fits_type_p (c, type)
4228 /* If the bounds of the type are integers, we can check ourselves.
4229 Otherwise,. use force_fit_type, which checks against the precision. */
4230 if (TYPE_MAX_VALUE (type) != NULL_TREE
4231 && TYPE_MIN_VALUE (type) != NULL_TREE
4232 && TREE_CODE (TYPE_MAX_VALUE (type)) == INTEGER_CST
4233 && TREE_CODE (TYPE_MIN_VALUE (type)) == INTEGER_CST)
4235 if (TREE_UNSIGNED (type))
4236 return (! INT_CST_LT_UNSIGNED (TYPE_MAX_VALUE (type), c)
4237 && ! INT_CST_LT_UNSIGNED (c, TYPE_MIN_VALUE (type))
4238 /* Negative ints never fit unsigned types. */
4239 && ! (TREE_INT_CST_HIGH (c) < 0
4240 && ! TREE_UNSIGNED (TREE_TYPE (c))));
4242 return (! INT_CST_LT (TYPE_MAX_VALUE (type), c)
4243 && ! INT_CST_LT (c, TYPE_MIN_VALUE (type))
4244 /* Unsigned ints with top bit set never fit signed types. */
4245 && ! (TREE_INT_CST_HIGH (c) < 0
4246 && TREE_UNSIGNED (TREE_TYPE (c))));
4251 TREE_TYPE (c) = type;
4252 return !force_fit_type (c, 0);
4256 /* Given a DECL or TYPE, return the scope in which it was declared, or
4257 NULL_TREE if there is no containing scope. */
4260 get_containing_scope (t)
4263 return (TYPE_P (t) ? TYPE_CONTEXT (t) : DECL_CONTEXT (t));
4266 /* Return the innermost context enclosing DECL that is
4267 a FUNCTION_DECL, or zero if none. */
4270 decl_function_context (decl)
4275 if (TREE_CODE (decl) == ERROR_MARK)
4278 if (TREE_CODE (decl) == SAVE_EXPR)
4279 context = SAVE_EXPR_CONTEXT (decl);
4281 /* C++ virtual functions use DECL_CONTEXT for the class of the vtable
4282 where we look up the function at runtime. Such functions always take
4283 a first argument of type 'pointer to real context'.
4285 C++ should really be fixed to use DECL_CONTEXT for the real context,
4286 and use something else for the "virtual context". */
4287 else if (TREE_CODE (decl) == FUNCTION_DECL && DECL_VINDEX (decl))
4290 (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl)))));
4292 context = DECL_CONTEXT (decl);
4294 while (context && TREE_CODE (context) != FUNCTION_DECL)
4296 if (TREE_CODE (context) == BLOCK)
4297 context = BLOCK_SUPERCONTEXT (context);
4299 context = get_containing_scope (context);
4305 /* Return the innermost context enclosing DECL that is
4306 a RECORD_TYPE, UNION_TYPE or QUAL_UNION_TYPE, or zero if none.
4307 TYPE_DECLs and FUNCTION_DECLs are transparent to this function. */
4310 decl_type_context (decl)
4313 tree context = DECL_CONTEXT (decl);
4317 if (TREE_CODE (context) == RECORD_TYPE
4318 || TREE_CODE (context) == UNION_TYPE
4319 || TREE_CODE (context) == QUAL_UNION_TYPE)
4322 if (TREE_CODE (context) == TYPE_DECL
4323 || TREE_CODE (context) == FUNCTION_DECL)
4324 context = DECL_CONTEXT (context);
4326 else if (TREE_CODE (context) == BLOCK)
4327 context = BLOCK_SUPERCONTEXT (context);
4330 /* Unhandled CONTEXT!? */
4336 /* CALL is a CALL_EXPR. Return the declaration for the function
4337 called, or NULL_TREE if the called function cannot be
4341 get_callee_fndecl (call)
4346 /* It's invalid to call this function with anything but a
4348 if (TREE_CODE (call) != CALL_EXPR)
4351 /* The first operand to the CALL is the address of the function
4353 addr = TREE_OPERAND (call, 0);
4357 /* If this is a readonly function pointer, extract its initial value. */
4358 if (DECL_P (addr) && TREE_CODE (addr) != FUNCTION_DECL
4359 && TREE_READONLY (addr) && ! TREE_THIS_VOLATILE (addr)
4360 && DECL_INITIAL (addr))
4361 addr = DECL_INITIAL (addr);
4363 /* If the address is just `&f' for some function `f', then we know
4364 that `f' is being called. */
4365 if (TREE_CODE (addr) == ADDR_EXPR
4366 && TREE_CODE (TREE_OPERAND (addr, 0)) == FUNCTION_DECL)
4367 return TREE_OPERAND (addr, 0);
4369 /* We couldn't figure out what was being called. */
4373 /* Print debugging information about the obstack O, named STR. */
4376 print_obstack_statistics (str, o)
4380 struct _obstack_chunk *chunk = o->chunk;
4384 n_alloc += o->next_free - chunk->contents;
4385 chunk = chunk->prev;
4389 n_alloc += chunk->limit - &chunk->contents[0];
4390 chunk = chunk->prev;
4392 fprintf (stderr, "obstack %s: %u bytes, %d chunks\n",
4393 str, n_alloc, n_chunks);
4396 /* Print debugging information about tree nodes generated during the compile,
4397 and any language-specific information. */
4400 dump_tree_statistics ()
4402 #ifdef GATHER_STATISTICS
4404 int total_nodes, total_bytes;
4407 fprintf (stderr, "\n??? tree nodes created\n\n");
4408 #ifdef GATHER_STATISTICS
4409 fprintf (stderr, "Kind Nodes Bytes\n");
4410 fprintf (stderr, "-------------------------------------\n");
4411 total_nodes = total_bytes = 0;
4412 for (i = 0; i < (int) all_kinds; i++)
4414 fprintf (stderr, "%-20s %6d %9d\n", tree_node_kind_names[i],
4415 tree_node_counts[i], tree_node_sizes[i]);
4416 total_nodes += tree_node_counts[i];
4417 total_bytes += tree_node_sizes[i];
4419 fprintf (stderr, "-------------------------------------\n");
4420 fprintf (stderr, "%-20s %6d %9d\n", "Total", total_nodes, total_bytes);
4421 fprintf (stderr, "-------------------------------------\n");
4423 fprintf (stderr, "(No per-node statistics)\n");
4425 print_obstack_statistics ("permanent_obstack", &permanent_obstack);
4426 print_type_hash_statistics ();
4427 print_lang_statistics ();
4430 #define FILE_FUNCTION_PREFIX_LEN 9
4432 #define FILE_FUNCTION_FORMAT "_GLOBAL__%s_%s"
4434 /* Appends 6 random characters to TEMPLATE to (hopefully) avoid name
4435 clashes in cases where we can't reliably choose a unique name.
4437 Derived from mkstemp.c in libiberty. */
4440 append_random_chars (template)
4443 static const char letters[]
4444 = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
4445 static unsigned HOST_WIDE_INT value;
4446 unsigned HOST_WIDE_INT v;
4452 /* VALUE should be unique for each file and must
4453 not change between compiles since this can cause
4454 bootstrap comparison errors. */
4456 if (stat (main_input_filename, &st) < 0)
4459 value = st.st_dev ^ st.st_ino ^ st.st_mtime;
4462 template += strlen (template);
4466 /* Fill in the random bits. */
4467 template[0] = letters[v % 62];
4469 template[1] = letters[v % 62];
4471 template[2] = letters[v % 62];
4473 template[3] = letters[v % 62];
4475 template[4] = letters[v % 62];
4477 template[5] = letters[v % 62];
4482 /* P is a string that will be used in a symbol. Mask out any characters
4483 that are not valid in that context. */
4486 clean_symbol_name (p)
4491 #ifndef NO_DOLLAR_IN_LABEL /* this for `$'; unlikely, but... -- kr */
4494 #ifndef NO_DOT_IN_LABEL /* this for `.'; unlikely, but... */
4501 /* Generate a name for a function unique to this translation unit.
4502 TYPE is some string to identify the purpose of this function to the
4503 linker or collect2. */
4506 get_file_function_name_long (type)
4513 if (first_global_object_name)
4514 p = first_global_object_name;
4517 /* We don't have anything that we know to be unique to this translation
4518 unit, so use what we do have and throw in some randomness. */
4520 const char *name = weak_global_object_name;
4521 const char *file = main_input_filename;
4526 file = input_filename;
4528 q = (char *) alloca (7 + strlen (name) + strlen (file));
4530 sprintf (q, "%s%s", name, file);
4531 append_random_chars (q);
4535 buf = (char *) alloca (sizeof (FILE_FUNCTION_FORMAT) + strlen (p)
4538 /* Set up the name of the file-level functions we may need.
4539 Use a global object (which is already required to be unique over
4540 the program) rather than the file name (which imposes extra
4542 sprintf (buf, FILE_FUNCTION_FORMAT, type, p);
4544 /* Don't need to pull weird characters out of global names. */
4545 if (p != first_global_object_name)
4546 clean_symbol_name (buf + 11);
4548 return get_identifier (buf);
4551 /* If KIND=='I', return a suitable global initializer (constructor) name.
4552 If KIND=='D', return a suitable global clean-up (destructor) name. */
4555 get_file_function_name (kind)
4563 return get_file_function_name_long (p);
4566 /* Expand (the constant part of) a SET_TYPE CONSTRUCTOR node.
4567 The result is placed in BUFFER (which has length BIT_SIZE),
4568 with one bit in each char ('\000' or '\001').
4570 If the constructor is constant, NULL_TREE is returned.
4571 Otherwise, a TREE_LIST of the non-constant elements is emitted. */
4574 get_set_constructor_bits (init, buffer, bit_size)
4581 HOST_WIDE_INT domain_min
4582 = tree_low_cst (TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (init))), 0);
4583 tree non_const_bits = NULL_TREE;
4585 for (i = 0; i < bit_size; i++)
4588 for (vals = TREE_OPERAND (init, 1);
4589 vals != NULL_TREE; vals = TREE_CHAIN (vals))
4591 if (!host_integerp (TREE_VALUE (vals), 0)
4592 || (TREE_PURPOSE (vals) != NULL_TREE
4593 && !host_integerp (TREE_PURPOSE (vals), 0)))
4595 = tree_cons (TREE_PURPOSE (vals), TREE_VALUE (vals), non_const_bits);
4596 else if (TREE_PURPOSE (vals) != NULL_TREE)
4598 /* Set a range of bits to ones. */
4599 HOST_WIDE_INT lo_index
4600 = tree_low_cst (TREE_PURPOSE (vals), 0) - domain_min;
4601 HOST_WIDE_INT hi_index
4602 = tree_low_cst (TREE_VALUE (vals), 0) - domain_min;
4604 if (lo_index < 0 || lo_index >= bit_size
4605 || hi_index < 0 || hi_index >= bit_size)
4607 for (; lo_index <= hi_index; lo_index++)
4608 buffer[lo_index] = 1;
4612 /* Set a single bit to one. */
4614 = tree_low_cst (TREE_VALUE (vals), 0) - domain_min;
4615 if (index < 0 || index >= bit_size)
4617 error ("invalid initializer for bit string");
4623 return non_const_bits;
4626 /* Expand (the constant part of) a SET_TYPE CONSTRUCTOR node.
4627 The result is placed in BUFFER (which is an array of bytes).
4628 If the constructor is constant, NULL_TREE is returned.
4629 Otherwise, a TREE_LIST of the non-constant elements is emitted. */
4632 get_set_constructor_bytes (init, buffer, wd_size)
4634 unsigned char *buffer;
4638 int set_word_size = BITS_PER_UNIT;
4639 int bit_size = wd_size * set_word_size;
4641 unsigned char *bytep = buffer;
4642 char *bit_buffer = (char *) alloca (bit_size);
4643 tree non_const_bits = get_set_constructor_bits (init, bit_buffer, bit_size);
4645 for (i = 0; i < wd_size; i++)
4648 for (i = 0; i < bit_size; i++)
4652 if (BYTES_BIG_ENDIAN)
4653 *bytep |= (1 << (set_word_size - 1 - bit_pos));
4655 *bytep |= 1 << bit_pos;
4658 if (bit_pos >= set_word_size)
4659 bit_pos = 0, bytep++;
4661 return non_const_bits;
4664 #if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
4665 /* Complain that the tree code of NODE does not match the expected CODE.
4666 FILE, LINE, and FUNCTION are of the caller. */
4669 tree_check_failed (node, code, file, line, function)
4671 enum tree_code code;
4674 const char *function;
4676 internal_error ("Tree check: expected %s, have %s in %s, at %s:%d",
4677 tree_code_name[code], tree_code_name[TREE_CODE (node)],
4678 function, trim_filename (file), line);
4681 /* Similar to above, except that we check for a class of tree
4682 code, given in CL. */
4685 tree_class_check_failed (node, cl, file, line, function)
4690 const char *function;
4693 ("Tree check: expected class '%c', have '%c' (%s) in %s, at %s:%d",
4694 cl, TREE_CODE_CLASS (TREE_CODE (node)),
4695 tree_code_name[TREE_CODE (node)], function, trim_filename (file), line);
4698 #endif /* ENABLE_TREE_CHECKING */
4700 /* For a new vector type node T, build the information necessary for
4701 debuggint output. */
4704 finish_vector_type (t)
4710 tree index = build_int_2 (TYPE_VECTOR_SUBPARTS (t) - 1, 0);
4711 tree array = build_array_type (TREE_TYPE (t),
4712 build_index_type (index));
4713 tree rt = make_node (RECORD_TYPE);
4715 TYPE_FIELDS (rt) = build_decl (FIELD_DECL, get_identifier ("f"), array);
4716 DECL_CONTEXT (TYPE_FIELDS (rt)) = rt;
4718 TYPE_DEBUG_REPRESENTATION_TYPE (t) = rt;
4719 /* In dwarfout.c, type lookup uses TYPE_UID numbers. We want to output
4720 the representation type, and we want to find that die when looking up
4721 the vector type. This is most easily achieved by making the TYPE_UID
4723 TYPE_UID (rt) = TYPE_UID (t);
4727 /* Create nodes for all integer types (and error_mark_node) using the sizes
4728 of C datatypes. The caller should call set_sizetype soon after calling
4729 this function to select one of the types as sizetype. */
4732 build_common_tree_nodes (signed_char)
4735 error_mark_node = make_node (ERROR_MARK);
4736 TREE_TYPE (error_mark_node) = error_mark_node;
4738 initialize_sizetypes ();
4740 /* Define both `signed char' and `unsigned char'. */
4741 signed_char_type_node = make_signed_type (CHAR_TYPE_SIZE);
4742 unsigned_char_type_node = make_unsigned_type (CHAR_TYPE_SIZE);
4744 /* Define `char', which is like either `signed char' or `unsigned char'
4745 but not the same as either. */
4748 ? make_signed_type (CHAR_TYPE_SIZE)
4749 : make_unsigned_type (CHAR_TYPE_SIZE));
4751 short_integer_type_node = make_signed_type (SHORT_TYPE_SIZE);
4752 short_unsigned_type_node = make_unsigned_type (SHORT_TYPE_SIZE);
4753 integer_type_node = make_signed_type (INT_TYPE_SIZE);
4754 unsigned_type_node = make_unsigned_type (INT_TYPE_SIZE);
4755 long_integer_type_node = make_signed_type (LONG_TYPE_SIZE);
4756 long_unsigned_type_node = make_unsigned_type (LONG_TYPE_SIZE);
4757 long_long_integer_type_node = make_signed_type (LONG_LONG_TYPE_SIZE);
4758 long_long_unsigned_type_node = make_unsigned_type (LONG_LONG_TYPE_SIZE);
4760 intQI_type_node = make_signed_type (GET_MODE_BITSIZE (QImode));
4761 intHI_type_node = make_signed_type (GET_MODE_BITSIZE (HImode));
4762 intSI_type_node = make_signed_type (GET_MODE_BITSIZE (SImode));
4763 intDI_type_node = make_signed_type (GET_MODE_BITSIZE (DImode));
4764 intTI_type_node = make_signed_type (GET_MODE_BITSIZE (TImode));
4766 unsigned_intQI_type_node = make_unsigned_type (GET_MODE_BITSIZE (QImode));
4767 unsigned_intHI_type_node = make_unsigned_type (GET_MODE_BITSIZE (HImode));
4768 unsigned_intSI_type_node = make_unsigned_type (GET_MODE_BITSIZE (SImode));
4769 unsigned_intDI_type_node = make_unsigned_type (GET_MODE_BITSIZE (DImode));
4770 unsigned_intTI_type_node = make_unsigned_type (GET_MODE_BITSIZE (TImode));
4773 /* Call this function after calling build_common_tree_nodes and set_sizetype.
4774 It will create several other common tree nodes. */
4777 build_common_tree_nodes_2 (short_double)
4780 /* Define these next since types below may used them. */
4781 integer_zero_node = build_int_2 (0, 0);
4782 integer_one_node = build_int_2 (1, 0);
4783 integer_minus_one_node = build_int_2 (-1, -1);
4785 size_zero_node = size_int (0);
4786 size_one_node = size_int (1);
4787 bitsize_zero_node = bitsize_int (0);
4788 bitsize_one_node = bitsize_int (1);
4789 bitsize_unit_node = bitsize_int (BITS_PER_UNIT);
4791 void_type_node = make_node (VOID_TYPE);
4792 layout_type (void_type_node);
4794 /* We are not going to have real types in C with less than byte alignment,
4795 so we might as well not have any types that claim to have it. */
4796 TYPE_ALIGN (void_type_node) = BITS_PER_UNIT;
4797 TYPE_USER_ALIGN (void_type_node) = 0;
4799 null_pointer_node = build_int_2 (0, 0);
4800 TREE_TYPE (null_pointer_node) = build_pointer_type (void_type_node);
4801 layout_type (TREE_TYPE (null_pointer_node));
4803 ptr_type_node = build_pointer_type (void_type_node);
4805 = build_pointer_type (build_type_variant (void_type_node, 1, 0));
4807 float_type_node = make_node (REAL_TYPE);
4808 TYPE_PRECISION (float_type_node) = FLOAT_TYPE_SIZE;
4809 layout_type (float_type_node);
4811 double_type_node = make_node (REAL_TYPE);
4813 TYPE_PRECISION (double_type_node) = FLOAT_TYPE_SIZE;
4815 TYPE_PRECISION (double_type_node) = DOUBLE_TYPE_SIZE;
4816 layout_type (double_type_node);
4818 long_double_type_node = make_node (REAL_TYPE);
4819 TYPE_PRECISION (long_double_type_node) = LONG_DOUBLE_TYPE_SIZE;
4820 layout_type (long_double_type_node);
4822 complex_integer_type_node = make_node (COMPLEX_TYPE);
4823 TREE_TYPE (complex_integer_type_node) = integer_type_node;
4824 layout_type (complex_integer_type_node);
4826 complex_float_type_node = make_node (COMPLEX_TYPE);
4827 TREE_TYPE (complex_float_type_node) = float_type_node;
4828 layout_type (complex_float_type_node);
4830 complex_double_type_node = make_node (COMPLEX_TYPE);
4831 TREE_TYPE (complex_double_type_node) = double_type_node;
4832 layout_type (complex_double_type_node);
4834 complex_long_double_type_node = make_node (COMPLEX_TYPE);
4835 TREE_TYPE (complex_long_double_type_node) = long_double_type_node;
4836 layout_type (complex_long_double_type_node);
4840 BUILD_VA_LIST_TYPE (t);
4842 /* Many back-ends define record types without seting TYPE_NAME.
4843 If we copied the record type here, we'd keep the original
4844 record type without a name. This breaks name mangling. So,
4845 don't copy record types and let c_common_nodes_and_builtins()
4846 declare the type to be __builtin_va_list. */
4847 if (TREE_CODE (t) != RECORD_TYPE)
4848 t = build_type_copy (t);
4850 va_list_type_node = t;
4853 V4SF_type_node = make_node (VECTOR_TYPE);
4854 TREE_TYPE (V4SF_type_node) = float_type_node;
4855 TYPE_MODE (V4SF_type_node) = V4SFmode;
4856 finish_vector_type (V4SF_type_node);
4858 V4SI_type_node = make_node (VECTOR_TYPE);
4859 TREE_TYPE (V4SI_type_node) = intSI_type_node;
4860 TYPE_MODE (V4SI_type_node) = V4SImode;
4861 finish_vector_type (V4SI_type_node);
4863 V2SI_type_node = make_node (VECTOR_TYPE);
4864 TREE_TYPE (V2SI_type_node) = intSI_type_node;
4865 TYPE_MODE (V2SI_type_node) = V2SImode;
4866 finish_vector_type (V2SI_type_node);
4868 V4HI_type_node = make_node (VECTOR_TYPE);
4869 TREE_TYPE (V4HI_type_node) = intHI_type_node;
4870 TYPE_MODE (V4HI_type_node) = V4HImode;
4871 finish_vector_type (V4HI_type_node);
4873 V8QI_type_node = make_node (VECTOR_TYPE);
4874 TREE_TYPE (V8QI_type_node) = intQI_type_node;
4875 TYPE_MODE (V8QI_type_node) = V8QImode;
4876 finish_vector_type (V8QI_type_node);
4878 V2SF_type_node = make_node (VECTOR_TYPE);
4879 TREE_TYPE (V2SF_type_node) = float_type_node;
4880 TYPE_MODE (V2SF_type_node) = V2SFmode;
4881 finish_vector_type (V2SF_type_node);