1 /* Language-independent node constructors for parse phase of GNU compiler.
2 Copyright (C) 1987, 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000, 2001, 2002 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. */
48 #include "langhooks.h"
50 #define obstack_chunk_alloc xmalloc
51 #define obstack_chunk_free free
52 /* obstack.[ch] explicitly declined to prototype this. */
53 extern int _obstack_allocated_p PARAMS ((struct obstack *h, PTR obj));
55 /* Objects allocated on this obstack last forever. */
57 struct obstack permanent_obstack;
59 /* Table indexed by tree code giving a string containing a character
60 classifying the tree code. Possibilities are
61 t, d, s, c, r, <, 1, 2 and e. See tree.def for details. */
63 #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) TYPE,
65 char tree_code_type[MAX_TREE_CODES] = {
70 /* Table indexed by tree code giving number of expression
71 operands beyond the fixed part of the node structure.
72 Not used for types or decls. */
74 #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) LENGTH,
76 int tree_code_length[MAX_TREE_CODES] = {
81 /* Names of tree components.
82 Used for printing out the tree and error messages. */
83 #define DEFTREECODE(SYM, NAME, TYPE, LEN) NAME,
85 const char *tree_code_name[MAX_TREE_CODES] = {
90 /* Statistics-gathering stuff. */
110 int tree_node_counts[(int) all_kinds];
111 int tree_node_sizes[(int) all_kinds];
113 static const char * const tree_node_kind_names[] = {
130 /* Unique id for next decl created. */
131 static int next_decl_uid;
132 /* Unique id for next type created. */
133 static int next_type_uid = 1;
135 /* Since we cannot rehash a type after it is in the table, we have to
136 keep the hash code. */
144 /* Initial size of the hash table (rounded to next prime). */
145 #define TYPE_HASH_INITIAL_SIZE 1000
147 /* Now here is the hash table. When recording a type, it is added to
148 the slot whose index is the hash code. Note that the hash table is
149 used for several kinds of types (function types, array types and
150 array index range types, for now). While all these live in the
151 same table, they are completely independent, and the hash code is
152 computed differently for each of these. */
154 htab_t type_hash_table;
156 static void build_real_from_int_cst_1 PARAMS ((PTR));
157 static void set_type_quals PARAMS ((tree, int));
158 static void append_random_chars PARAMS ((char *));
159 static int type_hash_eq PARAMS ((const void*, const void*));
160 static unsigned int type_hash_hash PARAMS ((const void*));
161 static void print_type_hash_statistics PARAMS((void));
162 static void finish_vector_type PARAMS((tree));
163 static tree make_vector PARAMS ((enum machine_mode, tree, int));
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 unsafe_for_reeval. Return negative to not handle some tree. */
170 int (*lang_unsafe_for_reeval) PARAMS ((tree));
172 /* Set the DECL_ASSEMBLER_NAME for a node. If it is the sort of thing
173 that the assembler should talk about, set DECL_ASSEMBLER_NAME to an
174 appropriate IDENTIFIER_NODE. Otherwise, set it to the
175 ERROR_MARK_NODE to ensure that the assembler does not talk about
177 void (*lang_set_decl_assembler_name) PARAMS ((tree));
179 tree global_trees[TI_MAX];
180 tree integer_types[itk_none];
182 /* Set the DECL_ASSEMBLER_NAME for DECL. */
184 set_decl_assembler_name (decl)
187 /* The language-independent code should never use the
188 DECL_ASSEMBLER_NAME for lots of DECLs. Only FUNCTION_DECLs and
189 VAR_DECLs for variables with static storage duration need a real
190 DECL_ASSEMBLER_NAME. */
191 if (TREE_CODE (decl) == FUNCTION_DECL
192 || (TREE_CODE (decl) == VAR_DECL
193 && (TREE_STATIC (decl)
194 || DECL_EXTERNAL (decl)
195 || TREE_PUBLIC (decl))))
196 /* By default, assume the name to use in assembly code is the
197 same as that used in the source language. (That's correct
198 for C, and GCC used to set DECL_ASSEMBLER_NAME to the same
199 value as DECL_NAME in build_decl, so this choice provides
200 backwards compatibility with existing front-ends. */
201 SET_DECL_ASSEMBLER_NAME (decl, DECL_NAME (decl));
203 /* Nobody should ever be asking for the DECL_ASSEMBLER_NAME of
204 these DECLs -- unless they're in language-dependent code, in
205 which case lang_set_decl_assembler_name should handle things. */
209 /* Init the principal obstacks. */
214 gcc_obstack_init (&permanent_obstack);
216 /* Initialize the hash table of types. */
217 type_hash_table = htab_create (TYPE_HASH_INITIAL_SIZE, type_hash_hash,
219 ggc_add_deletable_htab (type_hash_table, type_hash_marked_p,
221 ggc_add_tree_root (global_trees, TI_MAX);
222 ggc_add_tree_root (integer_types, itk_none);
224 /* Set lang_set_decl_set_assembler_name to a default value. */
225 lang_set_decl_assembler_name = set_decl_assembler_name;
229 /* Allocate SIZE bytes in the permanent obstack
230 and return a pointer to them. */
236 return (char *) obstack_alloc (&permanent_obstack, size);
239 /* Allocate NELEM items of SIZE bytes in the permanent obstack
240 and return a pointer to them. The storage is cleared before
241 returning the value. */
244 perm_calloc (nelem, size)
248 char *rval = (char *) obstack_alloc (&permanent_obstack, nelem * size);
249 memset (rval, 0, nelem * size);
253 /* Compute the number of bytes occupied by 'node'. This routine only
254 looks at TREE_CODE and, if the code is TREE_VEC, TREE_VEC_LENGTH. */
259 enum tree_code code = TREE_CODE (node);
261 switch (TREE_CODE_CLASS (code))
263 case 'd': /* A decl node */
264 return sizeof (struct tree_decl);
266 case 't': /* a type node */
267 return sizeof (struct tree_type);
269 case 'b': /* a lexical block node */
270 return sizeof (struct tree_block);
272 case 'r': /* a reference */
273 case 'e': /* an expression */
274 case 's': /* an expression with side effects */
275 case '<': /* a comparison expression */
276 case '1': /* a unary arithmetic expression */
277 case '2': /* a binary arithmetic expression */
278 return (sizeof (struct tree_exp)
279 + (TREE_CODE_LENGTH (code) - 1) * sizeof (char *));
281 case 'c': /* a constant */
282 /* We can't use TREE_CODE_LENGTH for INTEGER_CST, since the number of
283 words is machine-dependent due to varying length of HOST_WIDE_INT,
284 which might be wider than a pointer (e.g., long long). Similarly
285 for REAL_CST, since the number of words is machine-dependent due
286 to varying size and alignment of `double'. */
287 if (code == INTEGER_CST)
288 return sizeof (struct tree_int_cst);
289 else if (code == REAL_CST)
290 return sizeof (struct tree_real_cst);
292 return (sizeof (struct tree_common)
293 + TREE_CODE_LENGTH (code) * sizeof (char *));
295 case 'x': /* something random, like an identifier. */
298 length = (sizeof (struct tree_common)
299 + TREE_CODE_LENGTH (code) * sizeof (char *));
300 if (code == TREE_VEC)
301 length += (TREE_VEC_LENGTH (node) - 1) * sizeof (char *);
310 /* Return a newly allocated node of code CODE.
311 For decl and type nodes, some other fields are initialized.
312 The rest of the node is initialized to zero.
314 Achoo! I got a code in the node. */
321 int type = TREE_CODE_CLASS (code);
323 #ifdef GATHER_STATISTICS
326 struct tree_common ttmp;
328 /* We can't allocate a TREE_VEC without knowing how many elements
330 if (code == TREE_VEC)
333 TREE_SET_CODE ((tree)&ttmp, code);
334 length = tree_size ((tree)&ttmp);
336 #ifdef GATHER_STATISTICS
339 case 'd': /* A decl node */
343 case 't': /* a type node */
347 case 'b': /* a lexical block */
351 case 's': /* an expression with side effects */
355 case 'r': /* a reference */
359 case 'e': /* an expression */
360 case '<': /* a comparison expression */
361 case '1': /* a unary arithmetic expression */
362 case '2': /* a binary arithmetic expression */
366 case 'c': /* a constant */
370 case 'x': /* something random, like an identifier. */
371 if (code == IDENTIFIER_NODE)
373 else if (code == TREE_VEC)
383 tree_node_counts[(int) kind]++;
384 tree_node_sizes[(int) kind] += length;
387 t = ggc_alloc_tree (length);
389 memset ((PTR) t, 0, length);
391 TREE_SET_CODE (t, code);
396 TREE_SIDE_EFFECTS (t) = 1;
397 TREE_TYPE (t) = void_type_node;
401 if (code != FUNCTION_DECL)
403 DECL_USER_ALIGN (t) = 0;
404 DECL_IN_SYSTEM_HEADER (t) = in_system_header;
405 DECL_SOURCE_LINE (t) = lineno;
406 DECL_SOURCE_FILE (t) =
407 (input_filename) ? input_filename : "<built-in>";
408 DECL_UID (t) = next_decl_uid++;
410 /* We have not yet computed the alias set for this declaration. */
411 DECL_POINTER_ALIAS_SET (t) = -1;
415 TYPE_UID (t) = next_type_uid++;
416 TYPE_ALIGN (t) = char_type_node ? TYPE_ALIGN (char_type_node) : 0;
417 TYPE_USER_ALIGN (t) = 0;
418 TYPE_MAIN_VARIANT (t) = t;
420 /* Default to no attributes for type, but let target change that. */
421 TYPE_ATTRIBUTES (t) = NULL_TREE;
422 (*targetm.set_default_type_attributes) (t);
424 /* We have not yet computed the alias set for this type. */
425 TYPE_ALIAS_SET (t) = -1;
429 TREE_CONSTANT (t) = 1;
439 case PREDECREMENT_EXPR:
440 case PREINCREMENT_EXPR:
441 case POSTDECREMENT_EXPR:
442 case POSTINCREMENT_EXPR:
443 /* All of these have side-effects, no matter what their
445 TREE_SIDE_EFFECTS (t) = 1;
457 /* A front-end can reset this to an appropriate function if types need
460 tree (*make_lang_type_fn) PARAMS ((enum tree_code)) = make_node;
462 /* Return a new type (with the indicated CODE), doing whatever
463 language-specific processing is required. */
466 make_lang_type (code)
469 return (*make_lang_type_fn) (code);
472 /* Return a new node with the same contents as NODE except that its
473 TREE_CHAIN is zero and it has a fresh uid. */
480 enum tree_code code = TREE_CODE (node);
483 length = tree_size (node);
484 t = ggc_alloc_tree (length);
485 memcpy (t, node, length);
488 TREE_ASM_WRITTEN (t) = 0;
490 if (TREE_CODE_CLASS (code) == 'd')
491 DECL_UID (t) = next_decl_uid++;
492 else if (TREE_CODE_CLASS (code) == 't')
494 TYPE_UID (t) = next_type_uid++;
495 /* The following is so that the debug code for
496 the copy is different from the original type.
497 The two statements usually duplicate each other
498 (because they clear fields of the same union),
499 but the optimizer should catch that. */
500 TYPE_SYMTAB_POINTER (t) = 0;
501 TYPE_SYMTAB_ADDRESS (t) = 0;
507 /* Return a copy of a chain of nodes, chained through the TREE_CHAIN field.
508 For example, this can copy a list made of TREE_LIST nodes. */
520 head = prev = copy_node (list);
521 next = TREE_CHAIN (list);
524 TREE_CHAIN (prev) = copy_node (next);
525 prev = TREE_CHAIN (prev);
526 next = TREE_CHAIN (next);
532 /* Return a newly constructed INTEGER_CST node whose constant value
533 is specified by the two ints LOW and HI.
534 The TREE_TYPE is set to `int'.
536 This function should be used via the `build_int_2' macro. */
539 build_int_2_wide (low, hi)
540 unsigned HOST_WIDE_INT low;
543 tree t = make_node (INTEGER_CST);
545 TREE_INT_CST_LOW (t) = low;
546 TREE_INT_CST_HIGH (t) = hi;
547 TREE_TYPE (t) = integer_type_node;
551 /* Return a new VECTOR_CST node whose type is TYPE and whose values
552 are in a list pointed by VALS. */
555 build_vector (type, vals)
558 tree v = make_node (VECTOR_CST);
559 int over1 = 0, over2 = 0;
562 TREE_VECTOR_CST_ELTS (v) = vals;
563 TREE_TYPE (v) = type;
565 /* Iterate through elements and check for overflow. */
566 for (link = vals; link; link = TREE_CHAIN (link))
568 tree value = TREE_VALUE (link);
570 over1 |= TREE_OVERFLOW (value);
571 over2 |= TREE_CONSTANT_OVERFLOW (value);
574 TREE_OVERFLOW (v) = over1;
575 TREE_CONSTANT_OVERFLOW (v) = over2;
580 /* Return a new REAL_CST node whose type is TYPE and value is D. */
590 /* Check for valid float value for this type on this target machine;
591 if not, can print error message and store a valid value in D. */
592 #ifdef CHECK_FLOAT_VALUE
593 CHECK_FLOAT_VALUE (TYPE_MODE (type), d, overflow);
596 v = make_node (REAL_CST);
597 TREE_TYPE (v) = type;
598 TREE_REAL_CST (v) = d;
599 TREE_OVERFLOW (v) = TREE_CONSTANT_OVERFLOW (v) = overflow;
603 /* Return a new REAL_CST node whose type is TYPE
604 and whose value is the integer value of the INTEGER_CST node I. */
607 real_value_from_int_cst (type, i)
608 tree type ATTRIBUTE_UNUSED, i;
612 /* Clear all bits of the real value type so that we can later do
613 bitwise comparisons to see if two values are the same. */
614 memset ((char *) &d, 0, sizeof d);
616 if (! TREE_UNSIGNED (TREE_TYPE (i)))
617 REAL_VALUE_FROM_INT (d, TREE_INT_CST_LOW (i), TREE_INT_CST_HIGH (i),
620 REAL_VALUE_FROM_UNSIGNED_INT (d, TREE_INT_CST_LOW (i),
621 TREE_INT_CST_HIGH (i), TYPE_MODE (type));
625 /* Args to pass to and from build_real_from_int_cst_1. */
629 tree type; /* Input: type to conver to. */
630 tree i; /* Input: operand to convert. */
631 REAL_VALUE_TYPE d; /* Output: floating point value. */
634 /* Convert an integer to a floating point value while protected by a floating
635 point exception handler. */
638 build_real_from_int_cst_1 (data)
641 struct brfic_args *args = (struct brfic_args *) data;
643 args->d = real_value_from_int_cst (args->type, args->i);
646 /* Given a tree representing an integer constant I, return a tree
647 representing the same value as a floating-point constant of type TYPE.
648 We cannot perform this operation if there is no way of doing arithmetic
649 on floating-point values. */
652 build_real_from_int_cst (type, i)
657 int overflow = TREE_OVERFLOW (i);
659 struct brfic_args args;
661 v = make_node (REAL_CST);
662 TREE_TYPE (v) = type;
664 /* Setup input for build_real_from_int_cst_1() */
668 if (do_float_handler (build_real_from_int_cst_1, (PTR) &args))
669 /* Receive output from build_real_from_int_cst_1() */
673 /* We got an exception from build_real_from_int_cst_1() */
678 /* Check for valid float value for this type on this target machine. */
680 #ifdef CHECK_FLOAT_VALUE
681 CHECK_FLOAT_VALUE (TYPE_MODE (type), d, overflow);
684 TREE_REAL_CST (v) = d;
685 TREE_OVERFLOW (v) = TREE_CONSTANT_OVERFLOW (v) = overflow;
689 /* Return a newly constructed STRING_CST node whose value is
690 the LEN characters at STR.
691 The TREE_TYPE is not initialized. */
694 build_string (len, str)
698 tree s = make_node (STRING_CST);
700 TREE_STRING_LENGTH (s) = len;
701 TREE_STRING_POINTER (s) = ggc_alloc_string (str, len);
706 /* Return a newly constructed COMPLEX_CST node whose value is
707 specified by the real and imaginary parts REAL and IMAG.
708 Both REAL and IMAG should be constant nodes. TYPE, if specified,
709 will be the type of the COMPLEX_CST; otherwise a new type will be made. */
712 build_complex (type, real, imag)
716 tree t = make_node (COMPLEX_CST);
718 TREE_REALPART (t) = real;
719 TREE_IMAGPART (t) = imag;
720 TREE_TYPE (t) = type ? type : build_complex_type (TREE_TYPE (real));
721 TREE_OVERFLOW (t) = TREE_OVERFLOW (real) | TREE_OVERFLOW (imag);
722 TREE_CONSTANT_OVERFLOW (t)
723 = TREE_CONSTANT_OVERFLOW (real) | TREE_CONSTANT_OVERFLOW (imag);
727 /* Build a newly constructed TREE_VEC node of length LEN. */
734 int length = (len-1) * sizeof (tree) + sizeof (struct tree_vec);
736 #ifdef GATHER_STATISTICS
737 tree_node_counts[(int)vec_kind]++;
738 tree_node_sizes[(int)vec_kind] += length;
741 t = ggc_alloc_tree (length);
743 memset ((PTR) t, 0, length);
744 TREE_SET_CODE (t, TREE_VEC);
745 TREE_VEC_LENGTH (t) = len;
750 /* Return 1 if EXPR is the integer constant zero or a complex constant
759 return ((TREE_CODE (expr) == INTEGER_CST
760 && ! TREE_CONSTANT_OVERFLOW (expr)
761 && TREE_INT_CST_LOW (expr) == 0
762 && TREE_INT_CST_HIGH (expr) == 0)
763 || (TREE_CODE (expr) == COMPLEX_CST
764 && integer_zerop (TREE_REALPART (expr))
765 && integer_zerop (TREE_IMAGPART (expr))));
768 /* Return 1 if EXPR is the integer constant one or the corresponding
777 return ((TREE_CODE (expr) == INTEGER_CST
778 && ! TREE_CONSTANT_OVERFLOW (expr)
779 && TREE_INT_CST_LOW (expr) == 1
780 && TREE_INT_CST_HIGH (expr) == 0)
781 || (TREE_CODE (expr) == COMPLEX_CST
782 && integer_onep (TREE_REALPART (expr))
783 && integer_zerop (TREE_IMAGPART (expr))));
786 /* Return 1 if EXPR is an integer containing all 1's in as much precision as
787 it contains. Likewise for the corresponding complex constant. */
790 integer_all_onesp (expr)
798 if (TREE_CODE (expr) == COMPLEX_CST
799 && integer_all_onesp (TREE_REALPART (expr))
800 && integer_zerop (TREE_IMAGPART (expr)))
803 else if (TREE_CODE (expr) != INTEGER_CST
804 || TREE_CONSTANT_OVERFLOW (expr))
807 uns = TREE_UNSIGNED (TREE_TYPE (expr));
809 return (TREE_INT_CST_LOW (expr) == ~(unsigned HOST_WIDE_INT) 0
810 && TREE_INT_CST_HIGH (expr) == -1);
812 /* Note that using TYPE_PRECISION here is wrong. We care about the
813 actual bits, not the (arbitrary) range of the type. */
814 prec = GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (expr)));
815 if (prec >= HOST_BITS_PER_WIDE_INT)
817 HOST_WIDE_INT high_value;
820 shift_amount = prec - HOST_BITS_PER_WIDE_INT;
822 if (shift_amount > HOST_BITS_PER_WIDE_INT)
823 /* Can not handle precisions greater than twice the host int size. */
825 else if (shift_amount == HOST_BITS_PER_WIDE_INT)
826 /* Shifting by the host word size is undefined according to the ANSI
827 standard, so we must handle this as a special case. */
830 high_value = ((HOST_WIDE_INT) 1 << shift_amount) - 1;
832 return (TREE_INT_CST_LOW (expr) == ~(unsigned HOST_WIDE_INT) 0
833 && TREE_INT_CST_HIGH (expr) == high_value);
836 return TREE_INT_CST_LOW (expr) == ((unsigned HOST_WIDE_INT) 1 << prec) - 1;
839 /* Return 1 if EXPR is an integer constant that is a power of 2 (i.e., has only
847 HOST_WIDE_INT high, low;
851 if (TREE_CODE (expr) == COMPLEX_CST
852 && integer_pow2p (TREE_REALPART (expr))
853 && integer_zerop (TREE_IMAGPART (expr)))
856 if (TREE_CODE (expr) != INTEGER_CST || TREE_CONSTANT_OVERFLOW (expr))
859 prec = (POINTER_TYPE_P (TREE_TYPE (expr))
860 ? POINTER_SIZE : TYPE_PRECISION (TREE_TYPE (expr)));
861 high = TREE_INT_CST_HIGH (expr);
862 low = TREE_INT_CST_LOW (expr);
864 /* First clear all bits that are beyond the type's precision in case
865 we've been sign extended. */
867 if (prec == 2 * HOST_BITS_PER_WIDE_INT)
869 else if (prec > HOST_BITS_PER_WIDE_INT)
870 high &= ~((HOST_WIDE_INT) (-1) << (prec - HOST_BITS_PER_WIDE_INT));
874 if (prec < HOST_BITS_PER_WIDE_INT)
875 low &= ~((HOST_WIDE_INT) (-1) << prec);
878 if (high == 0 && low == 0)
881 return ((high == 0 && (low & (low - 1)) == 0)
882 || (low == 0 && (high & (high - 1)) == 0));
885 /* Return the power of two represented by a tree node known to be a
893 HOST_WIDE_INT high, low;
897 if (TREE_CODE (expr) == COMPLEX_CST)
898 return tree_log2 (TREE_REALPART (expr));
900 prec = (POINTER_TYPE_P (TREE_TYPE (expr))
901 ? POINTER_SIZE : TYPE_PRECISION (TREE_TYPE (expr)));
903 high = TREE_INT_CST_HIGH (expr);
904 low = TREE_INT_CST_LOW (expr);
906 /* First clear all bits that are beyond the type's precision in case
907 we've been sign extended. */
909 if (prec == 2 * HOST_BITS_PER_WIDE_INT)
911 else if (prec > HOST_BITS_PER_WIDE_INT)
912 high &= ~((HOST_WIDE_INT) (-1) << (prec - HOST_BITS_PER_WIDE_INT));
916 if (prec < HOST_BITS_PER_WIDE_INT)
917 low &= ~((HOST_WIDE_INT) (-1) << prec);
920 return (high != 0 ? HOST_BITS_PER_WIDE_INT + exact_log2 (high)
924 /* Similar, but return the largest integer Y such that 2 ** Y is less
925 than or equal to EXPR. */
928 tree_floor_log2 (expr)
932 HOST_WIDE_INT high, low;
936 if (TREE_CODE (expr) == COMPLEX_CST)
937 return tree_log2 (TREE_REALPART (expr));
939 prec = (POINTER_TYPE_P (TREE_TYPE (expr))
940 ? POINTER_SIZE : TYPE_PRECISION (TREE_TYPE (expr)));
942 high = TREE_INT_CST_HIGH (expr);
943 low = TREE_INT_CST_LOW (expr);
945 /* First clear all bits that are beyond the type's precision in case
946 we've been sign extended. Ignore if type's precision hasn't been set
947 since what we are doing is setting it. */
949 if (prec == 2 * HOST_BITS_PER_WIDE_INT || prec == 0)
951 else if (prec > HOST_BITS_PER_WIDE_INT)
952 high &= ~((HOST_WIDE_INT) (-1) << (prec - HOST_BITS_PER_WIDE_INT));
956 if (prec < HOST_BITS_PER_WIDE_INT)
957 low &= ~((HOST_WIDE_INT) (-1) << prec);
960 return (high != 0 ? HOST_BITS_PER_WIDE_INT + floor_log2 (high)
964 /* Return 1 if EXPR is the real constant zero. */
972 return ((TREE_CODE (expr) == REAL_CST
973 && ! TREE_CONSTANT_OVERFLOW (expr)
974 && REAL_VALUES_EQUAL (TREE_REAL_CST (expr), dconst0))
975 || (TREE_CODE (expr) == COMPLEX_CST
976 && real_zerop (TREE_REALPART (expr))
977 && real_zerop (TREE_IMAGPART (expr))));
980 /* Return 1 if EXPR is the real constant one in real or complex form. */
988 return ((TREE_CODE (expr) == REAL_CST
989 && ! TREE_CONSTANT_OVERFLOW (expr)
990 && REAL_VALUES_EQUAL (TREE_REAL_CST (expr), dconst1))
991 || (TREE_CODE (expr) == COMPLEX_CST
992 && real_onep (TREE_REALPART (expr))
993 && real_zerop (TREE_IMAGPART (expr))));
996 /* Return 1 if EXPR is the real constant two. */
1004 return ((TREE_CODE (expr) == REAL_CST
1005 && ! TREE_CONSTANT_OVERFLOW (expr)
1006 && REAL_VALUES_EQUAL (TREE_REAL_CST (expr), dconst2))
1007 || (TREE_CODE (expr) == COMPLEX_CST
1008 && real_twop (TREE_REALPART (expr))
1009 && real_zerop (TREE_IMAGPART (expr))));
1012 /* Nonzero if EXP is a constant or a cast of a constant. */
1015 really_constant_p (exp)
1018 /* This is not quite the same as STRIP_NOPS. It does more. */
1019 while (TREE_CODE (exp) == NOP_EXPR
1020 || TREE_CODE (exp) == CONVERT_EXPR
1021 || TREE_CODE (exp) == NON_LVALUE_EXPR)
1022 exp = TREE_OPERAND (exp, 0);
1023 return TREE_CONSTANT (exp);
1026 /* Return first list element whose TREE_VALUE is ELEM.
1027 Return 0 if ELEM is not in LIST. */
1030 value_member (elem, list)
1035 if (elem == TREE_VALUE (list))
1037 list = TREE_CHAIN (list);
1042 /* Return first list element whose TREE_PURPOSE is ELEM.
1043 Return 0 if ELEM is not in LIST. */
1046 purpose_member (elem, list)
1051 if (elem == TREE_PURPOSE (list))
1053 list = TREE_CHAIN (list);
1058 /* Return first list element whose BINFO_TYPE is ELEM.
1059 Return 0 if ELEM is not in LIST. */
1062 binfo_member (elem, list)
1067 if (elem == BINFO_TYPE (list))
1069 list = TREE_CHAIN (list);
1074 /* Return nonzero if ELEM is part of the chain CHAIN. */
1077 chain_member (elem, chain)
1084 chain = TREE_CHAIN (chain);
1090 /* Return nonzero if ELEM is equal to TREE_VALUE (CHAIN) for any piece of
1091 chain CHAIN. This and the next function are currently unused, but
1092 are retained for completeness. */
1095 chain_member_value (elem, chain)
1100 if (elem == TREE_VALUE (chain))
1102 chain = TREE_CHAIN (chain);
1108 /* Return nonzero if ELEM is equal to TREE_PURPOSE (CHAIN)
1109 for any piece of chain CHAIN. */
1112 chain_member_purpose (elem, chain)
1117 if (elem == TREE_PURPOSE (chain))
1119 chain = TREE_CHAIN (chain);
1125 /* Return the length of a chain of nodes chained through TREE_CHAIN.
1126 We expect a null pointer to mark the end of the chain.
1127 This is the Lisp primitive `length'. */
1136 for (tail = t; tail; tail = TREE_CHAIN (tail))
1142 /* Returns the number of FIELD_DECLs in TYPE. */
1145 fields_length (type)
1148 tree t = TYPE_FIELDS (type);
1151 for (; t; t = TREE_CHAIN (t))
1152 if (TREE_CODE (t) == FIELD_DECL)
1158 /* Concatenate two chains of nodes (chained through TREE_CHAIN)
1159 by modifying the last node in chain 1 to point to chain 2.
1160 This is the Lisp primitive `nconc'. */
1170 #ifdef ENABLE_TREE_CHECKING
1174 for (t1 = op1; TREE_CHAIN (t1); t1 = TREE_CHAIN (t1))
1176 TREE_CHAIN (t1) = op2;
1177 #ifdef ENABLE_TREE_CHECKING
1178 for (t2 = op2; t2; t2 = TREE_CHAIN (t2))
1180 abort (); /* Circularity created. */
1188 /* Return the last node in a chain of nodes (chained through TREE_CHAIN). */
1196 while ((next = TREE_CHAIN (chain)))
1201 /* Reverse the order of elements in the chain T,
1202 and return the new head of the chain (old last element). */
1208 tree prev = 0, decl, next;
1209 for (decl = t; decl; decl = next)
1211 next = TREE_CHAIN (decl);
1212 TREE_CHAIN (decl) = prev;
1218 /* Given a chain CHAIN of tree nodes,
1219 construct and return a list of those nodes. */
1225 tree result = NULL_TREE;
1226 tree in_tail = chain;
1227 tree out_tail = NULL_TREE;
1231 tree next = tree_cons (NULL_TREE, in_tail, NULL_TREE);
1233 TREE_CHAIN (out_tail) = next;
1237 in_tail = TREE_CHAIN (in_tail);
1243 /* Return a newly created TREE_LIST node whose
1244 purpose and value fields are PARM and VALUE. */
1247 build_tree_list (parm, value)
1250 tree t = make_node (TREE_LIST);
1251 TREE_PURPOSE (t) = parm;
1252 TREE_VALUE (t) = value;
1256 /* Return a newly created TREE_LIST node whose
1257 purpose and value fields are PARM and VALUE
1258 and whose TREE_CHAIN is CHAIN. */
1261 tree_cons (purpose, value, chain)
1262 tree purpose, value, chain;
1266 node = ggc_alloc_tree (sizeof (struct tree_list));
1268 memset (node, 0, sizeof (struct tree_common));
1270 #ifdef GATHER_STATISTICS
1271 tree_node_counts[(int) x_kind]++;
1272 tree_node_sizes[(int) x_kind] += sizeof (struct tree_list);
1275 TREE_SET_CODE (node, TREE_LIST);
1276 TREE_CHAIN (node) = chain;
1277 TREE_PURPOSE (node) = purpose;
1278 TREE_VALUE (node) = value;
1283 /* Return the size nominally occupied by an object of type TYPE
1284 when it resides in memory. The value is measured in units of bytes,
1285 and its data type is that normally used for type sizes
1286 (which is the first type created by make_signed_type or
1287 make_unsigned_type). */
1290 size_in_bytes (type)
1295 if (type == error_mark_node)
1296 return integer_zero_node;
1298 type = TYPE_MAIN_VARIANT (type);
1299 t = TYPE_SIZE_UNIT (type);
1303 incomplete_type_error (NULL_TREE, type);
1304 return size_zero_node;
1307 if (TREE_CODE (t) == INTEGER_CST)
1308 force_fit_type (t, 0);
1313 /* Return the size of TYPE (in bytes) as a wide integer
1314 or return -1 if the size can vary or is larger than an integer. */
1317 int_size_in_bytes (type)
1322 if (type == error_mark_node)
1325 type = TYPE_MAIN_VARIANT (type);
1326 t = TYPE_SIZE_UNIT (type);
1328 || TREE_CODE (t) != INTEGER_CST
1329 || TREE_OVERFLOW (t)
1330 || TREE_INT_CST_HIGH (t) != 0
1331 /* If the result would appear negative, it's too big to represent. */
1332 || (HOST_WIDE_INT) TREE_INT_CST_LOW (t) < 0)
1335 return TREE_INT_CST_LOW (t);
1338 /* Return the bit position of FIELD, in bits from the start of the record.
1339 This is a tree of type bitsizetype. */
1342 bit_position (field)
1346 return bit_from_pos (DECL_FIELD_OFFSET (field),
1347 DECL_FIELD_BIT_OFFSET (field));
1350 /* Likewise, but return as an integer. Abort if it cannot be represented
1351 in that way (since it could be a signed value, we don't have the option
1352 of returning -1 like int_size_in_byte can. */
1355 int_bit_position (field)
1358 return tree_low_cst (bit_position (field), 0);
1361 /* Return the byte position of FIELD, in bytes from the start of the record.
1362 This is a tree of type sizetype. */
1365 byte_position (field)
1368 return byte_from_pos (DECL_FIELD_OFFSET (field),
1369 DECL_FIELD_BIT_OFFSET (field));
1372 /* Likewise, but return as an integer. Abort if it cannot be represented
1373 in that way (since it could be a signed value, we don't have the option
1374 of returning -1 like int_size_in_byte can. */
1377 int_byte_position (field)
1380 return tree_low_cst (byte_position (field), 0);
1383 /* Return the strictest alignment, in bits, that T is known to have. */
1389 unsigned int align0, align1;
1391 switch (TREE_CODE (t))
1393 case NOP_EXPR: case CONVERT_EXPR: case NON_LVALUE_EXPR:
1394 /* If we have conversions, we know that the alignment of the
1395 object must meet each of the alignments of the types. */
1396 align0 = expr_align (TREE_OPERAND (t, 0));
1397 align1 = TYPE_ALIGN (TREE_TYPE (t));
1398 return MAX (align0, align1);
1400 case SAVE_EXPR: case COMPOUND_EXPR: case MODIFY_EXPR:
1401 case INIT_EXPR: case TARGET_EXPR: case WITH_CLEANUP_EXPR:
1402 case WITH_RECORD_EXPR: case CLEANUP_POINT_EXPR: case UNSAVE_EXPR:
1403 /* These don't change the alignment of an object. */
1404 return expr_align (TREE_OPERAND (t, 0));
1407 /* The best we can do is say that the alignment is the least aligned
1409 align0 = expr_align (TREE_OPERAND (t, 1));
1410 align1 = expr_align (TREE_OPERAND (t, 2));
1411 return MIN (align0, align1);
1413 case LABEL_DECL: case CONST_DECL:
1414 case VAR_DECL: case PARM_DECL: case RESULT_DECL:
1415 if (DECL_ALIGN (t) != 0)
1416 return DECL_ALIGN (t);
1420 return FUNCTION_BOUNDARY;
1426 /* Otherwise take the alignment from that of the type. */
1427 return TYPE_ALIGN (TREE_TYPE (t));
1430 /* Return, as a tree node, the number of elements for TYPE (which is an
1431 ARRAY_TYPE) minus one. This counts only elements of the top array. */
1434 array_type_nelts (type)
1437 tree index_type, min, max;
1439 /* If they did it with unspecified bounds, then we should have already
1440 given an error about it before we got here. */
1441 if (! TYPE_DOMAIN (type))
1442 return error_mark_node;
1444 index_type = TYPE_DOMAIN (type);
1445 min = TYPE_MIN_VALUE (index_type);
1446 max = TYPE_MAX_VALUE (index_type);
1448 return (integer_zerop (min)
1450 : fold (build (MINUS_EXPR, TREE_TYPE (max), max, min)));
1453 /* Return nonzero if arg is static -- a reference to an object in
1454 static storage. This is not the same as the C meaning of `static'. */
1460 switch (TREE_CODE (arg))
1463 /* Nested functions aren't static, since taking their address
1464 involves a trampoline. */
1465 return (decl_function_context (arg) == 0 || DECL_NO_STATIC_CHAIN (arg))
1466 && ! DECL_NON_ADDR_CONST_P (arg);
1469 return (TREE_STATIC (arg) || DECL_EXTERNAL (arg))
1470 && ! DECL_NON_ADDR_CONST_P (arg);
1473 return TREE_STATIC (arg);
1479 /* If we are referencing a bitfield, we can't evaluate an
1480 ADDR_EXPR at compile time and so it isn't a constant. */
1482 return (! DECL_BIT_FIELD (TREE_OPERAND (arg, 1))
1483 && staticp (TREE_OPERAND (arg, 0)));
1489 /* This case is technically correct, but results in setting
1490 TREE_CONSTANT on ADDR_EXPRs that cannot be evaluated at
1493 return TREE_CONSTANT (TREE_OPERAND (arg, 0));
1497 case ARRAY_RANGE_REF:
1498 if (TREE_CODE (TYPE_SIZE (TREE_TYPE (arg))) == INTEGER_CST
1499 && TREE_CODE (TREE_OPERAND (arg, 1)) == INTEGER_CST)
1500 return staticp (TREE_OPERAND (arg, 0));
1503 if ((unsigned int) TREE_CODE (arg)
1504 >= (unsigned int) LAST_AND_UNUSED_TREE_CODE)
1505 return (*lang_hooks.staticp) (arg);
1511 /* Wrap a SAVE_EXPR around EXPR, if appropriate.
1512 Do this to any expression which may be used in more than one place,
1513 but must be evaluated only once.
1515 Normally, expand_expr would reevaluate the expression each time.
1516 Calling save_expr produces something that is evaluated and recorded
1517 the first time expand_expr is called on it. Subsequent calls to
1518 expand_expr just reuse the recorded value.
1520 The call to expand_expr that generates code that actually computes
1521 the value is the first call *at compile time*. Subsequent calls
1522 *at compile time* generate code to use the saved value.
1523 This produces correct result provided that *at run time* control
1524 always flows through the insns made by the first expand_expr
1525 before reaching the other places where the save_expr was evaluated.
1526 You, the caller of save_expr, must make sure this is so.
1528 Constants, and certain read-only nodes, are returned with no
1529 SAVE_EXPR because that is safe. Expressions containing placeholders
1530 are not touched; see tree.def for an explanation of what these
1537 tree t = fold (expr);
1540 /* We don't care about whether this can be used as an lvalue in this
1542 while (TREE_CODE (t) == NON_LVALUE_EXPR)
1543 t = TREE_OPERAND (t, 0);
1545 /* If we have simple operations applied to a SAVE_EXPR or to a SAVE_EXPR and
1546 a constant, it will be more efficient to not make another SAVE_EXPR since
1547 it will allow better simplification and GCSE will be able to merge the
1548 computations if they actualy occur. */
1550 (TREE_CODE_CLASS (TREE_CODE (inner)) == '1'
1551 || (TREE_CODE_CLASS (TREE_CODE (inner)) == '2'
1552 && TREE_CONSTANT (TREE_OPERAND (inner, 1))));
1553 inner = TREE_OPERAND (inner, 0))
1556 /* If the tree evaluates to a constant, then we don't want to hide that
1557 fact (i.e. this allows further folding, and direct checks for constants).
1558 However, a read-only object that has side effects cannot be bypassed.
1559 Since it is no problem to reevaluate literals, we just return the
1561 if (TREE_CONSTANT (inner)
1562 || (TREE_READONLY (inner) && ! TREE_SIDE_EFFECTS (inner))
1563 || TREE_CODE (inner) == SAVE_EXPR || TREE_CODE (inner) == ERROR_MARK)
1566 /* If T contains a PLACEHOLDER_EXPR, we must evaluate it each time, since
1567 it means that the size or offset of some field of an object depends on
1568 the value within another field.
1570 Note that it must not be the case that T contains both a PLACEHOLDER_EXPR
1571 and some variable since it would then need to be both evaluated once and
1572 evaluated more than once. Front-ends must assure this case cannot
1573 happen by surrounding any such subexpressions in their own SAVE_EXPR
1574 and forcing evaluation at the proper time. */
1575 if (contains_placeholder_p (t))
1578 t = build (SAVE_EXPR, TREE_TYPE (expr), t, current_function_decl, NULL_TREE);
1580 /* This expression might be placed ahead of a jump to ensure that the
1581 value was computed on both sides of the jump. So make sure it isn't
1582 eliminated as dead. */
1583 TREE_SIDE_EFFECTS (t) = 1;
1584 TREE_READONLY (t) = 1;
1588 /* Arrange for an expression to be expanded multiple independent
1589 times. This is useful for cleanup actions, as the backend can
1590 expand them multiple times in different places. */
1598 /* If this is already protected, no sense in protecting it again. */
1599 if (TREE_CODE (expr) == UNSAVE_EXPR)
1602 t = build1 (UNSAVE_EXPR, TREE_TYPE (expr), expr);
1603 TREE_SIDE_EFFECTS (t) = TREE_SIDE_EFFECTS (expr);
1607 /* Returns the index of the first non-tree operand for CODE, or the number
1608 of operands if all are trees. */
1612 enum tree_code code;
1618 case GOTO_SUBROUTINE_EXPR:
1621 case WITH_CLEANUP_EXPR:
1623 case METHOD_CALL_EXPR:
1626 return TREE_CODE_LENGTH (code);
1630 /* Perform any modifications to EXPR required when it is unsaved. Does
1631 not recurse into EXPR's subtrees. */
1634 unsave_expr_1 (expr)
1637 switch (TREE_CODE (expr))
1640 if (! SAVE_EXPR_PERSISTENT_P (expr))
1641 SAVE_EXPR_RTL (expr) = 0;
1645 /* Don't mess with a TARGET_EXPR that hasn't been expanded.
1646 It's OK for this to happen if it was part of a subtree that
1647 isn't immediately expanded, such as operand 2 of another
1649 if (TREE_OPERAND (expr, 1))
1652 TREE_OPERAND (expr, 1) = TREE_OPERAND (expr, 3);
1653 TREE_OPERAND (expr, 3) = NULL_TREE;
1657 /* I don't yet know how to emit a sequence multiple times. */
1658 if (RTL_EXPR_SEQUENCE (expr) != 0)
1667 /* Default lang hook for "unsave_expr_now". */
1670 lhd_unsave_expr_now (expr)
1673 enum tree_code code;
1675 /* There's nothing to do for NULL_TREE. */
1679 unsave_expr_1 (expr);
1681 code = TREE_CODE (expr);
1682 switch (TREE_CODE_CLASS (code))
1684 case 'c': /* a constant */
1685 case 't': /* a type node */
1686 case 'd': /* A decl node */
1687 case 'b': /* A block node */
1690 case 'x': /* miscellaneous: e.g., identifier, TREE_LIST or ERROR_MARK. */
1691 if (code == TREE_LIST)
1693 lhd_unsave_expr_now (TREE_VALUE (expr));
1694 lhd_unsave_expr_now (TREE_CHAIN (expr));
1698 case 'e': /* an expression */
1699 case 'r': /* a reference */
1700 case 's': /* an expression with side effects */
1701 case '<': /* a comparison expression */
1702 case '2': /* a binary arithmetic expression */
1703 case '1': /* a unary arithmetic expression */
1707 for (i = first_rtl_op (code) - 1; i >= 0; i--)
1708 lhd_unsave_expr_now (TREE_OPERAND (expr, i));
1719 /* Return 0 if it is safe to evaluate EXPR multiple times,
1720 return 1 if it is safe if EXPR is unsaved afterward, or
1721 return 2 if it is completely unsafe.
1723 This assumes that CALL_EXPRs and TARGET_EXPRs are never replicated in
1724 an expression tree, so that it safe to unsave them and the surrounding
1725 context will be correct.
1727 SAVE_EXPRs basically *only* appear replicated in an expression tree,
1728 occasionally across the whole of a function. It is therefore only
1729 safe to unsave a SAVE_EXPR if you know that all occurrences appear
1730 below the UNSAVE_EXPR.
1732 RTL_EXPRs consume their rtl during evaluation. It is therefore
1733 never possible to unsave them. */
1736 unsafe_for_reeval (expr)
1740 enum tree_code code;
1745 if (expr == NULL_TREE)
1748 code = TREE_CODE (expr);
1749 first_rtl = first_rtl_op (code);
1758 for (exp = expr; exp != 0; exp = TREE_CHAIN (exp))
1760 tmp = unsafe_for_reeval (TREE_VALUE (exp));
1761 unsafeness = MAX (tmp, unsafeness);
1767 tmp = unsafe_for_reeval (TREE_OPERAND (expr, 1));
1768 return MAX (tmp, 1);
1775 if (lang_unsafe_for_reeval != 0)
1777 tmp = (*lang_unsafe_for_reeval) (expr);
1784 switch (TREE_CODE_CLASS (code))
1786 case 'c': /* a constant */
1787 case 't': /* a type node */
1788 case 'x': /* something random, like an identifier or an ERROR_MARK. */
1789 case 'd': /* A decl node */
1790 case 'b': /* A block node */
1793 case 'e': /* an expression */
1794 case 'r': /* a reference */
1795 case 's': /* an expression with side effects */
1796 case '<': /* a comparison expression */
1797 case '2': /* a binary arithmetic expression */
1798 case '1': /* a unary arithmetic expression */
1799 for (i = first_rtl - 1; i >= 0; i--)
1801 tmp = unsafe_for_reeval (TREE_OPERAND (expr, i));
1802 unsafeness = MAX (tmp, unsafeness);
1812 /* Return 1 if EXP contains a PLACEHOLDER_EXPR; i.e., if it represents a size
1813 or offset that depends on a field within a record. */
1816 contains_placeholder_p (exp)
1819 enum tree_code code;
1825 /* If we have a WITH_RECORD_EXPR, it "cancels" any PLACEHOLDER_EXPR
1826 in it since it is supplying a value for it. */
1827 code = TREE_CODE (exp);
1828 if (code == WITH_RECORD_EXPR)
1830 else if (code == PLACEHOLDER_EXPR)
1833 switch (TREE_CODE_CLASS (code))
1836 /* Don't look at any PLACEHOLDER_EXPRs that might be in index or bit
1837 position computations since they will be converted into a
1838 WITH_RECORD_EXPR involving the reference, which will assume
1839 here will be valid. */
1840 return contains_placeholder_p (TREE_OPERAND (exp, 0));
1843 if (code == TREE_LIST)
1844 return (contains_placeholder_p (TREE_VALUE (exp))
1845 || (TREE_CHAIN (exp) != 0
1846 && contains_placeholder_p (TREE_CHAIN (exp))));
1855 /* Ignoring the first operand isn't quite right, but works best. */
1856 return contains_placeholder_p (TREE_OPERAND (exp, 1));
1863 return (contains_placeholder_p (TREE_OPERAND (exp, 0))
1864 || contains_placeholder_p (TREE_OPERAND (exp, 1))
1865 || contains_placeholder_p (TREE_OPERAND (exp, 2)));
1868 /* If we already know this doesn't have a placeholder, don't
1870 if (SAVE_EXPR_NOPLACEHOLDER (exp) || SAVE_EXPR_RTL (exp) != 0)
1873 SAVE_EXPR_NOPLACEHOLDER (exp) = 1;
1874 result = contains_placeholder_p (TREE_OPERAND (exp, 0));
1876 SAVE_EXPR_NOPLACEHOLDER (exp) = 0;
1881 return (TREE_OPERAND (exp, 1) != 0
1882 && contains_placeholder_p (TREE_OPERAND (exp, 1)));
1888 switch (TREE_CODE_LENGTH (code))
1891 return contains_placeholder_p (TREE_OPERAND (exp, 0));
1893 return (contains_placeholder_p (TREE_OPERAND (exp, 0))
1894 || contains_placeholder_p (TREE_OPERAND (exp, 1)));
1905 /* Return 1 if EXP contains any expressions that produce cleanups for an
1906 outer scope to deal with. Used by fold. */
1914 if (! TREE_SIDE_EFFECTS (exp))
1917 switch (TREE_CODE (exp))
1920 case GOTO_SUBROUTINE_EXPR:
1921 case WITH_CLEANUP_EXPR:
1924 case CLEANUP_POINT_EXPR:
1928 for (exp = TREE_OPERAND (exp, 1); exp; exp = TREE_CHAIN (exp))
1930 cmp = has_cleanups (TREE_VALUE (exp));
1940 /* This general rule works for most tree codes. All exceptions should be
1941 handled above. If this is a language-specific tree code, we can't
1942 trust what might be in the operand, so say we don't know
1944 if ((int) TREE_CODE (exp) >= (int) LAST_AND_UNUSED_TREE_CODE)
1947 nops = first_rtl_op (TREE_CODE (exp));
1948 for (i = 0; i < nops; i++)
1949 if (TREE_OPERAND (exp, i) != 0)
1951 int type = TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp, i)));
1952 if (type == 'e' || type == '<' || type == '1' || type == '2'
1953 || type == 'r' || type == 's')
1955 cmp = has_cleanups (TREE_OPERAND (exp, i));
1964 /* Given a tree EXP, a FIELD_DECL F, and a replacement value R,
1965 return a tree with all occurrences of references to F in a
1966 PLACEHOLDER_EXPR replaced by R. Note that we assume here that EXP
1967 contains only arithmetic expressions or a CALL_EXPR with a
1968 PLACEHOLDER_EXPR occurring only in its arglist. */
1971 substitute_in_expr (exp, f, r)
1976 enum tree_code code = TREE_CODE (exp);
1981 switch (TREE_CODE_CLASS (code))
1988 if (code == PLACEHOLDER_EXPR)
1990 else if (code == TREE_LIST)
1992 op0 = (TREE_CHAIN (exp) == 0
1993 ? 0 : substitute_in_expr (TREE_CHAIN (exp), f, r));
1994 op1 = substitute_in_expr (TREE_VALUE (exp), f, r);
1995 if (op0 == TREE_CHAIN (exp) && op1 == TREE_VALUE (exp))
1998 return tree_cons (TREE_PURPOSE (exp), op1, op0);
2007 switch (TREE_CODE_LENGTH (code))
2010 op0 = substitute_in_expr (TREE_OPERAND (exp, 0), f, r);
2011 if (op0 == TREE_OPERAND (exp, 0))
2014 if (code == NON_LVALUE_EXPR)
2017 new = fold (build1 (code, TREE_TYPE (exp), op0));
2021 /* An RTL_EXPR cannot contain a PLACEHOLDER_EXPR; a CONSTRUCTOR
2022 could, but we don't support it. */
2023 if (code == RTL_EXPR)
2025 else if (code == CONSTRUCTOR)
2028 op0 = substitute_in_expr (TREE_OPERAND (exp, 0), f, r);
2029 op1 = substitute_in_expr (TREE_OPERAND (exp, 1), f, r);
2030 if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1))
2033 new = fold (build (code, TREE_TYPE (exp), op0, op1));
2037 /* It cannot be that anything inside a SAVE_EXPR contains a
2038 PLACEHOLDER_EXPR. */
2039 if (code == SAVE_EXPR)
2042 else if (code == CALL_EXPR)
2044 op1 = substitute_in_expr (TREE_OPERAND (exp, 1), f, r);
2045 if (op1 == TREE_OPERAND (exp, 1))
2048 return build (code, TREE_TYPE (exp),
2049 TREE_OPERAND (exp, 0), op1, NULL_TREE);
2052 else if (code != COND_EXPR)
2055 op0 = substitute_in_expr (TREE_OPERAND (exp, 0), f, r);
2056 op1 = substitute_in_expr (TREE_OPERAND (exp, 1), f, r);
2057 op2 = substitute_in_expr (TREE_OPERAND (exp, 2), f, r);
2058 if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1)
2059 && op2 == TREE_OPERAND (exp, 2))
2062 new = fold (build (code, TREE_TYPE (exp), op0, op1, op2));
2075 /* If this expression is getting a value from a PLACEHOLDER_EXPR
2076 and it is the right field, replace it with R. */
2077 for (inner = TREE_OPERAND (exp, 0);
2078 TREE_CODE_CLASS (TREE_CODE (inner)) == 'r';
2079 inner = TREE_OPERAND (inner, 0))
2081 if (TREE_CODE (inner) == PLACEHOLDER_EXPR
2082 && TREE_OPERAND (exp, 1) == f)
2085 /* If this expression hasn't been completed let, leave it
2087 if (TREE_CODE (inner) == PLACEHOLDER_EXPR
2088 && TREE_TYPE (inner) == 0)
2091 op0 = substitute_in_expr (TREE_OPERAND (exp, 0), f, r);
2092 if (op0 == TREE_OPERAND (exp, 0))
2095 new = fold (build (code, TREE_TYPE (exp), op0,
2096 TREE_OPERAND (exp, 1)));
2100 op0 = substitute_in_expr (TREE_OPERAND (exp, 0), f, r);
2101 op1 = substitute_in_expr (TREE_OPERAND (exp, 1), f, r);
2102 op2 = substitute_in_expr (TREE_OPERAND (exp, 2), f, r);
2103 if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1)
2104 && op2 == TREE_OPERAND (exp, 2))
2107 new = fold (build (code, TREE_TYPE (exp), op0, op1, op2));
2112 op0 = substitute_in_expr (TREE_OPERAND (exp, 0), f, r);
2113 if (op0 == TREE_OPERAND (exp, 0))
2116 new = fold (build1 (code, TREE_TYPE (exp), op0));
2128 TREE_READONLY (new) = TREE_READONLY (exp);
2132 /* Stabilize a reference so that we can use it any number of times
2133 without causing its operands to be evaluated more than once.
2134 Returns the stabilized reference. This works by means of save_expr,
2135 so see the caveats in the comments about save_expr.
2137 Also allows conversion expressions whose operands are references.
2138 Any other kind of expression is returned unchanged. */
2141 stabilize_reference (ref)
2145 enum tree_code code = TREE_CODE (ref);
2152 /* No action is needed in this case. */
2158 case FIX_TRUNC_EXPR:
2159 case FIX_FLOOR_EXPR:
2160 case FIX_ROUND_EXPR:
2162 result = build_nt (code, stabilize_reference (TREE_OPERAND (ref, 0)));
2166 result = build_nt (INDIRECT_REF,
2167 stabilize_reference_1 (TREE_OPERAND (ref, 0)));
2171 result = build_nt (COMPONENT_REF,
2172 stabilize_reference (TREE_OPERAND (ref, 0)),
2173 TREE_OPERAND (ref, 1));
2177 result = build_nt (BIT_FIELD_REF,
2178 stabilize_reference (TREE_OPERAND (ref, 0)),
2179 stabilize_reference_1 (TREE_OPERAND (ref, 1)),
2180 stabilize_reference_1 (TREE_OPERAND (ref, 2)));
2184 result = build_nt (ARRAY_REF,
2185 stabilize_reference (TREE_OPERAND (ref, 0)),
2186 stabilize_reference_1 (TREE_OPERAND (ref, 1)));
2189 case ARRAY_RANGE_REF:
2190 result = build_nt (ARRAY_RANGE_REF,
2191 stabilize_reference (TREE_OPERAND (ref, 0)),
2192 stabilize_reference_1 (TREE_OPERAND (ref, 1)));
2196 /* We cannot wrap the first expression in a SAVE_EXPR, as then
2197 it wouldn't be ignored. This matters when dealing with
2199 return stabilize_reference_1 (ref);
2202 result = build1 (INDIRECT_REF, TREE_TYPE (ref),
2203 save_expr (build1 (ADDR_EXPR,
2204 build_pointer_type (TREE_TYPE (ref)),
2208 /* If arg isn't a kind of lvalue we recognize, make no change.
2209 Caller should recognize the error for an invalid lvalue. */
2214 return error_mark_node;
2217 TREE_TYPE (result) = TREE_TYPE (ref);
2218 TREE_READONLY (result) = TREE_READONLY (ref);
2219 TREE_SIDE_EFFECTS (result) = TREE_SIDE_EFFECTS (ref);
2220 TREE_THIS_VOLATILE (result) = TREE_THIS_VOLATILE (ref);
2225 /* Subroutine of stabilize_reference; this is called for subtrees of
2226 references. Any expression with side-effects must be put in a SAVE_EXPR
2227 to ensure that it is only evaluated once.
2229 We don't put SAVE_EXPR nodes around everything, because assigning very
2230 simple expressions to temporaries causes us to miss good opportunities
2231 for optimizations. Among other things, the opportunity to fold in the
2232 addition of a constant into an addressing mode often gets lost, e.g.
2233 "y[i+1] += x;". In general, we take the approach that we should not make
2234 an assignment unless we are forced into it - i.e., that any non-side effect
2235 operator should be allowed, and that cse should take care of coalescing
2236 multiple utterances of the same expression should that prove fruitful. */
2239 stabilize_reference_1 (e)
2243 enum tree_code code = TREE_CODE (e);
2245 /* We cannot ignore const expressions because it might be a reference
2246 to a const array but whose index contains side-effects. But we can
2247 ignore things that are actual constant or that already have been
2248 handled by this function. */
2250 if (TREE_CONSTANT (e) || code == SAVE_EXPR)
2253 switch (TREE_CODE_CLASS (code))
2263 /* If the expression has side-effects, then encase it in a SAVE_EXPR
2264 so that it will only be evaluated once. */
2265 /* The reference (r) and comparison (<) classes could be handled as
2266 below, but it is generally faster to only evaluate them once. */
2267 if (TREE_SIDE_EFFECTS (e))
2268 return save_expr (e);
2272 /* Constants need no processing. In fact, we should never reach
2277 /* Division is slow and tends to be compiled with jumps,
2278 especially the division by powers of 2 that is often
2279 found inside of an array reference. So do it just once. */
2280 if (code == TRUNC_DIV_EXPR || code == TRUNC_MOD_EXPR
2281 || code == FLOOR_DIV_EXPR || code == FLOOR_MOD_EXPR
2282 || code == CEIL_DIV_EXPR || code == CEIL_MOD_EXPR
2283 || code == ROUND_DIV_EXPR || code == ROUND_MOD_EXPR)
2284 return save_expr (e);
2285 /* Recursively stabilize each operand. */
2286 result = build_nt (code, stabilize_reference_1 (TREE_OPERAND (e, 0)),
2287 stabilize_reference_1 (TREE_OPERAND (e, 1)));
2291 /* Recursively stabilize each operand. */
2292 result = build_nt (code, stabilize_reference_1 (TREE_OPERAND (e, 0)));
2299 TREE_TYPE (result) = TREE_TYPE (e);
2300 TREE_READONLY (result) = TREE_READONLY (e);
2301 TREE_SIDE_EFFECTS (result) = TREE_SIDE_EFFECTS (e);
2302 TREE_THIS_VOLATILE (result) = TREE_THIS_VOLATILE (e);
2307 /* Low-level constructors for expressions. */
2309 /* Build an expression of code CODE, data type TYPE,
2310 and operands as specified by the arguments ARG1 and following arguments.
2311 Expressions and reference nodes can be created this way.
2312 Constants, decls, types and misc nodes cannot be. */
2315 build VPARAMS ((enum tree_code code, tree tt, ...))
2324 VA_FIXEDARG (p, enum tree_code, code);
2325 VA_FIXEDARG (p, tree, tt);
2327 t = make_node (code);
2328 length = TREE_CODE_LENGTH (code);
2331 /* Below, we automatically set TREE_SIDE_EFFECTS and TREE_READONLY for the
2332 result based on those same flags for the arguments. But if the
2333 arguments aren't really even `tree' expressions, we shouldn't be trying
2335 fro = first_rtl_op (code);
2337 /* Expressions without side effects may be constant if their
2338 arguments are as well. */
2339 constant = (TREE_CODE_CLASS (code) == '<'
2340 || TREE_CODE_CLASS (code) == '1'
2341 || TREE_CODE_CLASS (code) == '2'
2342 || TREE_CODE_CLASS (code) == 'c');
2346 /* This is equivalent to the loop below, but faster. */
2347 tree arg0 = va_arg (p, tree);
2348 tree arg1 = va_arg (p, tree);
2350 TREE_OPERAND (t, 0) = arg0;
2351 TREE_OPERAND (t, 1) = arg1;
2352 TREE_READONLY (t) = 1;
2353 if (arg0 && fro > 0)
2355 if (TREE_SIDE_EFFECTS (arg0))
2356 TREE_SIDE_EFFECTS (t) = 1;
2357 if (!TREE_READONLY (arg0))
2358 TREE_READONLY (t) = 0;
2359 if (!TREE_CONSTANT (arg0))
2363 if (arg1 && fro > 1)
2365 if (TREE_SIDE_EFFECTS (arg1))
2366 TREE_SIDE_EFFECTS (t) = 1;
2367 if (!TREE_READONLY (arg1))
2368 TREE_READONLY (t) = 0;
2369 if (!TREE_CONSTANT (arg1))
2373 else if (length == 1)
2375 tree arg0 = va_arg (p, tree);
2377 /* The only one-operand cases we handle here are those with side-effects.
2378 Others are handled with build1. So don't bother checked if the
2379 arg has side-effects since we'll already have set it.
2381 ??? This really should use build1 too. */
2382 if (TREE_CODE_CLASS (code) != 's')
2384 TREE_OPERAND (t, 0) = arg0;
2388 for (i = 0; i < length; i++)
2390 tree operand = va_arg (p, tree);
2392 TREE_OPERAND (t, i) = operand;
2393 if (operand && fro > i)
2395 if (TREE_SIDE_EFFECTS (operand))
2396 TREE_SIDE_EFFECTS (t) = 1;
2397 if (!TREE_CONSTANT (operand))
2404 TREE_CONSTANT (t) = constant;
2408 /* Same as above, but only builds for unary operators.
2409 Saves lions share of calls to `build'; cuts down use
2410 of varargs, which is expensive for RISC machines. */
2413 build1 (code, type, node)
2414 enum tree_code code;
2419 #ifdef GATHER_STATISTICS
2420 tree_node_kind kind;
2424 #ifdef GATHER_STATISTICS
2425 if (TREE_CODE_CLASS (code) == 'r')
2431 #ifdef ENABLE_CHECKING
2432 if (TREE_CODE_CLASS (code) == '2'
2433 || TREE_CODE_CLASS (code) == '<'
2434 || TREE_CODE_LENGTH (code) != 1)
2436 #endif /* ENABLE_CHECKING */
2438 length = sizeof (struct tree_exp);
2440 t = ggc_alloc_tree (length);
2442 memset ((PTR) t, 0, sizeof (struct tree_common));
2444 #ifdef GATHER_STATISTICS
2445 tree_node_counts[(int) kind]++;
2446 tree_node_sizes[(int) kind] += length;
2449 TREE_SET_CODE (t, code);
2451 TREE_TYPE (t) = type;
2452 TREE_COMPLEXITY (t) = 0;
2453 TREE_OPERAND (t, 0) = node;
2454 if (node && first_rtl_op (code) != 0)
2456 TREE_SIDE_EFFECTS (t) = TREE_SIDE_EFFECTS (node);
2457 TREE_READONLY (t) = TREE_READONLY (node);
2466 case PREDECREMENT_EXPR:
2467 case PREINCREMENT_EXPR:
2468 case POSTDECREMENT_EXPR:
2469 case POSTINCREMENT_EXPR:
2470 /* All of these have side-effects, no matter what their
2472 TREE_SIDE_EFFECTS (t) = 1;
2473 TREE_READONLY (t) = 0;
2477 /* Whether a dereference is readonly has nothing to do with whether
2478 its operand is readonly. */
2479 TREE_READONLY (t) = 0;
2483 if (TREE_CODE_CLASS (code) == '1' && node && TREE_CONSTANT (node))
2484 TREE_CONSTANT (t) = 1;
2491 /* Similar except don't specify the TREE_TYPE
2492 and leave the TREE_SIDE_EFFECTS as 0.
2493 It is permissible for arguments to be null,
2494 or even garbage if their values do not matter. */
2497 build_nt VPARAMS ((enum tree_code code, ...))
2504 VA_FIXEDARG (p, enum tree_code, code);
2506 t = make_node (code);
2507 length = TREE_CODE_LENGTH (code);
2509 for (i = 0; i < length; i++)
2510 TREE_OPERAND (t, i) = va_arg (p, tree);
2516 /* Create a DECL_... node of code CODE, name NAME and data type TYPE.
2517 We do NOT enter this node in any sort of symbol table.
2519 layout_decl is used to set up the decl's storage layout.
2520 Other slots are initialized to 0 or null pointers. */
2523 build_decl (code, name, type)
2524 enum tree_code code;
2529 t = make_node (code);
2531 /* if (type == error_mark_node)
2532 type = integer_type_node; */
2533 /* That is not done, deliberately, so that having error_mark_node
2534 as the type can suppress useless errors in the use of this variable. */
2536 DECL_NAME (t) = name;
2537 TREE_TYPE (t) = type;
2539 if (code == VAR_DECL || code == PARM_DECL || code == RESULT_DECL)
2541 else if (code == FUNCTION_DECL)
2542 DECL_MODE (t) = FUNCTION_MODE;
2547 /* BLOCK nodes are used to represent the structure of binding contours
2548 and declarations, once those contours have been exited and their contents
2549 compiled. This information is used for outputting debugging info. */
2552 build_block (vars, tags, subblocks, supercontext, chain)
2553 tree vars, tags ATTRIBUTE_UNUSED, subblocks, supercontext, chain;
2555 tree block = make_node (BLOCK);
2557 BLOCK_VARS (block) = vars;
2558 BLOCK_SUBBLOCKS (block) = subblocks;
2559 BLOCK_SUPERCONTEXT (block) = supercontext;
2560 BLOCK_CHAIN (block) = chain;
2564 /* EXPR_WITH_FILE_LOCATION are used to keep track of the exact
2565 location where an expression or an identifier were encountered. It
2566 is necessary for languages where the frontend parser will handle
2567 recursively more than one file (Java is one of them). */
2570 build_expr_wfl (node, file, line, col)
2575 static const char *last_file = 0;
2576 static tree last_filenode = NULL_TREE;
2577 tree wfl = make_node (EXPR_WITH_FILE_LOCATION);
2579 EXPR_WFL_NODE (wfl) = node;
2580 EXPR_WFL_SET_LINECOL (wfl, line, col);
2581 if (file != last_file)
2584 last_filenode = file ? get_identifier (file) : NULL_TREE;
2587 EXPR_WFL_FILENAME_NODE (wfl) = last_filenode;
2590 TREE_SIDE_EFFECTS (wfl) = TREE_SIDE_EFFECTS (node);
2591 TREE_TYPE (wfl) = TREE_TYPE (node);
2597 /* Return a declaration like DDECL except that its DECL_ATTRIBUTES
2601 build_decl_attribute_variant (ddecl, attribute)
2602 tree ddecl, attribute;
2604 DECL_ATTRIBUTES (ddecl) = attribute;
2608 /* Return a type like TTYPE except that its TYPE_ATTRIBUTE
2611 Record such modified types already made so we don't make duplicates. */
2614 build_type_attribute_variant (ttype, attribute)
2615 tree ttype, attribute;
2617 if ( ! attribute_list_equal (TYPE_ATTRIBUTES (ttype), attribute))
2619 unsigned int hashcode;
2622 ntype = copy_node (ttype);
2624 TYPE_POINTER_TO (ntype) = 0;
2625 TYPE_REFERENCE_TO (ntype) = 0;
2626 TYPE_ATTRIBUTES (ntype) = attribute;
2628 /* Create a new main variant of TYPE. */
2629 TYPE_MAIN_VARIANT (ntype) = ntype;
2630 TYPE_NEXT_VARIANT (ntype) = 0;
2631 set_type_quals (ntype, TYPE_UNQUALIFIED);
2633 hashcode = (TYPE_HASH (TREE_CODE (ntype))
2634 + TYPE_HASH (TREE_TYPE (ntype))
2635 + attribute_hash_list (attribute));
2637 switch (TREE_CODE (ntype))
2640 hashcode += TYPE_HASH (TYPE_ARG_TYPES (ntype));
2643 hashcode += TYPE_HASH (TYPE_DOMAIN (ntype));
2646 hashcode += TYPE_HASH (TYPE_MAX_VALUE (ntype));
2649 hashcode += TYPE_HASH (TYPE_PRECISION (ntype));
2655 ntype = type_hash_canon (hashcode, ntype);
2656 ttype = build_qualified_type (ntype, TYPE_QUALS (ttype));
2662 /* Default value of targetm.comp_type_attributes that always returns 1. */
2665 default_comp_type_attributes (type1, type2)
2666 tree type1 ATTRIBUTE_UNUSED;
2667 tree type2 ATTRIBUTE_UNUSED;
2672 /* Default version of targetm.set_default_type_attributes that always does
2676 default_set_default_type_attributes (type)
2677 tree type ATTRIBUTE_UNUSED;
2681 /* Default version of targetm.insert_attributes that always does nothing. */
2683 default_insert_attributes (decl, attr_ptr)
2684 tree decl ATTRIBUTE_UNUSED;
2685 tree *attr_ptr ATTRIBUTE_UNUSED;
2689 /* Default value of targetm.attribute_table that is empty. */
2690 const struct attribute_spec default_target_attribute_table[] =
2692 { NULL, 0, 0, false, false, false, NULL }
2695 /* Default value of targetm.function_attribute_inlinable_p that always
2698 default_function_attribute_inlinable_p (fndecl)
2699 tree fndecl ATTRIBUTE_UNUSED;
2701 /* By default, functions with machine attributes cannot be inlined. */
2705 /* Default value of targetm.ms_bitfield_layout_p that always returns
2708 default_ms_bitfield_layout_p (record)
2709 tree record ATTRIBUTE_UNUSED;
2711 /* By default, GCC does not use the MS VC++ bitfield layout rules. */
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 manipulated efficiently on
3377 the host. If POS is zero, the value can be represented in a single
3378 HOST_WIDE_INT. If POS is nonzero, the value must be positive and can
3379 be represented in a single unsigned HOST_WIDE_INT. */
3382 host_integerp (t, pos)
3386 return (TREE_CODE (t) == INTEGER_CST
3387 && ! TREE_OVERFLOW (t)
3388 && ((TREE_INT_CST_HIGH (t) == 0
3389 && (HOST_WIDE_INT) TREE_INT_CST_LOW (t) >= 0)
3390 || (! pos && TREE_INT_CST_HIGH (t) == -1
3391 && (HOST_WIDE_INT) TREE_INT_CST_LOW (t) < 0
3392 && ! TREE_UNSIGNED (TREE_TYPE (t)))
3393 || (pos && TREE_INT_CST_HIGH (t) == 0)));
3396 /* Return the HOST_WIDE_INT least significant bits of T if it is an
3397 INTEGER_CST and there is no overflow. POS is nonzero if the result must
3398 be positive. Abort if we cannot satisfy the above conditions. */
3401 tree_low_cst (t, pos)
3405 if (host_integerp (t, pos))
3406 return TREE_INT_CST_LOW (t);
3411 /* Return the most significant bit of the integer constant T. */
3414 tree_int_cst_msb (t)
3419 unsigned HOST_WIDE_INT l;
3421 /* Note that using TYPE_PRECISION here is wrong. We care about the
3422 actual bits, not the (arbitrary) range of the type. */
3423 prec = GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (t))) - 1;
3424 rshift_double (TREE_INT_CST_LOW (t), TREE_INT_CST_HIGH (t), prec,
3425 2 * HOST_BITS_PER_WIDE_INT, &l, &h, 0);
3426 return (l & 1) == 1;
3429 /* Return an indication of the sign of the integer constant T.
3430 The return value is -1 if T < 0, 0 if T == 0, and 1 if T > 0.
3431 Note that -1 will never be returned it T's type is unsigned. */
3434 tree_int_cst_sgn (t)
3437 if (TREE_INT_CST_LOW (t) == 0 && TREE_INT_CST_HIGH (t) == 0)
3439 else if (TREE_UNSIGNED (TREE_TYPE (t)))
3441 else if (TREE_INT_CST_HIGH (t) < 0)
3447 /* Compare two constructor-element-type constants. Return 1 if the lists
3448 are known to be equal; otherwise return 0. */
3451 simple_cst_list_equal (l1, l2)
3454 while (l1 != NULL_TREE && l2 != NULL_TREE)
3456 if (simple_cst_equal (TREE_VALUE (l1), TREE_VALUE (l2)) != 1)
3459 l1 = TREE_CHAIN (l1);
3460 l2 = TREE_CHAIN (l2);
3466 /* Return truthvalue of whether T1 is the same tree structure as T2.
3467 Return 1 if they are the same.
3468 Return 0 if they are understandably different.
3469 Return -1 if either contains tree structure not understood by
3473 simple_cst_equal (t1, t2)
3476 enum tree_code code1, code2;
3482 if (t1 == 0 || t2 == 0)
3485 code1 = TREE_CODE (t1);
3486 code2 = TREE_CODE (t2);
3488 if (code1 == NOP_EXPR || code1 == CONVERT_EXPR || code1 == NON_LVALUE_EXPR)
3490 if (code2 == NOP_EXPR || code2 == CONVERT_EXPR
3491 || code2 == NON_LVALUE_EXPR)
3492 return simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
3494 return simple_cst_equal (TREE_OPERAND (t1, 0), t2);
3497 else if (code2 == NOP_EXPR || code2 == CONVERT_EXPR
3498 || code2 == NON_LVALUE_EXPR)
3499 return simple_cst_equal (t1, TREE_OPERAND (t2, 0));
3507 return (TREE_INT_CST_LOW (t1) == TREE_INT_CST_LOW (t2)
3508 && TREE_INT_CST_HIGH (t1) == TREE_INT_CST_HIGH (t2));
3511 return REAL_VALUES_IDENTICAL (TREE_REAL_CST (t1), TREE_REAL_CST (t2));
3514 return (TREE_STRING_LENGTH (t1) == TREE_STRING_LENGTH (t2)
3515 && ! memcmp (TREE_STRING_POINTER (t1), TREE_STRING_POINTER (t2),
3516 TREE_STRING_LENGTH (t1)));
3519 if (CONSTRUCTOR_ELTS (t1) == CONSTRUCTOR_ELTS (t2))
3525 return simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
3528 cmp = simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
3532 simple_cst_list_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1));
3535 /* Special case: if either target is an unallocated VAR_DECL,
3536 it means that it's going to be unified with whatever the
3537 TARGET_EXPR is really supposed to initialize, so treat it
3538 as being equivalent to anything. */
3539 if ((TREE_CODE (TREE_OPERAND (t1, 0)) == VAR_DECL
3540 && DECL_NAME (TREE_OPERAND (t1, 0)) == NULL_TREE
3541 && !DECL_RTL_SET_P (TREE_OPERAND (t1, 0)))
3542 || (TREE_CODE (TREE_OPERAND (t2, 0)) == VAR_DECL
3543 && DECL_NAME (TREE_OPERAND (t2, 0)) == NULL_TREE
3544 && !DECL_RTL_SET_P (TREE_OPERAND (t2, 0))))
3547 cmp = simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
3552 return simple_cst_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1));
3554 case WITH_CLEANUP_EXPR:
3555 cmp = simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
3559 return simple_cst_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t1, 1));
3562 if (TREE_OPERAND (t1, 1) == TREE_OPERAND (t2, 1))
3563 return simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
3577 /* This general rule works for most tree codes. All exceptions should be
3578 handled above. If this is a language-specific tree code, we can't
3579 trust what might be in the operand, so say we don't know
3581 if ((int) code1 >= (int) LAST_AND_UNUSED_TREE_CODE)
3584 switch (TREE_CODE_CLASS (code1))
3593 for (i = 0; i < TREE_CODE_LENGTH (code1); i++)
3595 cmp = simple_cst_equal (TREE_OPERAND (t1, i), TREE_OPERAND (t2, i));
3607 /* Compare the value of T, an INTEGER_CST, with U, an unsigned integer value.
3608 Return -1, 0, or 1 if the value of T is less than, equal to, or greater
3609 than U, respectively. */
3612 compare_tree_int (t, u)
3614 unsigned HOST_WIDE_INT u;
3616 if (tree_int_cst_sgn (t) < 0)
3618 else if (TREE_INT_CST_HIGH (t) != 0)
3620 else if (TREE_INT_CST_LOW (t) == u)
3622 else if (TREE_INT_CST_LOW (t) < u)
3628 /* Constructors for pointer, array and function types.
3629 (RECORD_TYPE, UNION_TYPE and ENUMERAL_TYPE nodes are
3630 constructed by language-dependent code, not here.) */
3632 /* Construct, lay out and return the type of pointers to TO_TYPE.
3633 If such a type has already been constructed, reuse it. */
3636 build_pointer_type (to_type)
3639 tree t = TYPE_POINTER_TO (to_type);
3641 /* First, if we already have a type for pointers to TO_TYPE, use it. */
3646 /* We need a new one. */
3647 t = make_node (POINTER_TYPE);
3649 TREE_TYPE (t) = to_type;
3651 /* Record this type as the pointer to TO_TYPE. */
3652 TYPE_POINTER_TO (to_type) = t;
3654 /* Lay out the type. This function has many callers that are concerned
3655 with expression-construction, and this simplifies them all.
3656 Also, it guarantees the TYPE_SIZE is in the same obstack as the type. */
3662 /* Build the node for the type of references-to-TO_TYPE. */
3665 build_reference_type (to_type)
3668 tree t = TYPE_REFERENCE_TO (to_type);
3670 /* First, if we already have a type for pointers to TO_TYPE, use it. */
3675 /* We need a new one. */
3676 t = make_node (REFERENCE_TYPE);
3678 TREE_TYPE (t) = to_type;
3680 /* Record this type as the pointer to TO_TYPE. */
3681 TYPE_REFERENCE_TO (to_type) = t;
3688 /* Build a type that is compatible with t but has no cv quals anywhere
3691 const char *const *const * -> char ***. */
3694 build_type_no_quals (t)
3697 switch (TREE_CODE (t))
3700 return build_pointer_type (build_type_no_quals (TREE_TYPE (t)));
3701 case REFERENCE_TYPE:
3702 return build_reference_type (build_type_no_quals (TREE_TYPE (t)));
3704 return TYPE_MAIN_VARIANT (t);
3708 /* Create a type of integers to be the TYPE_DOMAIN of an ARRAY_TYPE.
3709 MAXVAL should be the maximum value in the domain
3710 (one less than the length of the array).
3712 The maximum value that MAXVAL can have is INT_MAX for a HOST_WIDE_INT.
3713 We don't enforce this limit, that is up to caller (e.g. language front end).
3714 The limit exists because the result is a signed type and we don't handle
3715 sizes that use more than one HOST_WIDE_INT. */
3718 build_index_type (maxval)
3721 tree itype = make_node (INTEGER_TYPE);
3723 TREE_TYPE (itype) = sizetype;
3724 TYPE_PRECISION (itype) = TYPE_PRECISION (sizetype);
3725 TYPE_MIN_VALUE (itype) = size_zero_node;
3726 TYPE_MAX_VALUE (itype) = convert (sizetype, maxval);
3727 TYPE_MODE (itype) = TYPE_MODE (sizetype);
3728 TYPE_SIZE (itype) = TYPE_SIZE (sizetype);
3729 TYPE_SIZE_UNIT (itype) = TYPE_SIZE_UNIT (sizetype);
3730 TYPE_ALIGN (itype) = TYPE_ALIGN (sizetype);
3731 TYPE_USER_ALIGN (itype) = TYPE_USER_ALIGN (sizetype);
3733 if (host_integerp (maxval, 1))
3734 return type_hash_canon (tree_low_cst (maxval, 1), itype);
3739 /* Create a range of some discrete type TYPE (an INTEGER_TYPE,
3740 ENUMERAL_TYPE, BOOLEAN_TYPE, or CHAR_TYPE), with
3741 low bound LOWVAL and high bound HIGHVAL.
3742 if TYPE==NULL_TREE, sizetype is used. */
3745 build_range_type (type, lowval, highval)
3746 tree type, lowval, highval;
3748 tree itype = make_node (INTEGER_TYPE);
3750 TREE_TYPE (itype) = type;
3751 if (type == NULL_TREE)
3754 TYPE_MIN_VALUE (itype) = convert (type, lowval);
3755 TYPE_MAX_VALUE (itype) = highval ? convert (type, highval) : NULL;
3757 TYPE_PRECISION (itype) = TYPE_PRECISION (type);
3758 TYPE_MODE (itype) = TYPE_MODE (type);
3759 TYPE_SIZE (itype) = TYPE_SIZE (type);
3760 TYPE_SIZE_UNIT (itype) = TYPE_SIZE_UNIT (type);
3761 TYPE_ALIGN (itype) = TYPE_ALIGN (type);
3762 TYPE_USER_ALIGN (itype) = TYPE_USER_ALIGN (type);
3764 if (host_integerp (lowval, 0) && highval != 0 && host_integerp (highval, 0))
3765 return type_hash_canon (tree_low_cst (highval, 0)
3766 - tree_low_cst (lowval, 0),
3772 /* Just like build_index_type, but takes lowval and highval instead
3773 of just highval (maxval). */
3776 build_index_2_type (lowval, highval)
3777 tree lowval, highval;
3779 return build_range_type (sizetype, lowval, highval);
3782 /* Return nonzero iff ITYPE1 and ITYPE2 are equal (in the LISP sense).
3783 Needed because when index types are not hashed, equal index types
3784 built at different times appear distinct, even though structurally,
3788 index_type_equal (itype1, itype2)
3789 tree itype1, itype2;
3791 if (TREE_CODE (itype1) != TREE_CODE (itype2))
3794 if (TREE_CODE (itype1) == INTEGER_TYPE)
3796 if (TYPE_PRECISION (itype1) != TYPE_PRECISION (itype2)
3797 || TYPE_MODE (itype1) != TYPE_MODE (itype2)
3798 || simple_cst_equal (TYPE_SIZE (itype1), TYPE_SIZE (itype2)) != 1
3799 || TYPE_ALIGN (itype1) != TYPE_ALIGN (itype2))
3802 if (1 == simple_cst_equal (TYPE_MIN_VALUE (itype1),
3803 TYPE_MIN_VALUE (itype2))
3804 && 1 == simple_cst_equal (TYPE_MAX_VALUE (itype1),
3805 TYPE_MAX_VALUE (itype2)))
3812 /* Construct, lay out and return the type of arrays of elements with ELT_TYPE
3813 and number of elements specified by the range of values of INDEX_TYPE.
3814 If such a type has already been constructed, reuse it. */
3817 build_array_type (elt_type, index_type)
3818 tree elt_type, index_type;
3821 unsigned int hashcode;
3823 if (TREE_CODE (elt_type) == FUNCTION_TYPE)
3825 error ("arrays of functions are not meaningful");
3826 elt_type = integer_type_node;
3829 /* Make sure TYPE_POINTER_TO (elt_type) is filled in. */
3830 build_pointer_type (elt_type);
3832 /* Allocate the array after the pointer type,
3833 in case we free it in type_hash_canon. */
3834 t = make_node (ARRAY_TYPE);
3835 TREE_TYPE (t) = elt_type;
3836 TYPE_DOMAIN (t) = index_type;
3838 if (index_type == 0)
3843 hashcode = TYPE_HASH (elt_type) + TYPE_HASH (index_type);
3844 t = type_hash_canon (hashcode, t);
3846 if (!COMPLETE_TYPE_P (t))
3851 /* Return the TYPE of the elements comprising
3852 the innermost dimension of ARRAY. */
3855 get_inner_array_type (array)
3858 tree type = TREE_TYPE (array);
3860 while (TREE_CODE (type) == ARRAY_TYPE)
3861 type = TREE_TYPE (type);
3866 /* Construct, lay out and return
3867 the type of functions returning type VALUE_TYPE
3868 given arguments of types ARG_TYPES.
3869 ARG_TYPES is a chain of TREE_LIST nodes whose TREE_VALUEs
3870 are data type nodes for the arguments of the function.
3871 If such a type has already been constructed, reuse it. */
3874 build_function_type (value_type, arg_types)
3875 tree value_type, arg_types;
3878 unsigned int hashcode;
3880 if (TREE_CODE (value_type) == FUNCTION_TYPE)
3882 error ("function return type cannot be function");
3883 value_type = integer_type_node;
3886 /* Make a node of the sort we want. */
3887 t = make_node (FUNCTION_TYPE);
3888 TREE_TYPE (t) = value_type;
3889 TYPE_ARG_TYPES (t) = arg_types;
3891 /* If we already have such a type, use the old one and free this one. */
3892 hashcode = TYPE_HASH (value_type) + type_hash_list (arg_types);
3893 t = type_hash_canon (hashcode, t);
3895 if (!COMPLETE_TYPE_P (t))
3900 /* Construct, lay out and return the type of methods belonging to class
3901 BASETYPE and whose arguments and values are described by TYPE.
3902 If that type exists already, reuse it.
3903 TYPE must be a FUNCTION_TYPE node. */
3906 build_method_type (basetype, type)
3907 tree basetype, type;
3910 unsigned int hashcode;
3912 /* Make a node of the sort we want. */
3913 t = make_node (METHOD_TYPE);
3915 if (TREE_CODE (type) != FUNCTION_TYPE)
3918 TYPE_METHOD_BASETYPE (t) = TYPE_MAIN_VARIANT (basetype);
3919 TREE_TYPE (t) = TREE_TYPE (type);
3921 /* The actual arglist for this function includes a "hidden" argument
3922 which is "this". Put it into the list of argument types. */
3925 = tree_cons (NULL_TREE,
3926 build_pointer_type (basetype), TYPE_ARG_TYPES (type));
3928 /* If we already have such a type, use the old one and free this one. */
3929 hashcode = TYPE_HASH (basetype) + TYPE_HASH (type);
3930 t = type_hash_canon (hashcode, t);
3932 if (!COMPLETE_TYPE_P (t))
3938 /* Construct, lay out and return the type of offsets to a value
3939 of type TYPE, within an object of type BASETYPE.
3940 If a suitable offset type exists already, reuse it. */
3943 build_offset_type (basetype, type)
3944 tree basetype, type;
3947 unsigned int hashcode;
3949 /* Make a node of the sort we want. */
3950 t = make_node (OFFSET_TYPE);
3952 TYPE_OFFSET_BASETYPE (t) = TYPE_MAIN_VARIANT (basetype);
3953 TREE_TYPE (t) = type;
3955 /* If we already have such a type, use the old one and free this one. */
3956 hashcode = TYPE_HASH (basetype) + TYPE_HASH (type);
3957 t = type_hash_canon (hashcode, t);
3959 if (!COMPLETE_TYPE_P (t))
3965 /* Create a complex type whose components are COMPONENT_TYPE. */
3968 build_complex_type (component_type)
3969 tree component_type;
3972 unsigned int hashcode;
3974 /* Make a node of the sort we want. */
3975 t = make_node (COMPLEX_TYPE);
3977 TREE_TYPE (t) = TYPE_MAIN_VARIANT (component_type);
3978 set_type_quals (t, TYPE_QUALS (component_type));
3980 /* If we already have such a type, use the old one and free this one. */
3981 hashcode = TYPE_HASH (component_type);
3982 t = type_hash_canon (hashcode, t);
3984 if (!COMPLETE_TYPE_P (t))
3987 /* If we are writing Dwarf2 output we need to create a name,
3988 since complex is a fundamental type. */
3989 if ((write_symbols == DWARF2_DEBUG || write_symbols == VMS_AND_DWARF2_DEBUG)
3993 if (component_type == char_type_node)
3994 name = "complex char";
3995 else if (component_type == signed_char_type_node)
3996 name = "complex signed char";
3997 else if (component_type == unsigned_char_type_node)
3998 name = "complex unsigned char";
3999 else if (component_type == short_integer_type_node)
4000 name = "complex short int";
4001 else if (component_type == short_unsigned_type_node)
4002 name = "complex short unsigned int";
4003 else if (component_type == integer_type_node)
4004 name = "complex int";
4005 else if (component_type == unsigned_type_node)
4006 name = "complex unsigned int";
4007 else if (component_type == long_integer_type_node)
4008 name = "complex long int";
4009 else if (component_type == long_unsigned_type_node)
4010 name = "complex long unsigned int";
4011 else if (component_type == long_long_integer_type_node)
4012 name = "complex long long int";
4013 else if (component_type == long_long_unsigned_type_node)
4014 name = "complex long long unsigned int";
4019 TYPE_NAME (t) = get_identifier (name);
4025 /* Return OP, stripped of any conversions to wider types as much as is safe.
4026 Converting the value back to OP's type makes a value equivalent to OP.
4028 If FOR_TYPE is nonzero, we return a value which, if converted to
4029 type FOR_TYPE, would be equivalent to converting OP to type FOR_TYPE.
4031 If FOR_TYPE is nonzero, unaligned bit-field references may be changed to the
4032 narrowest type that can hold the value, even if they don't exactly fit.
4033 Otherwise, bit-field references are changed to a narrower type
4034 only if they can be fetched directly from memory in that type.
4036 OP must have integer, real or enumeral type. Pointers are not allowed!
4038 There are some cases where the obvious value we could return
4039 would regenerate to OP if converted to OP's type,
4040 but would not extend like OP to wider types.
4041 If FOR_TYPE indicates such extension is contemplated, we eschew such values.
4042 For example, if OP is (unsigned short)(signed char)-1,
4043 we avoid returning (signed char)-1 if FOR_TYPE is int,
4044 even though extending that to an unsigned short would regenerate OP,
4045 since the result of extending (signed char)-1 to (int)
4046 is different from (int) OP. */
4049 get_unwidened (op, for_type)
4053 /* Set UNS initially if converting OP to FOR_TYPE is a zero-extension. */
4054 tree type = TREE_TYPE (op);
4056 = TYPE_PRECISION (for_type != 0 ? for_type : type);
4058 = (for_type != 0 && for_type != type
4059 && final_prec > TYPE_PRECISION (type)
4060 && TREE_UNSIGNED (type));
4063 while (TREE_CODE (op) == NOP_EXPR)
4066 = TYPE_PRECISION (TREE_TYPE (op))
4067 - TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op, 0)));
4069 /* Truncations are many-one so cannot be removed.
4070 Unless we are later going to truncate down even farther. */
4072 && final_prec > TYPE_PRECISION (TREE_TYPE (op)))
4075 /* See what's inside this conversion. If we decide to strip it,
4077 op = TREE_OPERAND (op, 0);
4079 /* If we have not stripped any zero-extensions (uns is 0),
4080 we can strip any kind of extension.
4081 If we have previously stripped a zero-extension,
4082 only zero-extensions can safely be stripped.
4083 Any extension can be stripped if the bits it would produce
4084 are all going to be discarded later by truncating to FOR_TYPE. */
4088 if (! uns || final_prec <= TYPE_PRECISION (TREE_TYPE (op)))
4090 /* TREE_UNSIGNED says whether this is a zero-extension.
4091 Let's avoid computing it if it does not affect WIN
4092 and if UNS will not be needed again. */
4093 if ((uns || TREE_CODE (op) == NOP_EXPR)
4094 && TREE_UNSIGNED (TREE_TYPE (op)))
4102 if (TREE_CODE (op) == COMPONENT_REF
4103 /* Since type_for_size always gives an integer type. */
4104 && TREE_CODE (type) != REAL_TYPE
4105 /* Don't crash if field not laid out yet. */
4106 && DECL_SIZE (TREE_OPERAND (op, 1)) != 0
4107 && host_integerp (DECL_SIZE (TREE_OPERAND (op, 1)), 1))
4109 unsigned int innerprec
4110 = tree_low_cst (DECL_SIZE (TREE_OPERAND (op, 1)), 1);
4112 type = type_for_size (innerprec, TREE_UNSIGNED (TREE_OPERAND (op, 1)));
4114 /* We can get this structure field in the narrowest type it fits in.
4115 If FOR_TYPE is 0, do this only for a field that matches the
4116 narrower type exactly and is aligned for it
4117 The resulting extension to its nominal type (a fullword type)
4118 must fit the same conditions as for other extensions. */
4120 if (innerprec < TYPE_PRECISION (TREE_TYPE (op))
4121 && (for_type || ! DECL_BIT_FIELD (TREE_OPERAND (op, 1)))
4122 && (! uns || final_prec <= innerprec
4123 || TREE_UNSIGNED (TREE_OPERAND (op, 1)))
4126 win = build (COMPONENT_REF, type, TREE_OPERAND (op, 0),
4127 TREE_OPERAND (op, 1));
4128 TREE_SIDE_EFFECTS (win) = TREE_SIDE_EFFECTS (op);
4129 TREE_THIS_VOLATILE (win) = TREE_THIS_VOLATILE (op);
4136 /* Return OP or a simpler expression for a narrower value
4137 which can be sign-extended or zero-extended to give back OP.
4138 Store in *UNSIGNEDP_PTR either 1 if the value should be zero-extended
4139 or 0 if the value should be sign-extended. */
4142 get_narrower (op, unsignedp_ptr)
4150 while (TREE_CODE (op) == NOP_EXPR)
4153 = (TYPE_PRECISION (TREE_TYPE (op))
4154 - TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op, 0))));
4156 /* Truncations are many-one so cannot be removed. */
4160 /* See what's inside this conversion. If we decide to strip it,
4162 op = TREE_OPERAND (op, 0);
4166 /* An extension: the outermost one can be stripped,
4167 but remember whether it is zero or sign extension. */
4169 uns = TREE_UNSIGNED (TREE_TYPE (op));
4170 /* Otherwise, if a sign extension has been stripped,
4171 only sign extensions can now be stripped;
4172 if a zero extension has been stripped, only zero-extensions. */
4173 else if (uns != TREE_UNSIGNED (TREE_TYPE (op)))
4177 else /* bitschange == 0 */
4179 /* A change in nominal type can always be stripped, but we must
4180 preserve the unsignedness. */
4182 uns = TREE_UNSIGNED (TREE_TYPE (op));
4189 if (TREE_CODE (op) == COMPONENT_REF
4190 /* Since type_for_size always gives an integer type. */
4191 && TREE_CODE (TREE_TYPE (op)) != REAL_TYPE
4192 /* Ensure field is laid out already. */
4193 && DECL_SIZE (TREE_OPERAND (op, 1)) != 0)
4195 unsigned HOST_WIDE_INT innerprec
4196 = tree_low_cst (DECL_SIZE (TREE_OPERAND (op, 1)), 1);
4197 tree type = type_for_size (innerprec, TREE_UNSIGNED (op));
4199 /* We can get this structure field in a narrower type that fits it,
4200 but the resulting extension to its nominal type (a fullword type)
4201 must satisfy the same conditions as for other extensions.
4203 Do this only for fields that are aligned (not bit-fields),
4204 because when bit-field insns will be used there is no
4205 advantage in doing this. */
4207 if (innerprec < TYPE_PRECISION (TREE_TYPE (op))
4208 && ! DECL_BIT_FIELD (TREE_OPERAND (op, 1))
4209 && (first || uns == TREE_UNSIGNED (TREE_OPERAND (op, 1)))
4213 uns = TREE_UNSIGNED (TREE_OPERAND (op, 1));
4214 win = build (COMPONENT_REF, type, TREE_OPERAND (op, 0),
4215 TREE_OPERAND (op, 1));
4216 TREE_SIDE_EFFECTS (win) = TREE_SIDE_EFFECTS (op);
4217 TREE_THIS_VOLATILE (win) = TREE_THIS_VOLATILE (op);
4220 *unsignedp_ptr = uns;
4224 /* Nonzero if integer constant C has a value that is permissible
4225 for type TYPE (an INTEGER_TYPE). */
4228 int_fits_type_p (c, type)
4231 /* If the bounds of the type are integers, we can check ourselves.
4232 If not, but this type is a subtype, try checking against that.
4233 Otherwise, use force_fit_type, which checks against the precision. */
4234 if (TYPE_MAX_VALUE (type) != NULL_TREE
4235 && TYPE_MIN_VALUE (type) != NULL_TREE
4236 && TREE_CODE (TYPE_MAX_VALUE (type)) == INTEGER_CST
4237 && TREE_CODE (TYPE_MIN_VALUE (type)) == INTEGER_CST)
4239 if (TREE_UNSIGNED (type))
4240 return (! INT_CST_LT_UNSIGNED (TYPE_MAX_VALUE (type), c)
4241 && ! INT_CST_LT_UNSIGNED (c, TYPE_MIN_VALUE (type))
4242 /* Negative ints never fit unsigned types. */
4243 && ! (TREE_INT_CST_HIGH (c) < 0
4244 && ! TREE_UNSIGNED (TREE_TYPE (c))));
4246 return (! INT_CST_LT (TYPE_MAX_VALUE (type), c)
4247 && ! INT_CST_LT (c, TYPE_MIN_VALUE (type))
4248 /* Unsigned ints with top bit set never fit signed types. */
4249 && ! (TREE_INT_CST_HIGH (c) < 0
4250 && TREE_UNSIGNED (TREE_TYPE (c))));
4252 else if (TREE_CODE (type) == INTEGER_TYPE && TREE_TYPE (type) != 0)
4253 return int_fits_type_p (c, TREE_TYPE (type));
4257 TREE_TYPE (c) = type;
4258 return !force_fit_type (c, 0);
4262 /* Given a DECL or TYPE, return the scope in which it was declared, or
4263 NULL_TREE if there is no containing scope. */
4266 get_containing_scope (t)
4269 return (TYPE_P (t) ? TYPE_CONTEXT (t) : DECL_CONTEXT (t));
4272 /* Return the innermost context enclosing DECL that is
4273 a FUNCTION_DECL, or zero if none. */
4276 decl_function_context (decl)
4281 if (TREE_CODE (decl) == ERROR_MARK)
4284 if (TREE_CODE (decl) == SAVE_EXPR)
4285 context = SAVE_EXPR_CONTEXT (decl);
4287 /* C++ virtual functions use DECL_CONTEXT for the class of the vtable
4288 where we look up the function at runtime. Such functions always take
4289 a first argument of type 'pointer to real context'.
4291 C++ should really be fixed to use DECL_CONTEXT for the real context,
4292 and use something else for the "virtual context". */
4293 else if (TREE_CODE (decl) == FUNCTION_DECL && DECL_VINDEX (decl))
4296 (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl)))));
4298 context = DECL_CONTEXT (decl);
4300 while (context && TREE_CODE (context) != FUNCTION_DECL)
4302 if (TREE_CODE (context) == BLOCK)
4303 context = BLOCK_SUPERCONTEXT (context);
4305 context = get_containing_scope (context);
4311 /* Return the innermost context enclosing DECL that is
4312 a RECORD_TYPE, UNION_TYPE or QUAL_UNION_TYPE, or zero if none.
4313 TYPE_DECLs and FUNCTION_DECLs are transparent to this function. */
4316 decl_type_context (decl)
4319 tree context = DECL_CONTEXT (decl);
4323 if (TREE_CODE (context) == RECORD_TYPE
4324 || TREE_CODE (context) == UNION_TYPE
4325 || TREE_CODE (context) == QUAL_UNION_TYPE)
4328 if (TREE_CODE (context) == TYPE_DECL
4329 || TREE_CODE (context) == FUNCTION_DECL)
4330 context = DECL_CONTEXT (context);
4332 else if (TREE_CODE (context) == BLOCK)
4333 context = BLOCK_SUPERCONTEXT (context);
4336 /* Unhandled CONTEXT!? */
4342 /* CALL is a CALL_EXPR. Return the declaration for the function
4343 called, or NULL_TREE if the called function cannot be
4347 get_callee_fndecl (call)
4352 /* It's invalid to call this function with anything but a
4354 if (TREE_CODE (call) != CALL_EXPR)
4357 /* The first operand to the CALL is the address of the function
4359 addr = TREE_OPERAND (call, 0);
4363 /* If this is a readonly function pointer, extract its initial value. */
4364 if (DECL_P (addr) && TREE_CODE (addr) != FUNCTION_DECL
4365 && TREE_READONLY (addr) && ! TREE_THIS_VOLATILE (addr)
4366 && DECL_INITIAL (addr))
4367 addr = DECL_INITIAL (addr);
4369 /* If the address is just `&f' for some function `f', then we know
4370 that `f' is being called. */
4371 if (TREE_CODE (addr) == ADDR_EXPR
4372 && TREE_CODE (TREE_OPERAND (addr, 0)) == FUNCTION_DECL)
4373 return TREE_OPERAND (addr, 0);
4375 /* We couldn't figure out what was being called. */
4379 /* Print debugging information about the obstack O, named STR. */
4382 print_obstack_statistics (str, o)
4386 struct _obstack_chunk *chunk = o->chunk;
4390 n_alloc += o->next_free - chunk->contents;
4391 chunk = chunk->prev;
4395 n_alloc += chunk->limit - &chunk->contents[0];
4396 chunk = chunk->prev;
4398 fprintf (stderr, "obstack %s: %u bytes, %d chunks\n",
4399 str, n_alloc, n_chunks);
4402 /* Print debugging information about tree nodes generated during the compile,
4403 and any language-specific information. */
4406 dump_tree_statistics ()
4408 #ifdef GATHER_STATISTICS
4410 int total_nodes, total_bytes;
4413 fprintf (stderr, "\n??? tree nodes created\n\n");
4414 #ifdef GATHER_STATISTICS
4415 fprintf (stderr, "Kind Nodes Bytes\n");
4416 fprintf (stderr, "-------------------------------------\n");
4417 total_nodes = total_bytes = 0;
4418 for (i = 0; i < (int) all_kinds; i++)
4420 fprintf (stderr, "%-20s %6d %9d\n", tree_node_kind_names[i],
4421 tree_node_counts[i], tree_node_sizes[i]);
4422 total_nodes += tree_node_counts[i];
4423 total_bytes += tree_node_sizes[i];
4425 fprintf (stderr, "-------------------------------------\n");
4426 fprintf (stderr, "%-20s %6d %9d\n", "Total", total_nodes, total_bytes);
4427 fprintf (stderr, "-------------------------------------\n");
4429 fprintf (stderr, "(No per-node statistics)\n");
4431 print_obstack_statistics ("permanent_obstack", &permanent_obstack);
4432 print_type_hash_statistics ();
4433 (*lang_hooks.print_statistics) ();
4436 #define FILE_FUNCTION_PREFIX_LEN 9
4438 #define FILE_FUNCTION_FORMAT "_GLOBAL__%s_%s"
4440 /* Appends 6 random characters to TEMPLATE to (hopefully) avoid name
4441 clashes in cases where we can't reliably choose a unique name.
4443 Derived from mkstemp.c in libiberty. */
4446 append_random_chars (template)
4449 static const char letters[]
4450 = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
4451 static unsigned HOST_WIDE_INT value;
4452 unsigned HOST_WIDE_INT v;
4458 /* VALUE should be unique for each file and must not change between
4459 compiles since this can cause bootstrap comparison errors. */
4461 if (stat (main_input_filename, &st) < 0)
4463 /* This can happen when preprocessed text is shipped between
4464 machines, e.g. with bug reports. Assume that uniqueness
4465 isn't actually an issue. */
4470 /* In VMS, ino is an array, so we have to use both values. We
4471 conditionalize that. */
4473 #define INO_TO_INT(INO) ((int) (INO)[1] << 16 ^ (int) (INO)[2])
4475 #define INO_TO_INT(INO) INO
4477 value = st.st_dev ^ INO_TO_INT (st.st_ino) ^ st.st_mtime;
4481 template += strlen (template);
4485 /* Fill in the random bits. */
4486 template[0] = letters[v % 62];
4488 template[1] = letters[v % 62];
4490 template[2] = letters[v % 62];
4492 template[3] = letters[v % 62];
4494 template[4] = letters[v % 62];
4496 template[5] = letters[v % 62];
4501 /* P is a string that will be used in a symbol. Mask out any characters
4502 that are not valid in that context. */
4505 clean_symbol_name (p)
4510 #ifndef NO_DOLLAR_IN_LABEL /* this for `$'; unlikely, but... -- kr */
4513 #ifndef NO_DOT_IN_LABEL /* this for `.'; unlikely, but... */
4520 /* Generate a name for a function unique to this translation unit.
4521 TYPE is some string to identify the purpose of this function to the
4522 linker or collect2. */
4525 get_file_function_name_long (type)
4532 if (first_global_object_name)
4533 p = first_global_object_name;
4536 /* We don't have anything that we know to be unique to this translation
4537 unit, so use what we do have and throw in some randomness. */
4539 const char *name = weak_global_object_name;
4540 const char *file = main_input_filename;
4545 file = input_filename;
4547 q = (char *) alloca (7 + strlen (name) + strlen (file));
4549 sprintf (q, "%s%s", name, file);
4550 append_random_chars (q);
4554 buf = (char *) alloca (sizeof (FILE_FUNCTION_FORMAT) + strlen (p)
4557 /* Set up the name of the file-level functions we may need.
4558 Use a global object (which is already required to be unique over
4559 the program) rather than the file name (which imposes extra
4561 sprintf (buf, FILE_FUNCTION_FORMAT, type, p);
4563 /* Don't need to pull weird characters out of global names. */
4564 if (p != first_global_object_name)
4565 clean_symbol_name (buf + 11);
4567 return get_identifier (buf);
4570 /* If KIND=='I', return a suitable global initializer (constructor) name.
4571 If KIND=='D', return a suitable global clean-up (destructor) name. */
4574 get_file_function_name (kind)
4582 return get_file_function_name_long (p);
4585 /* Expand (the constant part of) a SET_TYPE CONSTRUCTOR node.
4586 The result is placed in BUFFER (which has length BIT_SIZE),
4587 with one bit in each char ('\000' or '\001').
4589 If the constructor is constant, NULL_TREE is returned.
4590 Otherwise, a TREE_LIST of the non-constant elements is emitted. */
4593 get_set_constructor_bits (init, buffer, bit_size)
4600 HOST_WIDE_INT domain_min
4601 = tree_low_cst (TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (init))), 0);
4602 tree non_const_bits = NULL_TREE;
4604 for (i = 0; i < bit_size; i++)
4607 for (vals = TREE_OPERAND (init, 1);
4608 vals != NULL_TREE; vals = TREE_CHAIN (vals))
4610 if (!host_integerp (TREE_VALUE (vals), 0)
4611 || (TREE_PURPOSE (vals) != NULL_TREE
4612 && !host_integerp (TREE_PURPOSE (vals), 0)))
4614 = tree_cons (TREE_PURPOSE (vals), TREE_VALUE (vals), non_const_bits);
4615 else if (TREE_PURPOSE (vals) != NULL_TREE)
4617 /* Set a range of bits to ones. */
4618 HOST_WIDE_INT lo_index
4619 = tree_low_cst (TREE_PURPOSE (vals), 0) - domain_min;
4620 HOST_WIDE_INT hi_index
4621 = tree_low_cst (TREE_VALUE (vals), 0) - domain_min;
4623 if (lo_index < 0 || lo_index >= bit_size
4624 || hi_index < 0 || hi_index >= bit_size)
4626 for (; lo_index <= hi_index; lo_index++)
4627 buffer[lo_index] = 1;
4631 /* Set a single bit to one. */
4633 = tree_low_cst (TREE_VALUE (vals), 0) - domain_min;
4634 if (index < 0 || index >= bit_size)
4636 error ("invalid initializer for bit string");
4642 return non_const_bits;
4645 /* Expand (the constant part of) a SET_TYPE CONSTRUCTOR node.
4646 The result is placed in BUFFER (which is an array of bytes).
4647 If the constructor is constant, NULL_TREE is returned.
4648 Otherwise, a TREE_LIST of the non-constant elements is emitted. */
4651 get_set_constructor_bytes (init, buffer, wd_size)
4653 unsigned char *buffer;
4657 int set_word_size = BITS_PER_UNIT;
4658 int bit_size = wd_size * set_word_size;
4660 unsigned char *bytep = buffer;
4661 char *bit_buffer = (char *) alloca (bit_size);
4662 tree non_const_bits = get_set_constructor_bits (init, bit_buffer, bit_size);
4664 for (i = 0; i < wd_size; i++)
4667 for (i = 0; i < bit_size; i++)
4671 if (BYTES_BIG_ENDIAN)
4672 *bytep |= (1 << (set_word_size - 1 - bit_pos));
4674 *bytep |= 1 << bit_pos;
4677 if (bit_pos >= set_word_size)
4678 bit_pos = 0, bytep++;
4680 return non_const_bits;
4683 #if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
4684 /* Complain that the tree code of NODE does not match the expected CODE.
4685 FILE, LINE, and FUNCTION are of the caller. */
4688 tree_check_failed (node, code, file, line, function)
4690 enum tree_code code;
4693 const char *function;
4695 internal_error ("tree check: expected %s, have %s in %s, at %s:%d",
4696 tree_code_name[code], tree_code_name[TREE_CODE (node)],
4697 function, trim_filename (file), line);
4700 /* Similar to above, except that we check for a class of tree
4701 code, given in CL. */
4704 tree_class_check_failed (node, cl, file, line, function)
4709 const char *function;
4712 ("tree check: expected class '%c', have '%c' (%s) in %s, at %s:%d",
4713 cl, TREE_CODE_CLASS (TREE_CODE (node)),
4714 tree_code_name[TREE_CODE (node)], function, trim_filename (file), line);
4717 #endif /* ENABLE_TREE_CHECKING */
4719 /* For a new vector type node T, build the information necessary for
4720 debuggint output. */
4723 finish_vector_type (t)
4729 tree index = build_int_2 (TYPE_VECTOR_SUBPARTS (t) - 1, 0);
4730 tree array = build_array_type (TREE_TYPE (t),
4731 build_index_type (index));
4732 tree rt = make_node (RECORD_TYPE);
4734 TYPE_FIELDS (rt) = build_decl (FIELD_DECL, get_identifier ("f"), array);
4735 DECL_CONTEXT (TYPE_FIELDS (rt)) = rt;
4737 TYPE_DEBUG_REPRESENTATION_TYPE (t) = rt;
4738 /* In dwarfout.c, type lookup uses TYPE_UID numbers. We want to output
4739 the representation type, and we want to find that die when looking up
4740 the vector type. This is most easily achieved by making the TYPE_UID
4742 TYPE_UID (rt) = TYPE_UID (t);
4746 /* Create nodes for all integer types (and error_mark_node) using the sizes
4747 of C datatypes. The caller should call set_sizetype soon after calling
4748 this function to select one of the types as sizetype. */
4751 build_common_tree_nodes (signed_char)
4754 error_mark_node = make_node (ERROR_MARK);
4755 TREE_TYPE (error_mark_node) = error_mark_node;
4757 initialize_sizetypes ();
4759 /* Define both `signed char' and `unsigned char'. */
4760 signed_char_type_node = make_signed_type (CHAR_TYPE_SIZE);
4761 unsigned_char_type_node = make_unsigned_type (CHAR_TYPE_SIZE);
4763 /* Define `char', which is like either `signed char' or `unsigned char'
4764 but not the same as either. */
4767 ? make_signed_type (CHAR_TYPE_SIZE)
4768 : make_unsigned_type (CHAR_TYPE_SIZE));
4770 short_integer_type_node = make_signed_type (SHORT_TYPE_SIZE);
4771 short_unsigned_type_node = make_unsigned_type (SHORT_TYPE_SIZE);
4772 integer_type_node = make_signed_type (INT_TYPE_SIZE);
4773 unsigned_type_node = make_unsigned_type (INT_TYPE_SIZE);
4774 long_integer_type_node = make_signed_type (LONG_TYPE_SIZE);
4775 long_unsigned_type_node = make_unsigned_type (LONG_TYPE_SIZE);
4776 long_long_integer_type_node = make_signed_type (LONG_LONG_TYPE_SIZE);
4777 long_long_unsigned_type_node = make_unsigned_type (LONG_LONG_TYPE_SIZE);
4779 intQI_type_node = make_signed_type (GET_MODE_BITSIZE (QImode));
4780 intHI_type_node = make_signed_type (GET_MODE_BITSIZE (HImode));
4781 intSI_type_node = make_signed_type (GET_MODE_BITSIZE (SImode));
4782 intDI_type_node = make_signed_type (GET_MODE_BITSIZE (DImode));
4783 intTI_type_node = make_signed_type (GET_MODE_BITSIZE (TImode));
4785 unsigned_intQI_type_node = make_unsigned_type (GET_MODE_BITSIZE (QImode));
4786 unsigned_intHI_type_node = make_unsigned_type (GET_MODE_BITSIZE (HImode));
4787 unsigned_intSI_type_node = make_unsigned_type (GET_MODE_BITSIZE (SImode));
4788 unsigned_intDI_type_node = make_unsigned_type (GET_MODE_BITSIZE (DImode));
4789 unsigned_intTI_type_node = make_unsigned_type (GET_MODE_BITSIZE (TImode));
4792 /* Call this function after calling build_common_tree_nodes and set_sizetype.
4793 It will create several other common tree nodes. */
4796 build_common_tree_nodes_2 (short_double)
4799 /* Define these next since types below may used them. */
4800 integer_zero_node = build_int_2 (0, 0);
4801 integer_one_node = build_int_2 (1, 0);
4802 integer_minus_one_node = build_int_2 (-1, -1);
4804 size_zero_node = size_int (0);
4805 size_one_node = size_int (1);
4806 bitsize_zero_node = bitsize_int (0);
4807 bitsize_one_node = bitsize_int (1);
4808 bitsize_unit_node = bitsize_int (BITS_PER_UNIT);
4810 void_type_node = make_node (VOID_TYPE);
4811 layout_type (void_type_node);
4813 /* We are not going to have real types in C with less than byte alignment,
4814 so we might as well not have any types that claim to have it. */
4815 TYPE_ALIGN (void_type_node) = BITS_PER_UNIT;
4816 TYPE_USER_ALIGN (void_type_node) = 0;
4818 null_pointer_node = build_int_2 (0, 0);
4819 TREE_TYPE (null_pointer_node) = build_pointer_type (void_type_node);
4820 layout_type (TREE_TYPE (null_pointer_node));
4822 ptr_type_node = build_pointer_type (void_type_node);
4824 = build_pointer_type (build_type_variant (void_type_node, 1, 0));
4826 float_type_node = make_node (REAL_TYPE);
4827 TYPE_PRECISION (float_type_node) = FLOAT_TYPE_SIZE;
4828 layout_type (float_type_node);
4830 double_type_node = make_node (REAL_TYPE);
4832 TYPE_PRECISION (double_type_node) = FLOAT_TYPE_SIZE;
4834 TYPE_PRECISION (double_type_node) = DOUBLE_TYPE_SIZE;
4835 layout_type (double_type_node);
4837 long_double_type_node = make_node (REAL_TYPE);
4838 TYPE_PRECISION (long_double_type_node) = LONG_DOUBLE_TYPE_SIZE;
4839 layout_type (long_double_type_node);
4841 complex_integer_type_node = make_node (COMPLEX_TYPE);
4842 TREE_TYPE (complex_integer_type_node) = integer_type_node;
4843 layout_type (complex_integer_type_node);
4845 complex_float_type_node = make_node (COMPLEX_TYPE);
4846 TREE_TYPE (complex_float_type_node) = float_type_node;
4847 layout_type (complex_float_type_node);
4849 complex_double_type_node = make_node (COMPLEX_TYPE);
4850 TREE_TYPE (complex_double_type_node) = double_type_node;
4851 layout_type (complex_double_type_node);
4853 complex_long_double_type_node = make_node (COMPLEX_TYPE);
4854 TREE_TYPE (complex_long_double_type_node) = long_double_type_node;
4855 layout_type (complex_long_double_type_node);
4859 BUILD_VA_LIST_TYPE (t);
4861 /* Many back-ends define record types without seting TYPE_NAME.
4862 If we copied the record type here, we'd keep the original
4863 record type without a name. This breaks name mangling. So,
4864 don't copy record types and let c_common_nodes_and_builtins()
4865 declare the type to be __builtin_va_list. */
4866 if (TREE_CODE (t) != RECORD_TYPE)
4867 t = build_type_copy (t);
4869 va_list_type_node = t;
4872 unsigned_V4SI_type_node
4873 = make_vector (V4SImode, unsigned_intSI_type_node, 1);
4874 unsigned_V2SI_type_node
4875 = make_vector (V2SImode, unsigned_intSI_type_node, 1);
4876 unsigned_V4HI_type_node
4877 = make_vector (V4HImode, unsigned_intHI_type_node, 1);
4878 unsigned_V8QI_type_node
4879 = make_vector (V8QImode, unsigned_intQI_type_node, 1);
4880 unsigned_V8HI_type_node
4881 = make_vector (V8HImode, unsigned_intHI_type_node, 1);
4882 unsigned_V16QI_type_node
4883 = make_vector (V16QImode, unsigned_intQI_type_node, 1);
4885 V16SF_type_node = make_vector (V16SFmode, float_type_node, 0);
4886 V4SF_type_node = make_vector (V4SFmode, float_type_node, 0);
4887 V4SI_type_node = make_vector (V4SImode, intSI_type_node, 0);
4888 V2SI_type_node = make_vector (V2SImode, intSI_type_node, 0);
4889 V4HI_type_node = make_vector (V4HImode, intHI_type_node, 0);
4890 V8QI_type_node = make_vector (V8QImode, intQI_type_node, 0);
4891 V8HI_type_node = make_vector (V8HImode, intHI_type_node, 0);
4892 V2SF_type_node = make_vector (V2SFmode, float_type_node, 0);
4893 V16QI_type_node = make_vector (V16QImode, intQI_type_node, 0);
4896 /* Returns a vector tree node given a vector mode, the inner type, and
4900 make_vector (mode, innertype, unsignedp)
4901 enum machine_mode mode;
4907 t = make_node (VECTOR_TYPE);
4908 TREE_TYPE (t) = innertype;
4909 TYPE_MODE (t) = mode;
4910 TREE_UNSIGNED (TREE_TYPE (t)) = unsignedp;
4911 finish_vector_type (t);
4916 /* Given an initializer INIT, return TRUE if INIT is zero or some
4917 aggregate of zeros. Otherwise return FALSE. */
4920 initializer_zerop (init)
4925 switch (TREE_CODE (init))
4928 return integer_zerop (init);
4930 return real_zerop (init)
4931 && ! REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (init));
4933 return integer_zerop (init)
4934 || (real_zerop (init)
4935 && ! REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (TREE_REALPART (init)))
4936 && ! REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (TREE_IMAGPART (init))));
4939 if (AGGREGATE_TYPE_P (TREE_TYPE (init)))
4941 tree aggr_init = TREE_OPERAND (init, 1);
4945 if (! initializer_zerop (TREE_VALUE (aggr_init)))
4947 aggr_init = TREE_CHAIN (aggr_init);