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. */
34 #include "coretypes.h"
47 #include "langhooks.h"
49 /* obstack.[ch] explicitly declined to prototype this. */
50 extern int _obstack_allocated_p PARAMS ((struct obstack *h, PTR obj));
52 #ifdef GATHER_STATISTICS
53 /* Statistics-gathering stuff. */
73 int tree_node_counts[(int) all_kinds];
74 int tree_node_sizes[(int) all_kinds];
76 static const char * const tree_node_kind_names[] = {
92 #endif /* GATHER_STATISTICS */
94 /* Unique id for next decl created. */
95 static int next_decl_uid;
96 /* Unique id for next type created. */
97 static int next_type_uid = 1;
99 /* Since we cannot rehash a type after it is in the table, we have to
100 keep the hash code. */
102 struct type_hash GTY(())
108 /* Initial size of the hash table (rounded to next prime). */
109 #define TYPE_HASH_INITIAL_SIZE 1000
111 /* Now here is the hash table. When recording a type, it is added to
112 the slot whose index is the hash code. Note that the hash table is
113 used for several kinds of types (function types, array types and
114 array index range types, for now). While all these live in the
115 same table, they are completely independent, and the hash code is
116 computed differently for each of these. */
118 static GTY ((if_marked ("type_hash_marked_p"), param_is (struct type_hash)))
119 htab_t type_hash_table;
121 static void set_type_quals PARAMS ((tree, int));
122 static void append_random_chars PARAMS ((char *));
123 static int type_hash_eq PARAMS ((const void *, const void *));
124 static hashval_t type_hash_hash PARAMS ((const void *));
125 static void print_type_hash_statistics PARAMS((void));
126 static void finish_vector_type PARAMS((tree));
127 static tree make_vector PARAMS ((enum machine_mode, tree, int));
128 static int type_hash_marked_p PARAMS ((const void *));
130 tree global_trees[TI_MAX];
131 tree integer_types[itk_none];
138 /* Initialize the hash table of types. */
139 type_hash_table = htab_create (TYPE_HASH_INITIAL_SIZE, type_hash_hash,
144 /* The name of the object as the assembler will see it (but before any
145 translations made by ASM_OUTPUT_LABELREF). Often this is the same
146 as DECL_NAME. It is an IDENTIFIER_NODE. */
148 decl_assembler_name (decl)
151 if (!DECL_ASSEMBLER_NAME_SET_P (decl))
152 (*lang_hooks.set_decl_assembler_name) (decl);
153 return DECL_CHECK (decl)->decl.assembler_name;
156 /* Compute the number of bytes occupied by 'node'. This routine only
157 looks at TREE_CODE and, if the code is TREE_VEC, TREE_VEC_LENGTH. */
162 enum tree_code code = TREE_CODE (node);
164 switch (TREE_CODE_CLASS (code))
166 case 'd': /* A decl node */
167 return sizeof (struct tree_decl);
169 case 't': /* a type node */
170 return sizeof (struct tree_type);
172 case 'b': /* a lexical block node */
173 return sizeof (struct tree_block);
175 case 'r': /* a reference */
176 case 'e': /* an expression */
177 case 's': /* an expression with side effects */
178 case '<': /* a comparison expression */
179 case '1': /* a unary arithmetic expression */
180 case '2': /* a binary arithmetic expression */
181 return (sizeof (struct tree_exp)
182 + TREE_CODE_LENGTH (code) * sizeof (char *) - sizeof (char *));
184 case 'c': /* a constant */
185 /* We can't use TREE_CODE_LENGTH for INTEGER_CST, since the number of
186 words is machine-dependent due to varying length of HOST_WIDE_INT,
187 which might be wider than a pointer (e.g., long long). Similarly
188 for REAL_CST, since the number of words is machine-dependent due
189 to varying size and alignment of `double'. */
190 if (code == INTEGER_CST)
191 return sizeof (struct tree_int_cst);
192 else if (code == REAL_CST)
193 return sizeof (struct tree_real_cst);
195 return (sizeof (struct tree_common)
196 + TREE_CODE_LENGTH (code) * sizeof (char *));
198 case 'x': /* something random, like an identifier. */
201 length = (sizeof (struct tree_common)
202 + TREE_CODE_LENGTH (code) * sizeof (char *));
203 if (code == TREE_VEC)
204 length += TREE_VEC_LENGTH (node) * sizeof (char *) - sizeof (char *);
213 /* Return a newly allocated node of code CODE.
214 For decl and type nodes, some other fields are initialized.
215 The rest of the node is initialized to zero.
217 Achoo! I got a code in the node. */
224 int type = TREE_CODE_CLASS (code);
226 #ifdef GATHER_STATISTICS
229 struct tree_common ttmp;
231 /* We can't allocate a TREE_VEC without knowing how many elements
233 if (code == TREE_VEC)
236 TREE_SET_CODE ((tree)&ttmp, code);
237 length = tree_size ((tree)&ttmp);
239 #ifdef GATHER_STATISTICS
242 case 'd': /* A decl node */
246 case 't': /* a type node */
250 case 'b': /* a lexical block */
254 case 's': /* an expression with side effects */
258 case 'r': /* a reference */
262 case 'e': /* an expression */
263 case '<': /* a comparison expression */
264 case '1': /* a unary arithmetic expression */
265 case '2': /* a binary arithmetic expression */
269 case 'c': /* a constant */
273 case 'x': /* something random, like an identifier. */
274 if (code == IDENTIFIER_NODE)
276 else if (code == TREE_VEC)
286 tree_node_counts[(int) kind]++;
287 tree_node_sizes[(int) kind] += length;
290 t = ggc_alloc_tree (length);
292 memset ((PTR) t, 0, length);
294 TREE_SET_CODE (t, code);
299 TREE_SIDE_EFFECTS (t) = 1;
303 if (code != FUNCTION_DECL)
305 DECL_USER_ALIGN (t) = 0;
306 DECL_IN_SYSTEM_HEADER (t) = in_system_header;
307 DECL_SOURCE_LINE (t) = lineno;
308 DECL_SOURCE_FILE (t) =
309 (input_filename) ? input_filename : "<built-in>";
310 DECL_UID (t) = next_decl_uid++;
312 /* We have not yet computed the alias set for this declaration. */
313 DECL_POINTER_ALIAS_SET (t) = -1;
317 TYPE_UID (t) = next_type_uid++;
318 TYPE_ALIGN (t) = char_type_node ? TYPE_ALIGN (char_type_node) : 0;
319 TYPE_USER_ALIGN (t) = 0;
320 TYPE_MAIN_VARIANT (t) = t;
322 /* Default to no attributes for type, but let target change that. */
323 TYPE_ATTRIBUTES (t) = NULL_TREE;
324 (*targetm.set_default_type_attributes) (t);
326 /* We have not yet computed the alias set for this type. */
327 TYPE_ALIAS_SET (t) = -1;
331 TREE_CONSTANT (t) = 1;
341 case PREDECREMENT_EXPR:
342 case PREINCREMENT_EXPR:
343 case POSTDECREMENT_EXPR:
344 case POSTINCREMENT_EXPR:
345 /* All of these have side-effects, no matter what their
347 TREE_SIDE_EFFECTS (t) = 1;
359 /* Return a new node with the same contents as NODE except that its
360 TREE_CHAIN is zero and it has a fresh uid. */
367 enum tree_code code = TREE_CODE (node);
370 length = tree_size (node);
371 t = ggc_alloc_tree (length);
372 memcpy (t, node, length);
375 TREE_ASM_WRITTEN (t) = 0;
377 if (TREE_CODE_CLASS (code) == 'd')
378 DECL_UID (t) = next_decl_uid++;
379 else if (TREE_CODE_CLASS (code) == 't')
381 TYPE_UID (t) = next_type_uid++;
382 /* The following is so that the debug code for
383 the copy is different from the original type.
384 The two statements usually duplicate each other
385 (because they clear fields of the same union),
386 but the optimizer should catch that. */
387 TYPE_SYMTAB_POINTER (t) = 0;
388 TYPE_SYMTAB_ADDRESS (t) = 0;
394 /* Return a copy of a chain of nodes, chained through the TREE_CHAIN field.
395 For example, this can copy a list made of TREE_LIST nodes. */
407 head = prev = copy_node (list);
408 next = TREE_CHAIN (list);
411 TREE_CHAIN (prev) = copy_node (next);
412 prev = TREE_CHAIN (prev);
413 next = TREE_CHAIN (next);
419 /* Return a newly constructed INTEGER_CST node whose constant value
420 is specified by the two ints LOW and HI.
421 The TREE_TYPE is set to `int'.
423 This function should be used via the `build_int_2' macro. */
426 build_int_2_wide (low, hi)
427 unsigned HOST_WIDE_INT low;
430 tree t = make_node (INTEGER_CST);
432 TREE_INT_CST_LOW (t) = low;
433 TREE_INT_CST_HIGH (t) = hi;
434 TREE_TYPE (t) = integer_type_node;
438 /* Return a new VECTOR_CST node whose type is TYPE and whose values
439 are in a list pointed by VALS. */
442 build_vector (type, vals)
445 tree v = make_node (VECTOR_CST);
446 int over1 = 0, over2 = 0;
449 TREE_VECTOR_CST_ELTS (v) = vals;
450 TREE_TYPE (v) = type;
452 /* Iterate through elements and check for overflow. */
453 for (link = vals; link; link = TREE_CHAIN (link))
455 tree value = TREE_VALUE (link);
457 over1 |= TREE_OVERFLOW (value);
458 over2 |= TREE_CONSTANT_OVERFLOW (value);
461 TREE_OVERFLOW (v) = over1;
462 TREE_CONSTANT_OVERFLOW (v) = over2;
467 /* Return a new REAL_CST node whose type is TYPE and value is D. */
478 /* ??? Used to check for overflow here via CHECK_FLOAT_TYPE.
479 Consider doing it via real_convert now. */
481 v = make_node (REAL_CST);
482 dp = ggc_alloc (sizeof (REAL_VALUE_TYPE));
483 memcpy (dp, &d, sizeof (REAL_VALUE_TYPE));
485 TREE_TYPE (v) = type;
486 TREE_REAL_CST_PTR (v) = dp;
487 TREE_OVERFLOW (v) = TREE_CONSTANT_OVERFLOW (v) = overflow;
491 /* Return a new REAL_CST node whose type is TYPE
492 and whose value is the integer value of the INTEGER_CST node I. */
495 real_value_from_int_cst (type, i)
496 tree type ATTRIBUTE_UNUSED, i;
500 /* Clear all bits of the real value type so that we can later do
501 bitwise comparisons to see if two values are the same. */
502 memset ((char *) &d, 0, sizeof d);
504 if (! TREE_UNSIGNED (TREE_TYPE (i)))
505 REAL_VALUE_FROM_INT (d, TREE_INT_CST_LOW (i), TREE_INT_CST_HIGH (i),
508 REAL_VALUE_FROM_UNSIGNED_INT (d, TREE_INT_CST_LOW (i),
509 TREE_INT_CST_HIGH (i), TYPE_MODE (type));
513 /* Given a tree representing an integer constant I, return a tree
514 representing the same value as a floating-point constant of type TYPE. */
517 build_real_from_int_cst (type, i)
522 int overflow = TREE_OVERFLOW (i);
524 v = build_real (type, real_value_from_int_cst (type, i));
526 TREE_OVERFLOW (v) |= overflow;
527 TREE_CONSTANT_OVERFLOW (v) |= overflow;
531 /* Return a newly constructed STRING_CST node whose value is
532 the LEN characters at STR.
533 The TREE_TYPE is not initialized. */
536 build_string (len, str)
540 tree s = make_node (STRING_CST);
542 TREE_STRING_LENGTH (s) = len;
543 TREE_STRING_POINTER (s) = ggc_alloc_string (str, len);
548 /* Return a newly constructed COMPLEX_CST node whose value is
549 specified by the real and imaginary parts REAL and IMAG.
550 Both REAL and IMAG should be constant nodes. TYPE, if specified,
551 will be the type of the COMPLEX_CST; otherwise a new type will be made. */
554 build_complex (type, real, imag)
558 tree t = make_node (COMPLEX_CST);
560 TREE_REALPART (t) = real;
561 TREE_IMAGPART (t) = imag;
562 TREE_TYPE (t) = type ? type : build_complex_type (TREE_TYPE (real));
563 TREE_OVERFLOW (t) = TREE_OVERFLOW (real) | TREE_OVERFLOW (imag);
564 TREE_CONSTANT_OVERFLOW (t)
565 = TREE_CONSTANT_OVERFLOW (real) | TREE_CONSTANT_OVERFLOW (imag);
569 /* Build a newly constructed TREE_VEC node of length LEN. */
576 int length = (len - 1) * sizeof (tree) + sizeof (struct tree_vec);
578 #ifdef GATHER_STATISTICS
579 tree_node_counts[(int) vec_kind]++;
580 tree_node_sizes[(int) vec_kind] += length;
583 t = ggc_alloc_tree (length);
585 memset ((PTR) t, 0, length);
586 TREE_SET_CODE (t, TREE_VEC);
587 TREE_VEC_LENGTH (t) = len;
592 /* Return 1 if EXPR is the integer constant zero or a complex constant
601 return ((TREE_CODE (expr) == INTEGER_CST
602 && ! TREE_CONSTANT_OVERFLOW (expr)
603 && TREE_INT_CST_LOW (expr) == 0
604 && TREE_INT_CST_HIGH (expr) == 0)
605 || (TREE_CODE (expr) == COMPLEX_CST
606 && integer_zerop (TREE_REALPART (expr))
607 && integer_zerop (TREE_IMAGPART (expr))));
610 /* Return 1 if EXPR is the integer constant one or the corresponding
619 return ((TREE_CODE (expr) == INTEGER_CST
620 && ! TREE_CONSTANT_OVERFLOW (expr)
621 && TREE_INT_CST_LOW (expr) == 1
622 && TREE_INT_CST_HIGH (expr) == 0)
623 || (TREE_CODE (expr) == COMPLEX_CST
624 && integer_onep (TREE_REALPART (expr))
625 && integer_zerop (TREE_IMAGPART (expr))));
628 /* Return 1 if EXPR is an integer containing all 1's in as much precision as
629 it contains. Likewise for the corresponding complex constant. */
632 integer_all_onesp (expr)
640 if (TREE_CODE (expr) == COMPLEX_CST
641 && integer_all_onesp (TREE_REALPART (expr))
642 && integer_zerop (TREE_IMAGPART (expr)))
645 else if (TREE_CODE (expr) != INTEGER_CST
646 || TREE_CONSTANT_OVERFLOW (expr))
649 uns = TREE_UNSIGNED (TREE_TYPE (expr));
651 return (TREE_INT_CST_LOW (expr) == ~(unsigned HOST_WIDE_INT) 0
652 && TREE_INT_CST_HIGH (expr) == -1);
654 /* Note that using TYPE_PRECISION here is wrong. We care about the
655 actual bits, not the (arbitrary) range of the type. */
656 prec = GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (expr)));
657 if (prec >= HOST_BITS_PER_WIDE_INT)
659 HOST_WIDE_INT high_value;
662 shift_amount = prec - HOST_BITS_PER_WIDE_INT;
664 if (shift_amount > HOST_BITS_PER_WIDE_INT)
665 /* Can not handle precisions greater than twice the host int size. */
667 else if (shift_amount == HOST_BITS_PER_WIDE_INT)
668 /* Shifting by the host word size is undefined according to the ANSI
669 standard, so we must handle this as a special case. */
672 high_value = ((HOST_WIDE_INT) 1 << shift_amount) - 1;
674 return (TREE_INT_CST_LOW (expr) == ~(unsigned HOST_WIDE_INT) 0
675 && TREE_INT_CST_HIGH (expr) == high_value);
678 return TREE_INT_CST_LOW (expr) == ((unsigned HOST_WIDE_INT) 1 << prec) - 1;
681 /* Return 1 if EXPR is an integer constant that is a power of 2 (i.e., has only
689 HOST_WIDE_INT high, low;
693 if (TREE_CODE (expr) == COMPLEX_CST
694 && integer_pow2p (TREE_REALPART (expr))
695 && integer_zerop (TREE_IMAGPART (expr)))
698 if (TREE_CODE (expr) != INTEGER_CST || TREE_CONSTANT_OVERFLOW (expr))
701 prec = (POINTER_TYPE_P (TREE_TYPE (expr))
702 ? POINTER_SIZE : TYPE_PRECISION (TREE_TYPE (expr)));
703 high = TREE_INT_CST_HIGH (expr);
704 low = TREE_INT_CST_LOW (expr);
706 /* First clear all bits that are beyond the type's precision in case
707 we've been sign extended. */
709 if (prec == 2 * HOST_BITS_PER_WIDE_INT)
711 else if (prec > HOST_BITS_PER_WIDE_INT)
712 high &= ~((HOST_WIDE_INT) (-1) << (prec - HOST_BITS_PER_WIDE_INT));
716 if (prec < HOST_BITS_PER_WIDE_INT)
717 low &= ~((HOST_WIDE_INT) (-1) << prec);
720 if (high == 0 && low == 0)
723 return ((high == 0 && (low & (low - 1)) == 0)
724 || (low == 0 && (high & (high - 1)) == 0));
727 /* Return 1 if EXPR is an integer constant other than zero or a
728 complex constant other than zero. */
731 integer_nonzerop (expr)
736 return ((TREE_CODE (expr) == INTEGER_CST
737 && ! TREE_CONSTANT_OVERFLOW (expr)
738 && (TREE_INT_CST_LOW (expr) != 0
739 || TREE_INT_CST_HIGH (expr) != 0))
740 || (TREE_CODE (expr) == COMPLEX_CST
741 && (integer_nonzerop (TREE_REALPART (expr))
742 || integer_nonzerop (TREE_IMAGPART (expr)))));
745 /* Return the power of two represented by a tree node known to be a
753 HOST_WIDE_INT high, low;
757 if (TREE_CODE (expr) == COMPLEX_CST)
758 return tree_log2 (TREE_REALPART (expr));
760 prec = (POINTER_TYPE_P (TREE_TYPE (expr))
761 ? POINTER_SIZE : TYPE_PRECISION (TREE_TYPE (expr)));
763 high = TREE_INT_CST_HIGH (expr);
764 low = TREE_INT_CST_LOW (expr);
766 /* First clear all bits that are beyond the type's precision in case
767 we've been sign extended. */
769 if (prec == 2 * HOST_BITS_PER_WIDE_INT)
771 else if (prec > HOST_BITS_PER_WIDE_INT)
772 high &= ~((HOST_WIDE_INT) (-1) << (prec - HOST_BITS_PER_WIDE_INT));
776 if (prec < HOST_BITS_PER_WIDE_INT)
777 low &= ~((HOST_WIDE_INT) (-1) << prec);
780 return (high != 0 ? HOST_BITS_PER_WIDE_INT + exact_log2 (high)
784 /* Similar, but return the largest integer Y such that 2 ** Y is less
785 than or equal to EXPR. */
788 tree_floor_log2 (expr)
792 HOST_WIDE_INT high, low;
796 if (TREE_CODE (expr) == COMPLEX_CST)
797 return tree_log2 (TREE_REALPART (expr));
799 prec = (POINTER_TYPE_P (TREE_TYPE (expr))
800 ? POINTER_SIZE : TYPE_PRECISION (TREE_TYPE (expr)));
802 high = TREE_INT_CST_HIGH (expr);
803 low = TREE_INT_CST_LOW (expr);
805 /* First clear all bits that are beyond the type's precision in case
806 we've been sign extended. Ignore if type's precision hasn't been set
807 since what we are doing is setting it. */
809 if (prec == 2 * HOST_BITS_PER_WIDE_INT || prec == 0)
811 else if (prec > HOST_BITS_PER_WIDE_INT)
812 high &= ~((HOST_WIDE_INT) (-1) << (prec - HOST_BITS_PER_WIDE_INT));
816 if (prec < HOST_BITS_PER_WIDE_INT)
817 low &= ~((HOST_WIDE_INT) (-1) << prec);
820 return (high != 0 ? HOST_BITS_PER_WIDE_INT + floor_log2 (high)
824 /* Return 1 if EXPR is the real constant zero. */
832 return ((TREE_CODE (expr) == REAL_CST
833 && ! TREE_CONSTANT_OVERFLOW (expr)
834 && REAL_VALUES_EQUAL (TREE_REAL_CST (expr), dconst0))
835 || (TREE_CODE (expr) == COMPLEX_CST
836 && real_zerop (TREE_REALPART (expr))
837 && real_zerop (TREE_IMAGPART (expr))));
840 /* Return 1 if EXPR is the real constant one in real or complex form. */
848 return ((TREE_CODE (expr) == REAL_CST
849 && ! TREE_CONSTANT_OVERFLOW (expr)
850 && REAL_VALUES_EQUAL (TREE_REAL_CST (expr), dconst1))
851 || (TREE_CODE (expr) == COMPLEX_CST
852 && real_onep (TREE_REALPART (expr))
853 && real_zerop (TREE_IMAGPART (expr))));
856 /* Return 1 if EXPR is the real constant two. */
864 return ((TREE_CODE (expr) == REAL_CST
865 && ! TREE_CONSTANT_OVERFLOW (expr)
866 && REAL_VALUES_EQUAL (TREE_REAL_CST (expr), dconst2))
867 || (TREE_CODE (expr) == COMPLEX_CST
868 && real_twop (TREE_REALPART (expr))
869 && real_zerop (TREE_IMAGPART (expr))));
872 /* Return 1 if EXPR is the real constant minus one. */
875 real_minus_onep (expr)
880 return ((TREE_CODE (expr) == REAL_CST
881 && ! TREE_CONSTANT_OVERFLOW (expr)
882 && REAL_VALUES_EQUAL (TREE_REAL_CST (expr), dconstm1))
883 || (TREE_CODE (expr) == COMPLEX_CST
884 && real_minus_onep (TREE_REALPART (expr))
885 && real_zerop (TREE_IMAGPART (expr))));
888 /* Nonzero if EXP is a constant or a cast of a constant. */
891 really_constant_p (exp)
894 /* This is not quite the same as STRIP_NOPS. It does more. */
895 while (TREE_CODE (exp) == NOP_EXPR
896 || TREE_CODE (exp) == CONVERT_EXPR
897 || TREE_CODE (exp) == NON_LVALUE_EXPR)
898 exp = TREE_OPERAND (exp, 0);
899 return TREE_CONSTANT (exp);
902 /* Return first list element whose TREE_VALUE is ELEM.
903 Return 0 if ELEM is not in LIST. */
906 value_member (elem, list)
911 if (elem == TREE_VALUE (list))
913 list = TREE_CHAIN (list);
918 /* Return first list element whose TREE_PURPOSE is ELEM.
919 Return 0 if ELEM is not in LIST. */
922 purpose_member (elem, list)
927 if (elem == TREE_PURPOSE (list))
929 list = TREE_CHAIN (list);
934 /* Return first list element whose BINFO_TYPE is ELEM.
935 Return 0 if ELEM is not in LIST. */
938 binfo_member (elem, list)
943 if (elem == BINFO_TYPE (list))
945 list = TREE_CHAIN (list);
950 /* Return nonzero if ELEM is part of the chain CHAIN. */
953 chain_member (elem, chain)
960 chain = TREE_CHAIN (chain);
966 /* Return the length of a chain of nodes chained through TREE_CHAIN.
967 We expect a null pointer to mark the end of the chain.
968 This is the Lisp primitive `length'. */
977 for (tail = t; tail; tail = TREE_CHAIN (tail))
983 /* Returns the number of FIELD_DECLs in TYPE. */
989 tree t = TYPE_FIELDS (type);
992 for (; t; t = TREE_CHAIN (t))
993 if (TREE_CODE (t) == FIELD_DECL)
999 /* Concatenate two chains of nodes (chained through TREE_CHAIN)
1000 by modifying the last node in chain 1 to point to chain 2.
1001 This is the Lisp primitive `nconc'. */
1011 #ifdef ENABLE_TREE_CHECKING
1015 for (t1 = op1; TREE_CHAIN (t1); t1 = TREE_CHAIN (t1))
1017 TREE_CHAIN (t1) = op2;
1018 #ifdef ENABLE_TREE_CHECKING
1019 for (t2 = op2; t2; t2 = TREE_CHAIN (t2))
1021 abort (); /* Circularity created. */
1029 /* Return the last node in a chain of nodes (chained through TREE_CHAIN). */
1037 while ((next = TREE_CHAIN (chain)))
1042 /* Reverse the order of elements in the chain T,
1043 and return the new head of the chain (old last element). */
1049 tree prev = 0, decl, next;
1050 for (decl = t; decl; decl = next)
1052 next = TREE_CHAIN (decl);
1053 TREE_CHAIN (decl) = prev;
1059 /* Return a newly created TREE_LIST node whose
1060 purpose and value fields are PARM and VALUE. */
1063 build_tree_list (parm, value)
1066 tree t = make_node (TREE_LIST);
1067 TREE_PURPOSE (t) = parm;
1068 TREE_VALUE (t) = value;
1072 /* Return a newly created TREE_LIST node whose
1073 purpose and value fields are PARM and VALUE
1074 and whose TREE_CHAIN is CHAIN. */
1077 tree_cons (purpose, value, chain)
1078 tree purpose, value, chain;
1082 node = ggc_alloc_tree (sizeof (struct tree_list));
1084 memset (node, 0, sizeof (struct tree_common));
1086 #ifdef GATHER_STATISTICS
1087 tree_node_counts[(int) x_kind]++;
1088 tree_node_sizes[(int) x_kind] += sizeof (struct tree_list);
1091 TREE_SET_CODE (node, TREE_LIST);
1092 TREE_CHAIN (node) = chain;
1093 TREE_PURPOSE (node) = purpose;
1094 TREE_VALUE (node) = value;
1099 /* Return the size nominally occupied by an object of type TYPE
1100 when it resides in memory. The value is measured in units of bytes,
1101 and its data type is that normally used for type sizes
1102 (which is the first type created by make_signed_type or
1103 make_unsigned_type). */
1106 size_in_bytes (type)
1111 if (type == error_mark_node)
1112 return integer_zero_node;
1114 type = TYPE_MAIN_VARIANT (type);
1115 t = TYPE_SIZE_UNIT (type);
1119 (*lang_hooks.types.incomplete_type_error) (NULL_TREE, type);
1120 return size_zero_node;
1123 if (TREE_CODE (t) == INTEGER_CST)
1124 force_fit_type (t, 0);
1129 /* Return the size of TYPE (in bytes) as a wide integer
1130 or return -1 if the size can vary or is larger than an integer. */
1133 int_size_in_bytes (type)
1138 if (type == error_mark_node)
1141 type = TYPE_MAIN_VARIANT (type);
1142 t = TYPE_SIZE_UNIT (type);
1144 || TREE_CODE (t) != INTEGER_CST
1145 || TREE_OVERFLOW (t)
1146 || TREE_INT_CST_HIGH (t) != 0
1147 /* If the result would appear negative, it's too big to represent. */
1148 || (HOST_WIDE_INT) TREE_INT_CST_LOW (t) < 0)
1151 return TREE_INT_CST_LOW (t);
1154 /* Return the bit position of FIELD, in bits from the start of the record.
1155 This is a tree of type bitsizetype. */
1158 bit_position (field)
1162 return bit_from_pos (DECL_FIELD_OFFSET (field),
1163 DECL_FIELD_BIT_OFFSET (field));
1166 /* Likewise, but return as an integer. Abort if it cannot be represented
1167 in that way (since it could be a signed value, we don't have the option
1168 of returning -1 like int_size_in_byte can. */
1171 int_bit_position (field)
1174 return tree_low_cst (bit_position (field), 0);
1177 /* Return the byte position of FIELD, in bytes from the start of the record.
1178 This is a tree of type sizetype. */
1181 byte_position (field)
1184 return byte_from_pos (DECL_FIELD_OFFSET (field),
1185 DECL_FIELD_BIT_OFFSET (field));
1188 /* Likewise, but return as an integer. Abort if it cannot be represented
1189 in that way (since it could be a signed value, we don't have the option
1190 of returning -1 like int_size_in_byte can. */
1193 int_byte_position (field)
1196 return tree_low_cst (byte_position (field), 0);
1199 /* Return the strictest alignment, in bits, that T is known to have. */
1205 unsigned int align0, align1;
1207 switch (TREE_CODE (t))
1209 case NOP_EXPR: case CONVERT_EXPR: case NON_LVALUE_EXPR:
1210 /* If we have conversions, we know that the alignment of the
1211 object must meet each of the alignments of the types. */
1212 align0 = expr_align (TREE_OPERAND (t, 0));
1213 align1 = TYPE_ALIGN (TREE_TYPE (t));
1214 return MAX (align0, align1);
1216 case SAVE_EXPR: case COMPOUND_EXPR: case MODIFY_EXPR:
1217 case INIT_EXPR: case TARGET_EXPR: case WITH_CLEANUP_EXPR:
1218 case WITH_RECORD_EXPR: case CLEANUP_POINT_EXPR: case UNSAVE_EXPR:
1219 /* These don't change the alignment of an object. */
1220 return expr_align (TREE_OPERAND (t, 0));
1223 /* The best we can do is say that the alignment is the least aligned
1225 align0 = expr_align (TREE_OPERAND (t, 1));
1226 align1 = expr_align (TREE_OPERAND (t, 2));
1227 return MIN (align0, align1);
1229 case LABEL_DECL: case CONST_DECL:
1230 case VAR_DECL: case PARM_DECL: case RESULT_DECL:
1231 if (DECL_ALIGN (t) != 0)
1232 return DECL_ALIGN (t);
1236 return FUNCTION_BOUNDARY;
1242 /* Otherwise take the alignment from that of the type. */
1243 return TYPE_ALIGN (TREE_TYPE (t));
1246 /* Return, as a tree node, the number of elements for TYPE (which is an
1247 ARRAY_TYPE) minus one. This counts only elements of the top array. */
1250 array_type_nelts (type)
1253 tree index_type, min, max;
1255 /* If they did it with unspecified bounds, then we should have already
1256 given an error about it before we got here. */
1257 if (! TYPE_DOMAIN (type))
1258 return error_mark_node;
1260 index_type = TYPE_DOMAIN (type);
1261 min = TYPE_MIN_VALUE (index_type);
1262 max = TYPE_MAX_VALUE (index_type);
1264 return (integer_zerop (min)
1266 : fold (build (MINUS_EXPR, TREE_TYPE (max), max, min)));
1269 /* Return nonzero if arg is static -- a reference to an object in
1270 static storage. This is not the same as the C meaning of `static'. */
1276 switch (TREE_CODE (arg))
1279 /* Nested functions aren't static, since taking their address
1280 involves a trampoline. */
1281 return ((decl_function_context (arg) == 0 || DECL_NO_STATIC_CHAIN (arg))
1282 && ! DECL_NON_ADDR_CONST_P (arg));
1285 return ((TREE_STATIC (arg) || DECL_EXTERNAL (arg))
1286 && ! DECL_THREAD_LOCAL (arg)
1287 && ! DECL_NON_ADDR_CONST_P (arg));
1290 return TREE_STATIC (arg);
1296 /* If we are referencing a bitfield, we can't evaluate an
1297 ADDR_EXPR at compile time and so it isn't a constant. */
1299 return (! DECL_BIT_FIELD (TREE_OPERAND (arg, 1))
1300 && staticp (TREE_OPERAND (arg, 0)));
1306 /* This case is technically correct, but results in setting
1307 TREE_CONSTANT on ADDR_EXPRs that cannot be evaluated at
1310 return TREE_CONSTANT (TREE_OPERAND (arg, 0));
1314 case ARRAY_RANGE_REF:
1315 if (TREE_CODE (TYPE_SIZE (TREE_TYPE (arg))) == INTEGER_CST
1316 && TREE_CODE (TREE_OPERAND (arg, 1)) == INTEGER_CST)
1317 return staticp (TREE_OPERAND (arg, 0));
1320 if ((unsigned int) TREE_CODE (arg)
1321 >= (unsigned int) LAST_AND_UNUSED_TREE_CODE)
1322 return (*lang_hooks.staticp) (arg);
1328 /* Wrap a SAVE_EXPR around EXPR, if appropriate.
1329 Do this to any expression which may be used in more than one place,
1330 but must be evaluated only once.
1332 Normally, expand_expr would reevaluate the expression each time.
1333 Calling save_expr produces something that is evaluated and recorded
1334 the first time expand_expr is called on it. Subsequent calls to
1335 expand_expr just reuse the recorded value.
1337 The call to expand_expr that generates code that actually computes
1338 the value is the first call *at compile time*. Subsequent calls
1339 *at compile time* generate code to use the saved value.
1340 This produces correct result provided that *at run time* control
1341 always flows through the insns made by the first expand_expr
1342 before reaching the other places where the save_expr was evaluated.
1343 You, the caller of save_expr, must make sure this is so.
1345 Constants, and certain read-only nodes, are returned with no
1346 SAVE_EXPR because that is safe. Expressions containing placeholders
1347 are not touched; see tree.def for an explanation of what these
1354 tree t = fold (expr);
1357 /* We don't care about whether this can be used as an lvalue in this
1359 while (TREE_CODE (t) == NON_LVALUE_EXPR)
1360 t = TREE_OPERAND (t, 0);
1362 /* If we have simple operations applied to a SAVE_EXPR or to a SAVE_EXPR and
1363 a constant, it will be more efficient to not make another SAVE_EXPR since
1364 it will allow better simplification and GCSE will be able to merge the
1365 computations if they actualy occur. */
1367 (TREE_CODE_CLASS (TREE_CODE (inner)) == '1'
1368 || (TREE_CODE_CLASS (TREE_CODE (inner)) == '2'
1369 && TREE_CONSTANT (TREE_OPERAND (inner, 1))));
1370 inner = TREE_OPERAND (inner, 0))
1373 /* If the tree evaluates to a constant, then we don't want to hide that
1374 fact (i.e. this allows further folding, and direct checks for constants).
1375 However, a read-only object that has side effects cannot be bypassed.
1376 Since it is no problem to reevaluate literals, we just return the
1378 if (TREE_CONSTANT (inner)
1379 || (TREE_READONLY (inner) && ! TREE_SIDE_EFFECTS (inner))
1380 || TREE_CODE (inner) == SAVE_EXPR || TREE_CODE (inner) == ERROR_MARK)
1383 /* If T contains a PLACEHOLDER_EXPR, we must evaluate it each time, since
1384 it means that the size or offset of some field of an object depends on
1385 the value within another field.
1387 Note that it must not be the case that T contains both a PLACEHOLDER_EXPR
1388 and some variable since it would then need to be both evaluated once and
1389 evaluated more than once. Front-ends must assure this case cannot
1390 happen by surrounding any such subexpressions in their own SAVE_EXPR
1391 and forcing evaluation at the proper time. */
1392 if (contains_placeholder_p (t))
1395 t = build (SAVE_EXPR, TREE_TYPE (expr), t, current_function_decl, NULL_TREE);
1397 /* This expression might be placed ahead of a jump to ensure that the
1398 value was computed on both sides of the jump. So make sure it isn't
1399 eliminated as dead. */
1400 TREE_SIDE_EFFECTS (t) = 1;
1401 TREE_READONLY (t) = 1;
1405 /* Arrange for an expression to be expanded multiple independent
1406 times. This is useful for cleanup actions, as the backend can
1407 expand them multiple times in different places. */
1415 /* If this is already protected, no sense in protecting it again. */
1416 if (TREE_CODE (expr) == UNSAVE_EXPR)
1419 t = build1 (UNSAVE_EXPR, TREE_TYPE (expr), expr);
1420 TREE_SIDE_EFFECTS (t) = TREE_SIDE_EFFECTS (expr);
1424 /* Returns the index of the first non-tree operand for CODE, or the number
1425 of operands if all are trees. */
1429 enum tree_code code;
1435 case GOTO_SUBROUTINE_EXPR:
1438 case WITH_CLEANUP_EXPR:
1440 case METHOD_CALL_EXPR:
1443 return TREE_CODE_LENGTH (code);
1447 /* Return which tree structure is used by T. */
1449 enum tree_node_structure_enum
1450 tree_node_structure (t)
1453 enum tree_code code = TREE_CODE (t);
1455 switch (TREE_CODE_CLASS (code))
1457 case 'd': return TS_DECL;
1458 case 't': return TS_TYPE;
1459 case 'b': return TS_BLOCK;
1460 case 'r': case '<': case '1': case '2': case 'e': case 's':
1462 default: /* 'c' and 'x' */
1468 case INTEGER_CST: return TS_INT_CST;
1469 case REAL_CST: return TS_REAL_CST;
1470 case COMPLEX_CST: return TS_COMPLEX;
1471 case VECTOR_CST: return TS_VECTOR;
1472 case STRING_CST: return TS_STRING;
1474 case ERROR_MARK: return TS_COMMON;
1475 case IDENTIFIER_NODE: return TS_IDENTIFIER;
1476 case TREE_LIST: return TS_LIST;
1477 case TREE_VEC: return TS_VEC;
1478 case PLACEHOLDER_EXPR: return TS_COMMON;
1485 /* Perform any modifications to EXPR required when it is unsaved. Does
1486 not recurse into EXPR's subtrees. */
1489 unsave_expr_1 (expr)
1492 switch (TREE_CODE (expr))
1495 if (! SAVE_EXPR_PERSISTENT_P (expr))
1496 SAVE_EXPR_RTL (expr) = 0;
1500 /* Don't mess with a TARGET_EXPR that hasn't been expanded.
1501 It's OK for this to happen if it was part of a subtree that
1502 isn't immediately expanded, such as operand 2 of another
1504 if (TREE_OPERAND (expr, 1))
1507 TREE_OPERAND (expr, 1) = TREE_OPERAND (expr, 3);
1508 TREE_OPERAND (expr, 3) = NULL_TREE;
1512 /* I don't yet know how to emit a sequence multiple times. */
1513 if (RTL_EXPR_SEQUENCE (expr) != 0)
1522 /* Default lang hook for "unsave_expr_now". */
1525 lhd_unsave_expr_now (expr)
1528 enum tree_code code;
1530 /* There's nothing to do for NULL_TREE. */
1534 unsave_expr_1 (expr);
1536 code = TREE_CODE (expr);
1537 switch (TREE_CODE_CLASS (code))
1539 case 'c': /* a constant */
1540 case 't': /* a type node */
1541 case 'd': /* A decl node */
1542 case 'b': /* A block node */
1545 case 'x': /* miscellaneous: e.g., identifier, TREE_LIST or ERROR_MARK. */
1546 if (code == TREE_LIST)
1548 lhd_unsave_expr_now (TREE_VALUE (expr));
1549 lhd_unsave_expr_now (TREE_CHAIN (expr));
1553 case 'e': /* an expression */
1554 case 'r': /* a reference */
1555 case 's': /* an expression with side effects */
1556 case '<': /* a comparison expression */
1557 case '2': /* a binary arithmetic expression */
1558 case '1': /* a unary arithmetic expression */
1562 for (i = first_rtl_op (code) - 1; i >= 0; i--)
1563 lhd_unsave_expr_now (TREE_OPERAND (expr, i));
1574 /* Return 0 if it is safe to evaluate EXPR multiple times,
1575 return 1 if it is safe if EXPR is unsaved afterward, or
1576 return 2 if it is completely unsafe.
1578 This assumes that CALL_EXPRs and TARGET_EXPRs are never replicated in
1579 an expression tree, so that it safe to unsave them and the surrounding
1580 context will be correct.
1582 SAVE_EXPRs basically *only* appear replicated in an expression tree,
1583 occasionally across the whole of a function. It is therefore only
1584 safe to unsave a SAVE_EXPR if you know that all occurrences appear
1585 below the UNSAVE_EXPR.
1587 RTL_EXPRs consume their rtl during evaluation. It is therefore
1588 never possible to unsave them. */
1591 unsafe_for_reeval (expr)
1595 enum tree_code code;
1600 if (expr == NULL_TREE)
1603 code = TREE_CODE (expr);
1604 first_rtl = first_rtl_op (code);
1613 for (exp = expr; exp != 0; exp = TREE_CHAIN (exp))
1615 tmp = unsafe_for_reeval (TREE_VALUE (exp));
1616 unsafeness = MAX (tmp, unsafeness);
1622 tmp2 = unsafe_for_reeval (TREE_OPERAND (expr, 0));
1623 tmp = unsafe_for_reeval (TREE_OPERAND (expr, 1));
1624 return MAX (MAX (tmp, 1), tmp2);
1631 tmp = (*lang_hooks.unsafe_for_reeval) (expr);
1637 switch (TREE_CODE_CLASS (code))
1639 case 'c': /* a constant */
1640 case 't': /* a type node */
1641 case 'x': /* something random, like an identifier or an ERROR_MARK. */
1642 case 'd': /* A decl node */
1643 case 'b': /* A block node */
1646 case 'e': /* an expression */
1647 case 'r': /* a reference */
1648 case 's': /* an expression with side effects */
1649 case '<': /* a comparison expression */
1650 case '2': /* a binary arithmetic expression */
1651 case '1': /* a unary arithmetic expression */
1652 for (i = first_rtl - 1; i >= 0; i--)
1654 tmp = unsafe_for_reeval (TREE_OPERAND (expr, i));
1655 unsafeness = MAX (tmp, unsafeness);
1665 /* Return 1 if EXP contains a PLACEHOLDER_EXPR; i.e., if it represents a size
1666 or offset that depends on a field within a record. */
1669 contains_placeholder_p (exp)
1672 enum tree_code code;
1678 /* If we have a WITH_RECORD_EXPR, it "cancels" any PLACEHOLDER_EXPR
1679 in it since it is supplying a value for it. */
1680 code = TREE_CODE (exp);
1681 if (code == WITH_RECORD_EXPR)
1683 else if (code == PLACEHOLDER_EXPR)
1686 switch (TREE_CODE_CLASS (code))
1689 /* Don't look at any PLACEHOLDER_EXPRs that might be in index or bit
1690 position computations since they will be converted into a
1691 WITH_RECORD_EXPR involving the reference, which will assume
1692 here will be valid. */
1693 return contains_placeholder_p (TREE_OPERAND (exp, 0));
1696 if (code == TREE_LIST)
1697 return (contains_placeholder_p (TREE_VALUE (exp))
1698 || (TREE_CHAIN (exp) != 0
1699 && contains_placeholder_p (TREE_CHAIN (exp))));
1708 /* Ignoring the first operand isn't quite right, but works best. */
1709 return contains_placeholder_p (TREE_OPERAND (exp, 1));
1716 return (contains_placeholder_p (TREE_OPERAND (exp, 0))
1717 || contains_placeholder_p (TREE_OPERAND (exp, 1))
1718 || contains_placeholder_p (TREE_OPERAND (exp, 2)));
1721 /* If we already know this doesn't have a placeholder, don't
1723 if (SAVE_EXPR_NOPLACEHOLDER (exp) || SAVE_EXPR_RTL (exp) != 0)
1726 SAVE_EXPR_NOPLACEHOLDER (exp) = 1;
1727 result = contains_placeholder_p (TREE_OPERAND (exp, 0));
1729 SAVE_EXPR_NOPLACEHOLDER (exp) = 0;
1734 return (TREE_OPERAND (exp, 1) != 0
1735 && contains_placeholder_p (TREE_OPERAND (exp, 1)));
1741 switch (TREE_CODE_LENGTH (code))
1744 return contains_placeholder_p (TREE_OPERAND (exp, 0));
1746 return (contains_placeholder_p (TREE_OPERAND (exp, 0))
1747 || contains_placeholder_p (TREE_OPERAND (exp, 1)));
1758 /* Return 1 if EXP contains any expressions that produce cleanups for an
1759 outer scope to deal with. Used by fold. */
1767 if (! TREE_SIDE_EFFECTS (exp))
1770 switch (TREE_CODE (exp))
1773 case GOTO_SUBROUTINE_EXPR:
1774 case WITH_CLEANUP_EXPR:
1777 case CLEANUP_POINT_EXPR:
1781 for (exp = TREE_OPERAND (exp, 1); exp; exp = TREE_CHAIN (exp))
1783 cmp = has_cleanups (TREE_VALUE (exp));
1793 /* This general rule works for most tree codes. All exceptions should be
1794 handled above. If this is a language-specific tree code, we can't
1795 trust what might be in the operand, so say we don't know
1797 if ((int) TREE_CODE (exp) >= (int) LAST_AND_UNUSED_TREE_CODE)
1800 nops = first_rtl_op (TREE_CODE (exp));
1801 for (i = 0; i < nops; i++)
1802 if (TREE_OPERAND (exp, i) != 0)
1804 int type = TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp, i)));
1805 if (type == 'e' || type == '<' || type == '1' || type == '2'
1806 || type == 'r' || type == 's')
1808 cmp = has_cleanups (TREE_OPERAND (exp, i));
1817 /* Given a tree EXP, a FIELD_DECL F, and a replacement value R,
1818 return a tree with all occurrences of references to F in a
1819 PLACEHOLDER_EXPR replaced by R. Note that we assume here that EXP
1820 contains only arithmetic expressions or a CALL_EXPR with a
1821 PLACEHOLDER_EXPR occurring only in its arglist. */
1824 substitute_in_expr (exp, f, r)
1829 enum tree_code code = TREE_CODE (exp);
1834 switch (TREE_CODE_CLASS (code))
1841 if (code == PLACEHOLDER_EXPR)
1843 else if (code == TREE_LIST)
1845 op0 = (TREE_CHAIN (exp) == 0
1846 ? 0 : substitute_in_expr (TREE_CHAIN (exp), f, r));
1847 op1 = substitute_in_expr (TREE_VALUE (exp), f, r);
1848 if (op0 == TREE_CHAIN (exp) && op1 == TREE_VALUE (exp))
1851 return tree_cons (TREE_PURPOSE (exp), op1, op0);
1860 switch (TREE_CODE_LENGTH (code))
1863 op0 = substitute_in_expr (TREE_OPERAND (exp, 0), f, r);
1864 if (op0 == TREE_OPERAND (exp, 0))
1867 if (code == NON_LVALUE_EXPR)
1870 new = fold (build1 (code, TREE_TYPE (exp), op0));
1874 /* An RTL_EXPR cannot contain a PLACEHOLDER_EXPR; a CONSTRUCTOR
1875 could, but we don't support it. */
1876 if (code == RTL_EXPR)
1878 else if (code == CONSTRUCTOR)
1881 op0 = substitute_in_expr (TREE_OPERAND (exp, 0), f, r);
1882 op1 = substitute_in_expr (TREE_OPERAND (exp, 1), f, r);
1883 if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1))
1886 new = fold (build (code, TREE_TYPE (exp), op0, op1));
1890 /* It cannot be that anything inside a SAVE_EXPR contains a
1891 PLACEHOLDER_EXPR. */
1892 if (code == SAVE_EXPR)
1895 else if (code == CALL_EXPR)
1897 op1 = substitute_in_expr (TREE_OPERAND (exp, 1), f, r);
1898 if (op1 == TREE_OPERAND (exp, 1))
1901 return build (code, TREE_TYPE (exp),
1902 TREE_OPERAND (exp, 0), op1, NULL_TREE);
1905 else if (code != COND_EXPR)
1908 op0 = substitute_in_expr (TREE_OPERAND (exp, 0), f, r);
1909 op1 = substitute_in_expr (TREE_OPERAND (exp, 1), f, r);
1910 op2 = substitute_in_expr (TREE_OPERAND (exp, 2), f, r);
1911 if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1)
1912 && op2 == TREE_OPERAND (exp, 2))
1915 new = fold (build (code, TREE_TYPE (exp), op0, op1, op2));
1928 /* If this expression is getting a value from a PLACEHOLDER_EXPR
1929 and it is the right field, replace it with R. */
1930 for (inner = TREE_OPERAND (exp, 0);
1931 TREE_CODE_CLASS (TREE_CODE (inner)) == 'r';
1932 inner = TREE_OPERAND (inner, 0))
1934 if (TREE_CODE (inner) == PLACEHOLDER_EXPR
1935 && TREE_OPERAND (exp, 1) == f)
1938 /* If this expression hasn't been completed let, leave it
1940 if (TREE_CODE (inner) == PLACEHOLDER_EXPR
1941 && TREE_TYPE (inner) == 0)
1944 op0 = substitute_in_expr (TREE_OPERAND (exp, 0), f, r);
1945 if (op0 == TREE_OPERAND (exp, 0))
1948 new = fold (build (code, TREE_TYPE (exp), op0,
1949 TREE_OPERAND (exp, 1)));
1953 op0 = substitute_in_expr (TREE_OPERAND (exp, 0), f, r);
1954 op1 = substitute_in_expr (TREE_OPERAND (exp, 1), f, r);
1955 op2 = substitute_in_expr (TREE_OPERAND (exp, 2), f, r);
1956 if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1)
1957 && op2 == TREE_OPERAND (exp, 2))
1960 new = fold (build (code, TREE_TYPE (exp), op0, op1, op2));
1965 op0 = substitute_in_expr (TREE_OPERAND (exp, 0), f, r);
1966 if (op0 == TREE_OPERAND (exp, 0))
1969 new = fold (build1 (code, TREE_TYPE (exp), op0));
1981 TREE_READONLY (new) = TREE_READONLY (exp);
1985 /* Stabilize a reference so that we can use it any number of times
1986 without causing its operands to be evaluated more than once.
1987 Returns the stabilized reference. This works by means of save_expr,
1988 so see the caveats in the comments about save_expr.
1990 Also allows conversion expressions whose operands are references.
1991 Any other kind of expression is returned unchanged. */
1994 stabilize_reference (ref)
1998 enum tree_code code = TREE_CODE (ref);
2005 /* No action is needed in this case. */
2011 case FIX_TRUNC_EXPR:
2012 case FIX_FLOOR_EXPR:
2013 case FIX_ROUND_EXPR:
2015 result = build_nt (code, stabilize_reference (TREE_OPERAND (ref, 0)));
2019 result = build_nt (INDIRECT_REF,
2020 stabilize_reference_1 (TREE_OPERAND (ref, 0)));
2024 result = build_nt (COMPONENT_REF,
2025 stabilize_reference (TREE_OPERAND (ref, 0)),
2026 TREE_OPERAND (ref, 1));
2030 result = build_nt (BIT_FIELD_REF,
2031 stabilize_reference (TREE_OPERAND (ref, 0)),
2032 stabilize_reference_1 (TREE_OPERAND (ref, 1)),
2033 stabilize_reference_1 (TREE_OPERAND (ref, 2)));
2037 result = build_nt (ARRAY_REF,
2038 stabilize_reference (TREE_OPERAND (ref, 0)),
2039 stabilize_reference_1 (TREE_OPERAND (ref, 1)));
2042 case ARRAY_RANGE_REF:
2043 result = build_nt (ARRAY_RANGE_REF,
2044 stabilize_reference (TREE_OPERAND (ref, 0)),
2045 stabilize_reference_1 (TREE_OPERAND (ref, 1)));
2049 /* We cannot wrap the first expression in a SAVE_EXPR, as then
2050 it wouldn't be ignored. This matters when dealing with
2052 return stabilize_reference_1 (ref);
2055 result = build1 (INDIRECT_REF, TREE_TYPE (ref),
2056 save_expr (build1 (ADDR_EXPR,
2057 build_pointer_type (TREE_TYPE (ref)),
2061 /* If arg isn't a kind of lvalue we recognize, make no change.
2062 Caller should recognize the error for an invalid lvalue. */
2067 return error_mark_node;
2070 TREE_TYPE (result) = TREE_TYPE (ref);
2071 TREE_READONLY (result) = TREE_READONLY (ref);
2072 TREE_SIDE_EFFECTS (result) = TREE_SIDE_EFFECTS (ref);
2073 TREE_THIS_VOLATILE (result) = TREE_THIS_VOLATILE (ref);
2078 /* Subroutine of stabilize_reference; this is called for subtrees of
2079 references. Any expression with side-effects must be put in a SAVE_EXPR
2080 to ensure that it is only evaluated once.
2082 We don't put SAVE_EXPR nodes around everything, because assigning very
2083 simple expressions to temporaries causes us to miss good opportunities
2084 for optimizations. Among other things, the opportunity to fold in the
2085 addition of a constant into an addressing mode often gets lost, e.g.
2086 "y[i+1] += x;". In general, we take the approach that we should not make
2087 an assignment unless we are forced into it - i.e., that any non-side effect
2088 operator should be allowed, and that cse should take care of coalescing
2089 multiple utterances of the same expression should that prove fruitful. */
2092 stabilize_reference_1 (e)
2096 enum tree_code code = TREE_CODE (e);
2098 /* We cannot ignore const expressions because it might be a reference
2099 to a const array but whose index contains side-effects. But we can
2100 ignore things that are actual constant or that already have been
2101 handled by this function. */
2103 if (TREE_CONSTANT (e) || code == SAVE_EXPR)
2106 switch (TREE_CODE_CLASS (code))
2116 /* If the expression has side-effects, then encase it in a SAVE_EXPR
2117 so that it will only be evaluated once. */
2118 /* The reference (r) and comparison (<) classes could be handled as
2119 below, but it is generally faster to only evaluate them once. */
2120 if (TREE_SIDE_EFFECTS (e))
2121 return save_expr (e);
2125 /* Constants need no processing. In fact, we should never reach
2130 /* Division is slow and tends to be compiled with jumps,
2131 especially the division by powers of 2 that is often
2132 found inside of an array reference. So do it just once. */
2133 if (code == TRUNC_DIV_EXPR || code == TRUNC_MOD_EXPR
2134 || code == FLOOR_DIV_EXPR || code == FLOOR_MOD_EXPR
2135 || code == CEIL_DIV_EXPR || code == CEIL_MOD_EXPR
2136 || code == ROUND_DIV_EXPR || code == ROUND_MOD_EXPR)
2137 return save_expr (e);
2138 /* Recursively stabilize each operand. */
2139 result = build_nt (code, stabilize_reference_1 (TREE_OPERAND (e, 0)),
2140 stabilize_reference_1 (TREE_OPERAND (e, 1)));
2144 /* Recursively stabilize each operand. */
2145 result = build_nt (code, stabilize_reference_1 (TREE_OPERAND (e, 0)));
2152 TREE_TYPE (result) = TREE_TYPE (e);
2153 TREE_READONLY (result) = TREE_READONLY (e);
2154 TREE_SIDE_EFFECTS (result) = TREE_SIDE_EFFECTS (e);
2155 TREE_THIS_VOLATILE (result) = TREE_THIS_VOLATILE (e);
2160 /* Low-level constructors for expressions. */
2162 /* Build an expression of code CODE, data type TYPE,
2163 and operands as specified by the arguments ARG1 and following arguments.
2164 Expressions and reference nodes can be created this way.
2165 Constants, decls, types and misc nodes cannot be. */
2168 build VPARAMS ((enum tree_code code, tree tt, ...))
2177 VA_FIXEDARG (p, enum tree_code, code);
2178 VA_FIXEDARG (p, tree, tt);
2180 t = make_node (code);
2181 length = TREE_CODE_LENGTH (code);
2184 /* Below, we automatically set TREE_SIDE_EFFECTS and TREE_READONLY for the
2185 result based on those same flags for the arguments. But if the
2186 arguments aren't really even `tree' expressions, we shouldn't be trying
2188 fro = first_rtl_op (code);
2190 /* Expressions without side effects may be constant if their
2191 arguments are as well. */
2192 constant = (TREE_CODE_CLASS (code) == '<'
2193 || TREE_CODE_CLASS (code) == '1'
2194 || TREE_CODE_CLASS (code) == '2'
2195 || TREE_CODE_CLASS (code) == 'c');
2199 /* This is equivalent to the loop below, but faster. */
2200 tree arg0 = va_arg (p, tree);
2201 tree arg1 = va_arg (p, tree);
2203 TREE_OPERAND (t, 0) = arg0;
2204 TREE_OPERAND (t, 1) = arg1;
2205 TREE_READONLY (t) = 1;
2206 if (arg0 && fro > 0)
2208 if (TREE_SIDE_EFFECTS (arg0))
2209 TREE_SIDE_EFFECTS (t) = 1;
2210 if (!TREE_READONLY (arg0))
2211 TREE_READONLY (t) = 0;
2212 if (!TREE_CONSTANT (arg0))
2216 if (arg1 && fro > 1)
2218 if (TREE_SIDE_EFFECTS (arg1))
2219 TREE_SIDE_EFFECTS (t) = 1;
2220 if (!TREE_READONLY (arg1))
2221 TREE_READONLY (t) = 0;
2222 if (!TREE_CONSTANT (arg1))
2226 else if (length == 1)
2228 tree arg0 = va_arg (p, tree);
2230 /* The only one-operand cases we handle here are those with side-effects.
2231 Others are handled with build1. So don't bother checked if the
2232 arg has side-effects since we'll already have set it.
2234 ??? This really should use build1 too. */
2235 if (TREE_CODE_CLASS (code) != 's')
2237 TREE_OPERAND (t, 0) = arg0;
2241 for (i = 0; i < length; i++)
2243 tree operand = va_arg (p, tree);
2245 TREE_OPERAND (t, i) = operand;
2246 if (operand && fro > i)
2248 if (TREE_SIDE_EFFECTS (operand))
2249 TREE_SIDE_EFFECTS (t) = 1;
2250 if (!TREE_CONSTANT (operand))
2257 TREE_CONSTANT (t) = constant;
2261 /* Same as above, but only builds for unary operators.
2262 Saves lions share of calls to `build'; cuts down use
2263 of varargs, which is expensive for RISC machines. */
2266 build1 (code, type, node)
2267 enum tree_code code;
2271 int length = sizeof (struct tree_exp);
2272 #ifdef GATHER_STATISTICS
2273 tree_node_kind kind;
2277 #ifdef GATHER_STATISTICS
2278 switch (TREE_CODE_CLASS (code))
2280 case 's': /* an expression with side effects */
2283 case 'r': /* a reference */
2291 tree_node_counts[(int) kind]++;
2292 tree_node_sizes[(int) kind] += length;
2295 #ifdef ENABLE_CHECKING
2296 if (TREE_CODE_CLASS (code) == '2'
2297 || TREE_CODE_CLASS (code) == '<'
2298 || TREE_CODE_LENGTH (code) != 1)
2300 #endif /* ENABLE_CHECKING */
2302 t = ggc_alloc_tree (length);
2304 memset ((PTR) t, 0, sizeof (struct tree_common));
2306 TREE_SET_CODE (t, code);
2308 TREE_TYPE (t) = type;
2309 TREE_COMPLEXITY (t) = 0;
2310 TREE_OPERAND (t, 0) = node;
2311 if (node && first_rtl_op (code) != 0)
2313 TREE_SIDE_EFFECTS (t) = TREE_SIDE_EFFECTS (node);
2314 TREE_READONLY (t) = TREE_READONLY (node);
2317 if (TREE_CODE_CLASS (code) == 's')
2318 TREE_SIDE_EFFECTS (t) = 1;
2325 case PREDECREMENT_EXPR:
2326 case PREINCREMENT_EXPR:
2327 case POSTDECREMENT_EXPR:
2328 case POSTINCREMENT_EXPR:
2329 /* All of these have side-effects, no matter what their
2331 TREE_SIDE_EFFECTS (t) = 1;
2332 TREE_READONLY (t) = 0;
2336 /* Whether a dereference is readonly has nothing to do with whether
2337 its operand is readonly. */
2338 TREE_READONLY (t) = 0;
2342 if (TREE_CODE_CLASS (code) == '1' && node && TREE_CONSTANT (node))
2343 TREE_CONSTANT (t) = 1;
2350 /* Similar except don't specify the TREE_TYPE
2351 and leave the TREE_SIDE_EFFECTS as 0.
2352 It is permissible for arguments to be null,
2353 or even garbage if their values do not matter. */
2356 build_nt VPARAMS ((enum tree_code code, ...))
2363 VA_FIXEDARG (p, enum tree_code, code);
2365 t = make_node (code);
2366 length = TREE_CODE_LENGTH (code);
2368 for (i = 0; i < length; i++)
2369 TREE_OPERAND (t, i) = va_arg (p, tree);
2375 /* Create a DECL_... node of code CODE, name NAME and data type TYPE.
2376 We do NOT enter this node in any sort of symbol table.
2378 layout_decl is used to set up the decl's storage layout.
2379 Other slots are initialized to 0 or null pointers. */
2382 build_decl (code, name, type)
2383 enum tree_code code;
2388 t = make_node (code);
2390 /* if (type == error_mark_node)
2391 type = integer_type_node; */
2392 /* That is not done, deliberately, so that having error_mark_node
2393 as the type can suppress useless errors in the use of this variable. */
2395 DECL_NAME (t) = name;
2396 TREE_TYPE (t) = type;
2398 if (code == VAR_DECL || code == PARM_DECL || code == RESULT_DECL)
2400 else if (code == FUNCTION_DECL)
2401 DECL_MODE (t) = FUNCTION_MODE;
2406 /* BLOCK nodes are used to represent the structure of binding contours
2407 and declarations, once those contours have been exited and their contents
2408 compiled. This information is used for outputting debugging info. */
2411 build_block (vars, tags, subblocks, supercontext, chain)
2412 tree vars, tags ATTRIBUTE_UNUSED, subblocks, supercontext, chain;
2414 tree block = make_node (BLOCK);
2416 BLOCK_VARS (block) = vars;
2417 BLOCK_SUBBLOCKS (block) = subblocks;
2418 BLOCK_SUPERCONTEXT (block) = supercontext;
2419 BLOCK_CHAIN (block) = chain;
2423 /* EXPR_WITH_FILE_LOCATION are used to keep track of the exact
2424 location where an expression or an identifier were encountered. It
2425 is necessary for languages where the frontend parser will handle
2426 recursively more than one file (Java is one of them). */
2429 build_expr_wfl (node, file, line, col)
2434 static const char *last_file = 0;
2435 static tree last_filenode = NULL_TREE;
2436 tree wfl = make_node (EXPR_WITH_FILE_LOCATION);
2438 EXPR_WFL_NODE (wfl) = node;
2439 EXPR_WFL_SET_LINECOL (wfl, line, col);
2440 if (file != last_file)
2443 last_filenode = file ? get_identifier (file) : NULL_TREE;
2446 EXPR_WFL_FILENAME_NODE (wfl) = last_filenode;
2449 TREE_SIDE_EFFECTS (wfl) = TREE_SIDE_EFFECTS (node);
2450 TREE_TYPE (wfl) = TREE_TYPE (node);
2456 /* Return a declaration like DDECL except that its DECL_ATTRIBUTES
2460 build_decl_attribute_variant (ddecl, attribute)
2461 tree ddecl, attribute;
2463 DECL_ATTRIBUTES (ddecl) = attribute;
2467 /* Return a type like TTYPE except that its TYPE_ATTRIBUTE
2470 Record such modified types already made so we don't make duplicates. */
2473 build_type_attribute_variant (ttype, attribute)
2474 tree ttype, attribute;
2476 if (! attribute_list_equal (TYPE_ATTRIBUTES (ttype), attribute))
2478 unsigned int hashcode;
2481 ntype = copy_node (ttype);
2483 TYPE_POINTER_TO (ntype) = 0;
2484 TYPE_REFERENCE_TO (ntype) = 0;
2485 TYPE_ATTRIBUTES (ntype) = attribute;
2487 /* Create a new main variant of TYPE. */
2488 TYPE_MAIN_VARIANT (ntype) = ntype;
2489 TYPE_NEXT_VARIANT (ntype) = 0;
2490 set_type_quals (ntype, TYPE_UNQUALIFIED);
2492 hashcode = (TYPE_HASH (TREE_CODE (ntype))
2493 + TYPE_HASH (TREE_TYPE (ntype))
2494 + attribute_hash_list (attribute));
2496 switch (TREE_CODE (ntype))
2499 hashcode += TYPE_HASH (TYPE_ARG_TYPES (ntype));
2502 hashcode += TYPE_HASH (TYPE_DOMAIN (ntype));
2505 hashcode += TYPE_HASH (TYPE_MAX_VALUE (ntype));
2508 hashcode += TYPE_HASH (TYPE_PRECISION (ntype));
2514 ntype = type_hash_canon (hashcode, ntype);
2515 ttype = build_qualified_type (ntype, TYPE_QUALS (ttype));
2521 /* Return nonzero if IDENT is a valid name for attribute ATTR,
2524 We try both `text' and `__text__', ATTR may be either one. */
2525 /* ??? It might be a reasonable simplification to require ATTR to be only
2526 `text'. One might then also require attribute lists to be stored in
2527 their canonicalized form. */
2530 is_attribute_p (attr, ident)
2534 int ident_len, attr_len;
2537 if (TREE_CODE (ident) != IDENTIFIER_NODE)
2540 if (strcmp (attr, IDENTIFIER_POINTER (ident)) == 0)
2543 p = IDENTIFIER_POINTER (ident);
2544 ident_len = strlen (p);
2545 attr_len = strlen (attr);
2547 /* If ATTR is `__text__', IDENT must be `text'; and vice versa. */
2551 || attr[attr_len - 2] != '_'
2552 || attr[attr_len - 1] != '_')
2554 if (ident_len == attr_len - 4
2555 && strncmp (attr + 2, p, attr_len - 4) == 0)
2560 if (ident_len == attr_len + 4
2561 && p[0] == '_' && p[1] == '_'
2562 && p[ident_len - 2] == '_' && p[ident_len - 1] == '_'
2563 && strncmp (attr, p + 2, attr_len) == 0)
2570 /* Given an attribute name and a list of attributes, return a pointer to the
2571 attribute's list element if the attribute is part of the list, or NULL_TREE
2572 if not found. If the attribute appears more than once, this only
2573 returns the first occurrence; the TREE_CHAIN of the return value should
2574 be passed back in if further occurrences are wanted. */
2577 lookup_attribute (attr_name, list)
2578 const char *attr_name;
2583 for (l = list; l; l = TREE_CHAIN (l))
2585 if (TREE_CODE (TREE_PURPOSE (l)) != IDENTIFIER_NODE)
2587 if (is_attribute_p (attr_name, TREE_PURPOSE (l)))
2594 /* Return an attribute list that is the union of a1 and a2. */
2597 merge_attributes (a1, a2)
2602 /* Either one unset? Take the set one. */
2604 if ((attributes = a1) == 0)
2607 /* One that completely contains the other? Take it. */
2609 else if (a2 != 0 && ! attribute_list_contained (a1, a2))
2611 if (attribute_list_contained (a2, a1))
2615 /* Pick the longest list, and hang on the other list. */
2617 if (list_length (a1) < list_length (a2))
2618 attributes = a2, a2 = a1;
2620 for (; a2 != 0; a2 = TREE_CHAIN (a2))
2623 for (a = lookup_attribute (IDENTIFIER_POINTER (TREE_PURPOSE (a2)),
2626 a = lookup_attribute (IDENTIFIER_POINTER (TREE_PURPOSE (a2)),
2629 if (simple_cst_equal (TREE_VALUE (a), TREE_VALUE (a2)) == 1)
2634 a1 = copy_node (a2);
2635 TREE_CHAIN (a1) = attributes;
2644 /* Given types T1 and T2, merge their attributes and return
2648 merge_type_attributes (t1, t2)
2651 return merge_attributes (TYPE_ATTRIBUTES (t1),
2652 TYPE_ATTRIBUTES (t2));
2655 /* Given decls OLDDECL and NEWDECL, merge their attributes and return
2659 merge_decl_attributes (olddecl, newdecl)
2660 tree olddecl, newdecl;
2662 return merge_attributes (DECL_ATTRIBUTES (olddecl),
2663 DECL_ATTRIBUTES (newdecl));
2666 #ifdef TARGET_DLLIMPORT_DECL_ATTRIBUTES
2668 /* Specialization of merge_decl_attributes for various Windows targets.
2670 This handles the following situation:
2672 __declspec (dllimport) int foo;
2675 The second instance of `foo' nullifies the dllimport. */
2678 merge_dllimport_decl_attributes (old, new)
2683 int delete_dllimport_p;
2685 old = DECL_ATTRIBUTES (old);
2686 new = DECL_ATTRIBUTES (new);
2688 /* What we need to do here is remove from `old' dllimport if it doesn't
2689 appear in `new'. dllimport behaves like extern: if a declaration is
2690 marked dllimport and a definition appears later, then the object
2691 is not dllimport'd. */
2692 if (lookup_attribute ("dllimport", old) != NULL_TREE
2693 && lookup_attribute ("dllimport", new) == NULL_TREE)
2694 delete_dllimport_p = 1;
2696 delete_dllimport_p = 0;
2698 a = merge_attributes (old, new);
2700 if (delete_dllimport_p)
2704 /* Scan the list for dllimport and delete it. */
2705 for (prev = NULL_TREE, t = a; t; prev = t, t = TREE_CHAIN (t))
2707 if (is_attribute_p ("dllimport", TREE_PURPOSE (t)))
2709 if (prev == NULL_TREE)
2712 TREE_CHAIN (prev) = TREE_CHAIN (t);
2721 #endif /* TARGET_DLLIMPORT_DECL_ATTRIBUTES */
2723 /* Set the type qualifiers for TYPE to TYPE_QUALS, which is a bitmask
2724 of the various TYPE_QUAL values. */
2727 set_type_quals (type, type_quals)
2731 TYPE_READONLY (type) = (type_quals & TYPE_QUAL_CONST) != 0;
2732 TYPE_VOLATILE (type) = (type_quals & TYPE_QUAL_VOLATILE) != 0;
2733 TYPE_RESTRICT (type) = (type_quals & TYPE_QUAL_RESTRICT) != 0;
2736 /* Return a version of the TYPE, qualified as indicated by the
2737 TYPE_QUALS, if one exists. If no qualified version exists yet,
2738 return NULL_TREE. */
2741 get_qualified_type (type, type_quals)
2747 /* Search the chain of variants to see if there is already one there just
2748 like the one we need to have. If so, use that existing one. We must
2749 preserve the TYPE_NAME, since there is code that depends on this. */
2750 for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
2751 if (TYPE_QUALS (t) == type_quals && TYPE_NAME (t) == TYPE_NAME (type)
2752 && TYPE_CONTEXT (t) == TYPE_CONTEXT (type))
2758 /* Like get_qualified_type, but creates the type if it does not
2759 exist. This function never returns NULL_TREE. */
2762 build_qualified_type (type, type_quals)
2768 /* See if we already have the appropriate qualified variant. */
2769 t = get_qualified_type (type, type_quals);
2771 /* If not, build it. */
2774 t = build_type_copy (type);
2775 set_type_quals (t, type_quals);
2781 /* Create a new variant of TYPE, equivalent but distinct.
2782 This is so the caller can modify it. */
2785 build_type_copy (type)
2788 tree t, m = TYPE_MAIN_VARIANT (type);
2790 t = copy_node (type);
2792 TYPE_POINTER_TO (t) = 0;
2793 TYPE_REFERENCE_TO (t) = 0;
2795 /* Add this type to the chain of variants of TYPE. */
2796 TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (m);
2797 TYPE_NEXT_VARIANT (m) = t;
2802 /* Hashing of types so that we don't make duplicates.
2803 The entry point is `type_hash_canon'. */
2805 /* Compute a hash code for a list of types (chain of TREE_LIST nodes
2806 with types in the TREE_VALUE slots), by adding the hash codes
2807 of the individual types. */
2810 type_hash_list (list)
2813 unsigned int hashcode;
2816 for (hashcode = 0, tail = list; tail; tail = TREE_CHAIN (tail))
2817 hashcode += TYPE_HASH (TREE_VALUE (tail));
2822 /* These are the Hashtable callback functions. */
2824 /* Returns true if the types are equal. */
2827 type_hash_eq (va, vb)
2831 const struct type_hash *a = va, *b = vb;
2832 if (a->hash == b->hash
2833 && TREE_CODE (a->type) == TREE_CODE (b->type)
2834 && TREE_TYPE (a->type) == TREE_TYPE (b->type)
2835 && attribute_list_equal (TYPE_ATTRIBUTES (a->type),
2836 TYPE_ATTRIBUTES (b->type))
2837 && TYPE_ALIGN (a->type) == TYPE_ALIGN (b->type)
2838 && (TYPE_MAX_VALUE (a->type) == TYPE_MAX_VALUE (b->type)
2839 || tree_int_cst_equal (TYPE_MAX_VALUE (a->type),
2840 TYPE_MAX_VALUE (b->type)))
2841 && (TYPE_MIN_VALUE (a->type) == TYPE_MIN_VALUE (b->type)
2842 || tree_int_cst_equal (TYPE_MIN_VALUE (a->type),
2843 TYPE_MIN_VALUE (b->type)))
2844 /* Note that TYPE_DOMAIN is TYPE_ARG_TYPES for FUNCTION_TYPE. */
2845 && (TYPE_DOMAIN (a->type) == TYPE_DOMAIN (b->type)
2846 || (TYPE_DOMAIN (a->type)
2847 && TREE_CODE (TYPE_DOMAIN (a->type)) == TREE_LIST
2848 && TYPE_DOMAIN (b->type)
2849 && TREE_CODE (TYPE_DOMAIN (b->type)) == TREE_LIST
2850 && type_list_equal (TYPE_DOMAIN (a->type),
2851 TYPE_DOMAIN (b->type)))))
2856 /* Return the cached hash value. */
2859 type_hash_hash (item)
2862 return ((const struct type_hash *) item)->hash;
2865 /* Look in the type hash table for a type isomorphic to TYPE.
2866 If one is found, return it. Otherwise return 0. */
2869 type_hash_lookup (hashcode, type)
2870 unsigned int hashcode;
2873 struct type_hash *h, in;
2875 /* The TYPE_ALIGN field of a type is set by layout_type(), so we
2876 must call that routine before comparing TYPE_ALIGNs. */
2882 h = htab_find_with_hash (type_hash_table, &in, hashcode);
2888 /* Add an entry to the type-hash-table
2889 for a type TYPE whose hash code is HASHCODE. */
2892 type_hash_add (hashcode, type)
2893 unsigned int hashcode;
2896 struct type_hash *h;
2899 h = (struct type_hash *) ggc_alloc (sizeof (struct type_hash));
2902 loc = htab_find_slot_with_hash (type_hash_table, h, hashcode, INSERT);
2903 *(struct type_hash **) loc = h;
2906 /* Given TYPE, and HASHCODE its hash code, return the canonical
2907 object for an identical type if one already exists.
2908 Otherwise, return TYPE, and record it as the canonical object
2909 if it is a permanent object.
2911 To use this function, first create a type of the sort you want.
2912 Then compute its hash code from the fields of the type that
2913 make it different from other similar types.
2914 Then call this function and use the value.
2915 This function frees the type you pass in if it is a duplicate. */
2917 /* Set to 1 to debug without canonicalization. Never set by program. */
2918 int debug_no_type_hash = 0;
2921 type_hash_canon (hashcode, type)
2922 unsigned int hashcode;
2927 if (debug_no_type_hash)
2930 /* See if the type is in the hash table already. If so, return it.
2931 Otherwise, add the type. */
2932 t1 = type_hash_lookup (hashcode, type);
2935 #ifdef GATHER_STATISTICS
2936 tree_node_counts[(int) t_kind]--;
2937 tree_node_sizes[(int) t_kind] -= sizeof (struct tree_type);
2943 type_hash_add (hashcode, type);
2948 /* See if the data pointed to by the type hash table is marked. We consider
2949 it marked if the type is marked or if a debug type number or symbol
2950 table entry has been made for the type. This reduces the amount of
2951 debugging output and eliminates that dependency of the debug output on
2952 the number of garbage collections. */
2955 type_hash_marked_p (p)
2958 tree type = ((struct type_hash *) p)->type;
2960 return ggc_marked_p (type) || TYPE_SYMTAB_POINTER (type);
2964 print_type_hash_statistics ()
2966 fprintf (stderr, "Type hash: size %ld, %ld elements, %f collisions\n",
2967 (long) htab_size (type_hash_table),
2968 (long) htab_elements (type_hash_table),
2969 htab_collisions (type_hash_table));
2972 /* Compute a hash code for a list of attributes (chain of TREE_LIST nodes
2973 with names in the TREE_PURPOSE slots and args in the TREE_VALUE slots),
2974 by adding the hash codes of the individual attributes. */
2977 attribute_hash_list (list)
2980 unsigned int hashcode;
2983 for (hashcode = 0, tail = list; tail; tail = TREE_CHAIN (tail))
2984 /* ??? Do we want to add in TREE_VALUE too? */
2985 hashcode += TYPE_HASH (TREE_PURPOSE (tail));
2989 /* Given two lists of attributes, return true if list l2 is
2990 equivalent to l1. */
2993 attribute_list_equal (l1, l2)
2996 return attribute_list_contained (l1, l2)
2997 && attribute_list_contained (l2, l1);
3000 /* Given two lists of attributes, return true if list L2 is
3001 completely contained within L1. */
3002 /* ??? This would be faster if attribute names were stored in a canonicalized
3003 form. Otherwise, if L1 uses `foo' and L2 uses `__foo__', the long method
3004 must be used to show these elements are equivalent (which they are). */
3005 /* ??? It's not clear that attributes with arguments will always be handled
3009 attribute_list_contained (l1, l2)
3014 /* First check the obvious, maybe the lists are identical. */
3018 /* Maybe the lists are similar. */
3019 for (t1 = l1, t2 = l2;
3021 && TREE_PURPOSE (t1) == TREE_PURPOSE (t2)
3022 && TREE_VALUE (t1) == TREE_VALUE (t2);
3023 t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2));
3025 /* Maybe the lists are equal. */
3026 if (t1 == 0 && t2 == 0)
3029 for (; t2 != 0; t2 = TREE_CHAIN (t2))
3032 for (attr = lookup_attribute (IDENTIFIER_POINTER (TREE_PURPOSE (t2)), l1);
3034 attr = lookup_attribute (IDENTIFIER_POINTER (TREE_PURPOSE (t2)),
3037 if (simple_cst_equal (TREE_VALUE (t2), TREE_VALUE (attr)) == 1)
3044 if (simple_cst_equal (TREE_VALUE (t2), TREE_VALUE (attr)) != 1)
3051 /* Given two lists of types
3052 (chains of TREE_LIST nodes with types in the TREE_VALUE slots)
3053 return 1 if the lists contain the same types in the same order.
3054 Also, the TREE_PURPOSEs must match. */
3057 type_list_equal (l1, l2)
3062 for (t1 = l1, t2 = l2; t1 && t2; t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2))
3063 if (TREE_VALUE (t1) != TREE_VALUE (t2)
3064 || (TREE_PURPOSE (t1) != TREE_PURPOSE (t2)
3065 && ! (1 == simple_cst_equal (TREE_PURPOSE (t1), TREE_PURPOSE (t2))
3066 && (TREE_TYPE (TREE_PURPOSE (t1))
3067 == TREE_TYPE (TREE_PURPOSE (t2))))))
3073 /* Returns the number of arguments to the FUNCTION_TYPE or METHOD_TYPE
3074 given by TYPE. If the argument list accepts variable arguments,
3075 then this function counts only the ordinary arguments. */
3078 type_num_arguments (type)
3084 for (t = TYPE_ARG_TYPES (type); t; t = TREE_CHAIN (t))
3085 /* If the function does not take a variable number of arguments,
3086 the last element in the list will have type `void'. */
3087 if (VOID_TYPE_P (TREE_VALUE (t)))
3095 /* Nonzero if integer constants T1 and T2
3096 represent the same constant value. */
3099 tree_int_cst_equal (t1, t2)
3105 if (t1 == 0 || t2 == 0)
3108 if (TREE_CODE (t1) == INTEGER_CST
3109 && TREE_CODE (t2) == INTEGER_CST
3110 && TREE_INT_CST_LOW (t1) == TREE_INT_CST_LOW (t2)
3111 && TREE_INT_CST_HIGH (t1) == TREE_INT_CST_HIGH (t2))
3117 /* Nonzero if integer constants T1 and T2 represent values that satisfy <.
3118 The precise way of comparison depends on their data type. */
3121 tree_int_cst_lt (t1, t2)
3127 if (TREE_UNSIGNED (TREE_TYPE (t1)) != TREE_UNSIGNED (TREE_TYPE (t2)))
3129 int t1_sgn = tree_int_cst_sgn (t1);
3130 int t2_sgn = tree_int_cst_sgn (t2);
3132 if (t1_sgn < t2_sgn)
3134 else if (t1_sgn > t2_sgn)
3136 /* Otherwise, both are non-negative, so we compare them as
3137 unsigned just in case one of them would overflow a signed
3140 else if (! TREE_UNSIGNED (TREE_TYPE (t1)))
3141 return INT_CST_LT (t1, t2);
3143 return INT_CST_LT_UNSIGNED (t1, t2);
3146 /* Returns -1 if T1 < T2, 0 if T1 == T2, and 1 if T1 > T2. */
3149 tree_int_cst_compare (t1, t2)
3153 if (tree_int_cst_lt (t1, t2))
3155 else if (tree_int_cst_lt (t2, t1))
3161 /* Return 1 if T is an INTEGER_CST that can be manipulated efficiently on
3162 the host. If POS is zero, the value can be represented in a single
3163 HOST_WIDE_INT. If POS is nonzero, the value must be positive and can
3164 be represented in a single unsigned HOST_WIDE_INT. */
3167 host_integerp (t, pos)
3171 return (TREE_CODE (t) == INTEGER_CST
3172 && ! TREE_OVERFLOW (t)
3173 && ((TREE_INT_CST_HIGH (t) == 0
3174 && (HOST_WIDE_INT) TREE_INT_CST_LOW (t) >= 0)
3175 || (! pos && TREE_INT_CST_HIGH (t) == -1
3176 && (HOST_WIDE_INT) TREE_INT_CST_LOW (t) < 0
3177 && ! TREE_UNSIGNED (TREE_TYPE (t)))
3178 || (pos && TREE_INT_CST_HIGH (t) == 0)));
3181 /* Return the HOST_WIDE_INT least significant bits of T if it is an
3182 INTEGER_CST and there is no overflow. POS is nonzero if the result must
3183 be positive. Abort if we cannot satisfy the above conditions. */
3186 tree_low_cst (t, pos)
3190 if (host_integerp (t, pos))
3191 return TREE_INT_CST_LOW (t);
3196 /* Return an indication of the sign of the integer constant T.
3197 The return value is -1 if T < 0, 0 if T == 0, and 1 if T > 0.
3198 Note that -1 will never be returned it T's type is unsigned. */
3201 tree_int_cst_sgn (t)
3204 if (TREE_INT_CST_LOW (t) == 0 && TREE_INT_CST_HIGH (t) == 0)
3206 else if (TREE_UNSIGNED (TREE_TYPE (t)))
3208 else if (TREE_INT_CST_HIGH (t) < 0)
3214 /* Compare two constructor-element-type constants. Return 1 if the lists
3215 are known to be equal; otherwise return 0. */
3218 simple_cst_list_equal (l1, l2)
3221 while (l1 != NULL_TREE && l2 != NULL_TREE)
3223 if (simple_cst_equal (TREE_VALUE (l1), TREE_VALUE (l2)) != 1)
3226 l1 = TREE_CHAIN (l1);
3227 l2 = TREE_CHAIN (l2);
3233 /* Return truthvalue of whether T1 is the same tree structure as T2.
3234 Return 1 if they are the same.
3235 Return 0 if they are understandably different.
3236 Return -1 if either contains tree structure not understood by
3240 simple_cst_equal (t1, t2)
3243 enum tree_code code1, code2;
3249 if (t1 == 0 || t2 == 0)
3252 code1 = TREE_CODE (t1);
3253 code2 = TREE_CODE (t2);
3255 if (code1 == NOP_EXPR || code1 == CONVERT_EXPR || code1 == NON_LVALUE_EXPR)
3257 if (code2 == NOP_EXPR || code2 == CONVERT_EXPR
3258 || code2 == NON_LVALUE_EXPR)
3259 return simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
3261 return simple_cst_equal (TREE_OPERAND (t1, 0), t2);
3264 else if (code2 == NOP_EXPR || code2 == CONVERT_EXPR
3265 || code2 == NON_LVALUE_EXPR)
3266 return simple_cst_equal (t1, TREE_OPERAND (t2, 0));
3274 return (TREE_INT_CST_LOW (t1) == TREE_INT_CST_LOW (t2)
3275 && TREE_INT_CST_HIGH (t1) == TREE_INT_CST_HIGH (t2));
3278 return REAL_VALUES_IDENTICAL (TREE_REAL_CST (t1), TREE_REAL_CST (t2));
3281 return (TREE_STRING_LENGTH (t1) == TREE_STRING_LENGTH (t2)
3282 && ! memcmp (TREE_STRING_POINTER (t1), TREE_STRING_POINTER (t2),
3283 TREE_STRING_LENGTH (t1)));
3286 if (CONSTRUCTOR_ELTS (t1) == CONSTRUCTOR_ELTS (t2))
3292 return simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
3295 cmp = simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
3299 simple_cst_list_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1));
3302 /* Special case: if either target is an unallocated VAR_DECL,
3303 it means that it's going to be unified with whatever the
3304 TARGET_EXPR is really supposed to initialize, so treat it
3305 as being equivalent to anything. */
3306 if ((TREE_CODE (TREE_OPERAND (t1, 0)) == VAR_DECL
3307 && DECL_NAME (TREE_OPERAND (t1, 0)) == NULL_TREE
3308 && !DECL_RTL_SET_P (TREE_OPERAND (t1, 0)))
3309 || (TREE_CODE (TREE_OPERAND (t2, 0)) == VAR_DECL
3310 && DECL_NAME (TREE_OPERAND (t2, 0)) == NULL_TREE
3311 && !DECL_RTL_SET_P (TREE_OPERAND (t2, 0))))
3314 cmp = simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
3319 return simple_cst_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1));
3321 case WITH_CLEANUP_EXPR:
3322 cmp = simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
3326 return simple_cst_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t1, 1));
3329 if (TREE_OPERAND (t1, 1) == TREE_OPERAND (t2, 1))
3330 return simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
3344 /* This general rule works for most tree codes. All exceptions should be
3345 handled above. If this is a language-specific tree code, we can't
3346 trust what might be in the operand, so say we don't know
3348 if ((int) code1 >= (int) LAST_AND_UNUSED_TREE_CODE)
3351 switch (TREE_CODE_CLASS (code1))
3360 for (i = 0; i < TREE_CODE_LENGTH (code1); i++)
3362 cmp = simple_cst_equal (TREE_OPERAND (t1, i), TREE_OPERAND (t2, i));
3374 /* Compare the value of T, an INTEGER_CST, with U, an unsigned integer value.
3375 Return -1, 0, or 1 if the value of T is less than, equal to, or greater
3376 than U, respectively. */
3379 compare_tree_int (t, u)
3381 unsigned HOST_WIDE_INT u;
3383 if (tree_int_cst_sgn (t) < 0)
3385 else if (TREE_INT_CST_HIGH (t) != 0)
3387 else if (TREE_INT_CST_LOW (t) == u)
3389 else if (TREE_INT_CST_LOW (t) < u)
3395 /* Constructors for pointer, array and function types.
3396 (RECORD_TYPE, UNION_TYPE and ENUMERAL_TYPE nodes are
3397 constructed by language-dependent code, not here.) */
3399 /* Construct, lay out and return the type of pointers to TO_TYPE
3400 with mode MODE. If such a type has already been constructed,
3404 build_pointer_type_for_mode (to_type, mode)
3406 enum machine_mode mode;
3408 tree t = TYPE_POINTER_TO (to_type);
3410 /* First, if we already have a type for pointers to TO_TYPE, use it. */
3411 if (t != 0 && mode == ptr_mode)
3414 t = make_node (POINTER_TYPE);
3416 TREE_TYPE (t) = to_type;
3417 TYPE_MODE (t) = mode;
3419 /* Record this type as the pointer to TO_TYPE. */
3420 if (mode == ptr_mode)
3421 TYPE_POINTER_TO (to_type) = t;
3423 /* Lay out the type. This function has many callers that are concerned
3424 with expression-construction, and this simplifies them all.
3425 Also, it guarantees the TYPE_SIZE is in the same obstack as the type. */
3431 /* By default build pointers in ptr_mode. */
3434 build_pointer_type (to_type)
3437 return build_pointer_type_for_mode (to_type, ptr_mode);
3440 /* Construct, lay out and return the type of references to TO_TYPE
3441 with mode MODE. If such a type has already been constructed,
3445 build_reference_type_for_mode (to_type, mode)
3447 enum machine_mode mode;
3449 tree t = TYPE_REFERENCE_TO (to_type);
3451 /* First, if we already have a type for pointers to TO_TYPE, use it. */
3452 if (t != 0 && mode == ptr_mode)
3455 t = make_node (REFERENCE_TYPE);
3457 TREE_TYPE (t) = to_type;
3458 TYPE_MODE (t) = mode;
3460 /* Record this type as the pointer to TO_TYPE. */
3461 if (mode == ptr_mode)
3462 TYPE_REFERENCE_TO (to_type) = t;
3470 /* Build the node for the type of references-to-TO_TYPE by default
3474 build_reference_type (to_type)
3477 return build_reference_type_for_mode (to_type, ptr_mode);
3480 /* Build a type that is compatible with t but has no cv quals anywhere
3483 const char *const *const * -> char ***. */
3486 build_type_no_quals (t)
3489 switch (TREE_CODE (t))
3492 return build_pointer_type (build_type_no_quals (TREE_TYPE (t)));
3493 case REFERENCE_TYPE:
3494 return build_reference_type (build_type_no_quals (TREE_TYPE (t)));
3496 return TYPE_MAIN_VARIANT (t);
3500 /* Create a type of integers to be the TYPE_DOMAIN of an ARRAY_TYPE.
3501 MAXVAL should be the maximum value in the domain
3502 (one less than the length of the array).
3504 The maximum value that MAXVAL can have is INT_MAX for a HOST_WIDE_INT.
3505 We don't enforce this limit, that is up to caller (e.g. language front end).
3506 The limit exists because the result is a signed type and we don't handle
3507 sizes that use more than one HOST_WIDE_INT. */
3510 build_index_type (maxval)
3513 tree itype = make_node (INTEGER_TYPE);
3515 TREE_TYPE (itype) = sizetype;
3516 TYPE_PRECISION (itype) = TYPE_PRECISION (sizetype);
3517 TYPE_MIN_VALUE (itype) = size_zero_node;
3518 TYPE_MAX_VALUE (itype) = convert (sizetype, maxval);
3519 TYPE_MODE (itype) = TYPE_MODE (sizetype);
3520 TYPE_SIZE (itype) = TYPE_SIZE (sizetype);
3521 TYPE_SIZE_UNIT (itype) = TYPE_SIZE_UNIT (sizetype);
3522 TYPE_ALIGN (itype) = TYPE_ALIGN (sizetype);
3523 TYPE_USER_ALIGN (itype) = TYPE_USER_ALIGN (sizetype);
3525 if (host_integerp (maxval, 1))
3526 return type_hash_canon (tree_low_cst (maxval, 1), itype);
3531 /* Create a range of some discrete type TYPE (an INTEGER_TYPE,
3532 ENUMERAL_TYPE, BOOLEAN_TYPE, or CHAR_TYPE), with
3533 low bound LOWVAL and high bound HIGHVAL.
3534 if TYPE==NULL_TREE, sizetype is used. */
3537 build_range_type (type, lowval, highval)
3538 tree type, lowval, highval;
3540 tree itype = make_node (INTEGER_TYPE);
3542 TREE_TYPE (itype) = type;
3543 if (type == NULL_TREE)
3546 TYPE_MIN_VALUE (itype) = convert (type, lowval);
3547 TYPE_MAX_VALUE (itype) = highval ? convert (type, highval) : NULL;
3549 TYPE_PRECISION (itype) = TYPE_PRECISION (type);
3550 TYPE_MODE (itype) = TYPE_MODE (type);
3551 TYPE_SIZE (itype) = TYPE_SIZE (type);
3552 TYPE_SIZE_UNIT (itype) = TYPE_SIZE_UNIT (type);
3553 TYPE_ALIGN (itype) = TYPE_ALIGN (type);
3554 TYPE_USER_ALIGN (itype) = TYPE_USER_ALIGN (type);
3556 if (host_integerp (lowval, 0) && highval != 0 && host_integerp (highval, 0))
3557 return type_hash_canon (tree_low_cst (highval, 0)
3558 - tree_low_cst (lowval, 0),
3564 /* Just like build_index_type, but takes lowval and highval instead
3565 of just highval (maxval). */
3568 build_index_2_type (lowval, highval)
3569 tree lowval, highval;
3571 return build_range_type (sizetype, lowval, highval);
3574 /* Construct, lay out and return the type of arrays of elements with ELT_TYPE
3575 and number of elements specified by the range of values of INDEX_TYPE.
3576 If such a type has already been constructed, reuse it. */
3579 build_array_type (elt_type, index_type)
3580 tree elt_type, index_type;
3583 unsigned int hashcode;
3585 if (TREE_CODE (elt_type) == FUNCTION_TYPE)
3587 error ("arrays of functions are not meaningful");
3588 elt_type = integer_type_node;
3591 /* Make sure TYPE_POINTER_TO (elt_type) is filled in. */
3592 build_pointer_type (elt_type);
3594 /* Allocate the array after the pointer type,
3595 in case we free it in type_hash_canon. */
3596 t = make_node (ARRAY_TYPE);
3597 TREE_TYPE (t) = elt_type;
3598 TYPE_DOMAIN (t) = index_type;
3600 if (index_type == 0)
3605 hashcode = TYPE_HASH (elt_type) + TYPE_HASH (index_type);
3606 t = type_hash_canon (hashcode, t);
3608 if (!COMPLETE_TYPE_P (t))
3613 /* Return the TYPE of the elements comprising
3614 the innermost dimension of ARRAY. */
3617 get_inner_array_type (array)
3620 tree type = TREE_TYPE (array);
3622 while (TREE_CODE (type) == ARRAY_TYPE)
3623 type = TREE_TYPE (type);
3628 /* Construct, lay out and return
3629 the type of functions returning type VALUE_TYPE
3630 given arguments of types ARG_TYPES.
3631 ARG_TYPES is a chain of TREE_LIST nodes whose TREE_VALUEs
3632 are data type nodes for the arguments of the function.
3633 If such a type has already been constructed, reuse it. */
3636 build_function_type (value_type, arg_types)
3637 tree value_type, arg_types;
3640 unsigned int hashcode;
3642 if (TREE_CODE (value_type) == FUNCTION_TYPE)
3644 error ("function return type cannot be function");
3645 value_type = integer_type_node;
3648 /* Make a node of the sort we want. */
3649 t = make_node (FUNCTION_TYPE);
3650 TREE_TYPE (t) = value_type;
3651 TYPE_ARG_TYPES (t) = arg_types;
3653 /* If we already have such a type, use the old one and free this one. */
3654 hashcode = TYPE_HASH (value_type) + type_hash_list (arg_types);
3655 t = type_hash_canon (hashcode, t);
3657 if (!COMPLETE_TYPE_P (t))
3662 /* Build a function type. The RETURN_TYPE is the type retured by the
3663 function. If additional arguments are provided, they are
3664 additional argument types. The list of argument types must always
3665 be terminated by NULL_TREE. */
3668 build_function_type_list VPARAMS ((tree return_type, ...))
3672 VA_OPEN (p, return_type);
3673 VA_FIXEDARG (p, tree, return_type);
3675 t = va_arg (p, tree);
3676 for (args = NULL_TREE; t != NULL_TREE; t = va_arg (p, tree))
3677 args = tree_cons (NULL_TREE, t, args);
3680 args = nreverse (args);
3681 TREE_CHAIN (last) = void_list_node;
3682 args = build_function_type (return_type, args);
3688 /* Construct, lay out and return the type of methods belonging to class
3689 BASETYPE and whose arguments and values are described by TYPE.
3690 If that type exists already, reuse it.
3691 TYPE must be a FUNCTION_TYPE node. */
3694 build_method_type (basetype, type)
3695 tree basetype, type;
3698 unsigned int hashcode;
3700 /* Make a node of the sort we want. */
3701 t = make_node (METHOD_TYPE);
3703 if (TREE_CODE (type) != FUNCTION_TYPE)
3706 TYPE_METHOD_BASETYPE (t) = TYPE_MAIN_VARIANT (basetype);
3707 TREE_TYPE (t) = TREE_TYPE (type);
3709 /* The actual arglist for this function includes a "hidden" argument
3710 which is "this". Put it into the list of argument types. */
3713 = tree_cons (NULL_TREE,
3714 build_pointer_type (basetype), TYPE_ARG_TYPES (type));
3716 /* If we already have such a type, use the old one and free this one. */
3717 hashcode = TYPE_HASH (basetype) + TYPE_HASH (type);
3718 t = type_hash_canon (hashcode, t);
3720 if (!COMPLETE_TYPE_P (t))
3726 /* Construct, lay out and return the type of offsets to a value
3727 of type TYPE, within an object of type BASETYPE.
3728 If a suitable offset type exists already, reuse it. */
3731 build_offset_type (basetype, type)
3732 tree basetype, type;
3735 unsigned int hashcode;
3737 /* Make a node of the sort we want. */
3738 t = make_node (OFFSET_TYPE);
3740 TYPE_OFFSET_BASETYPE (t) = TYPE_MAIN_VARIANT (basetype);
3741 TREE_TYPE (t) = type;
3743 /* If we already have such a type, use the old one and free this one. */
3744 hashcode = TYPE_HASH (basetype) + TYPE_HASH (type);
3745 t = type_hash_canon (hashcode, t);
3747 if (!COMPLETE_TYPE_P (t))
3753 /* Create a complex type whose components are COMPONENT_TYPE. */
3756 build_complex_type (component_type)
3757 tree component_type;
3760 unsigned int hashcode;
3762 /* Make a node of the sort we want. */
3763 t = make_node (COMPLEX_TYPE);
3765 TREE_TYPE (t) = TYPE_MAIN_VARIANT (component_type);
3766 set_type_quals (t, TYPE_QUALS (component_type));
3768 /* If we already have such a type, use the old one and free this one. */
3769 hashcode = TYPE_HASH (component_type);
3770 t = type_hash_canon (hashcode, t);
3772 if (!COMPLETE_TYPE_P (t))
3775 /* If we are writing Dwarf2 output we need to create a name,
3776 since complex is a fundamental type. */
3777 if ((write_symbols == DWARF2_DEBUG || write_symbols == VMS_AND_DWARF2_DEBUG)
3781 if (component_type == char_type_node)
3782 name = "complex char";
3783 else if (component_type == signed_char_type_node)
3784 name = "complex signed char";
3785 else if (component_type == unsigned_char_type_node)
3786 name = "complex unsigned char";
3787 else if (component_type == short_integer_type_node)
3788 name = "complex short int";
3789 else if (component_type == short_unsigned_type_node)
3790 name = "complex short unsigned int";
3791 else if (component_type == integer_type_node)
3792 name = "complex int";
3793 else if (component_type == unsigned_type_node)
3794 name = "complex unsigned int";
3795 else if (component_type == long_integer_type_node)
3796 name = "complex long int";
3797 else if (component_type == long_unsigned_type_node)
3798 name = "complex long unsigned int";
3799 else if (component_type == long_long_integer_type_node)
3800 name = "complex long long int";
3801 else if (component_type == long_long_unsigned_type_node)
3802 name = "complex long long unsigned int";
3807 TYPE_NAME (t) = get_identifier (name);
3813 /* Return OP, stripped of any conversions to wider types as much as is safe.
3814 Converting the value back to OP's type makes a value equivalent to OP.
3816 If FOR_TYPE is nonzero, we return a value which, if converted to
3817 type FOR_TYPE, would be equivalent to converting OP to type FOR_TYPE.
3819 If FOR_TYPE is nonzero, unaligned bit-field references may be changed to the
3820 narrowest type that can hold the value, even if they don't exactly fit.
3821 Otherwise, bit-field references are changed to a narrower type
3822 only if they can be fetched directly from memory in that type.
3824 OP must have integer, real or enumeral type. Pointers are not allowed!
3826 There are some cases where the obvious value we could return
3827 would regenerate to OP if converted to OP's type,
3828 but would not extend like OP to wider types.
3829 If FOR_TYPE indicates such extension is contemplated, we eschew such values.
3830 For example, if OP is (unsigned short)(signed char)-1,
3831 we avoid returning (signed char)-1 if FOR_TYPE is int,
3832 even though extending that to an unsigned short would regenerate OP,
3833 since the result of extending (signed char)-1 to (int)
3834 is different from (int) OP. */
3837 get_unwidened (op, for_type)
3841 /* Set UNS initially if converting OP to FOR_TYPE is a zero-extension. */
3842 tree type = TREE_TYPE (op);
3844 = TYPE_PRECISION (for_type != 0 ? for_type : type);
3846 = (for_type != 0 && for_type != type
3847 && final_prec > TYPE_PRECISION (type)
3848 && TREE_UNSIGNED (type));
3851 while (TREE_CODE (op) == NOP_EXPR)
3854 = TYPE_PRECISION (TREE_TYPE (op))
3855 - TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op, 0)));
3857 /* Truncations are many-one so cannot be removed.
3858 Unless we are later going to truncate down even farther. */
3860 && final_prec > TYPE_PRECISION (TREE_TYPE (op)))
3863 /* See what's inside this conversion. If we decide to strip it,
3865 op = TREE_OPERAND (op, 0);
3867 /* If we have not stripped any zero-extensions (uns is 0),
3868 we can strip any kind of extension.
3869 If we have previously stripped a zero-extension,
3870 only zero-extensions can safely be stripped.
3871 Any extension can be stripped if the bits it would produce
3872 are all going to be discarded later by truncating to FOR_TYPE. */
3876 if (! uns || final_prec <= TYPE_PRECISION (TREE_TYPE (op)))
3878 /* TREE_UNSIGNED says whether this is a zero-extension.
3879 Let's avoid computing it if it does not affect WIN
3880 and if UNS will not be needed again. */
3881 if ((uns || TREE_CODE (op) == NOP_EXPR)
3882 && TREE_UNSIGNED (TREE_TYPE (op)))
3890 if (TREE_CODE (op) == COMPONENT_REF
3891 /* Since type_for_size always gives an integer type. */
3892 && TREE_CODE (type) != REAL_TYPE
3893 /* Don't crash if field not laid out yet. */
3894 && DECL_SIZE (TREE_OPERAND (op, 1)) != 0
3895 && host_integerp (DECL_SIZE (TREE_OPERAND (op, 1)), 1))
3897 unsigned int innerprec
3898 = tree_low_cst (DECL_SIZE (TREE_OPERAND (op, 1)), 1);
3899 int unsignedp = TREE_UNSIGNED (TREE_OPERAND (op, 1));
3900 type = (*lang_hooks.types.type_for_size) (innerprec, unsignedp);
3902 /* We can get this structure field in the narrowest type it fits in.
3903 If FOR_TYPE is 0, do this only for a field that matches the
3904 narrower type exactly and is aligned for it
3905 The resulting extension to its nominal type (a fullword type)
3906 must fit the same conditions as for other extensions. */
3908 if (innerprec < TYPE_PRECISION (TREE_TYPE (op))
3909 && (for_type || ! DECL_BIT_FIELD (TREE_OPERAND (op, 1)))
3910 && (! uns || final_prec <= innerprec || unsignedp)
3913 win = build (COMPONENT_REF, type, TREE_OPERAND (op, 0),
3914 TREE_OPERAND (op, 1));
3915 TREE_SIDE_EFFECTS (win) = TREE_SIDE_EFFECTS (op);
3916 TREE_THIS_VOLATILE (win) = TREE_THIS_VOLATILE (op);
3923 /* Return OP or a simpler expression for a narrower value
3924 which can be sign-extended or zero-extended to give back OP.
3925 Store in *UNSIGNEDP_PTR either 1 if the value should be zero-extended
3926 or 0 if the value should be sign-extended. */
3929 get_narrower (op, unsignedp_ptr)
3937 while (TREE_CODE (op) == NOP_EXPR)
3940 = (TYPE_PRECISION (TREE_TYPE (op))
3941 - TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op, 0))));
3943 /* Truncations are many-one so cannot be removed. */
3947 /* See what's inside this conversion. If we decide to strip it,
3949 op = TREE_OPERAND (op, 0);
3953 /* An extension: the outermost one can be stripped,
3954 but remember whether it is zero or sign extension. */
3956 uns = TREE_UNSIGNED (TREE_TYPE (op));
3957 /* Otherwise, if a sign extension has been stripped,
3958 only sign extensions can now be stripped;
3959 if a zero extension has been stripped, only zero-extensions. */
3960 else if (uns != TREE_UNSIGNED (TREE_TYPE (op)))
3964 else /* bitschange == 0 */
3966 /* A change in nominal type can always be stripped, but we must
3967 preserve the unsignedness. */
3969 uns = TREE_UNSIGNED (TREE_TYPE (op));
3976 if (TREE_CODE (op) == COMPONENT_REF
3977 /* Since type_for_size always gives an integer type. */
3978 && TREE_CODE (TREE_TYPE (op)) != REAL_TYPE
3979 /* Ensure field is laid out already. */
3980 && DECL_SIZE (TREE_OPERAND (op, 1)) != 0)
3982 unsigned HOST_WIDE_INT innerprec
3983 = tree_low_cst (DECL_SIZE (TREE_OPERAND (op, 1)), 1);
3984 tree type = (*lang_hooks.types.type_for_size) (innerprec,
3985 TREE_UNSIGNED (op));
3987 /* We can get this structure field in a narrower type that fits it,
3988 but the resulting extension to its nominal type (a fullword type)
3989 must satisfy the same conditions as for other extensions.
3991 Do this only for fields that are aligned (not bit-fields),
3992 because when bit-field insns will be used there is no
3993 advantage in doing this. */
3995 if (innerprec < TYPE_PRECISION (TREE_TYPE (op))
3996 && ! DECL_BIT_FIELD (TREE_OPERAND (op, 1))
3997 && (first || uns == TREE_UNSIGNED (TREE_OPERAND (op, 1)))
4001 uns = TREE_UNSIGNED (TREE_OPERAND (op, 1));
4002 win = build (COMPONENT_REF, type, TREE_OPERAND (op, 0),
4003 TREE_OPERAND (op, 1));
4004 TREE_SIDE_EFFECTS (win) = TREE_SIDE_EFFECTS (op);
4005 TREE_THIS_VOLATILE (win) = TREE_THIS_VOLATILE (op);
4008 *unsignedp_ptr = uns;
4012 /* Nonzero if integer constant C has a value that is permissible
4013 for type TYPE (an INTEGER_TYPE). */
4016 int_fits_type_p (c, type)
4019 /* If the bounds of the type are integers, we can check ourselves.
4020 If not, but this type is a subtype, try checking against that.
4021 Otherwise, use force_fit_type, which checks against the precision. */
4022 if (TYPE_MAX_VALUE (type) != NULL_TREE
4023 && TYPE_MIN_VALUE (type) != NULL_TREE
4024 && TREE_CODE (TYPE_MAX_VALUE (type)) == INTEGER_CST
4025 && TREE_CODE (TYPE_MIN_VALUE (type)) == INTEGER_CST)
4027 if (TREE_UNSIGNED (type))
4028 return (! INT_CST_LT_UNSIGNED (TYPE_MAX_VALUE (type), c)
4029 && ! INT_CST_LT_UNSIGNED (c, TYPE_MIN_VALUE (type))
4030 /* Negative ints never fit unsigned types. */
4031 && ! (TREE_INT_CST_HIGH (c) < 0
4032 && ! TREE_UNSIGNED (TREE_TYPE (c))));
4034 return (! INT_CST_LT (TYPE_MAX_VALUE (type), c)
4035 && ! INT_CST_LT (c, TYPE_MIN_VALUE (type))
4036 /* Unsigned ints with top bit set never fit signed types. */
4037 && ! (TREE_INT_CST_HIGH (c) < 0
4038 && TREE_UNSIGNED (TREE_TYPE (c))));
4040 else if (TREE_CODE (type) == INTEGER_TYPE && TREE_TYPE (type) != 0)
4041 return int_fits_type_p (c, TREE_TYPE (type));
4045 TREE_TYPE (c) = type;
4046 return !force_fit_type (c, 0);
4050 /* Returns true if T is, contains, or refers to a type with variable
4051 size. This concept is more general than that of C99 'variably
4052 modified types': in C99, a struct type is never variably modified
4053 because a VLA may not appear as a structure member. However, in
4056 struct S { int i[f()]; };
4058 is valid, and other languages may define similar constructs. */
4061 variably_modified_type_p (type)
4064 if (type == error_mark_node)
4067 /* If TYPE itself has variable size, it is variably modified.
4069 We do not yet have a representation of the C99 '[*]' syntax.
4070 When a representation is chosen, this function should be modified
4071 to test for that case as well. */
4072 if (TYPE_SIZE (type)
4073 && TYPE_SIZE (type) != error_mark_node
4074 && TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
4077 /* If TYPE is a pointer or reference, it is variably modified if
4078 the type pointed to is variably modified. */
4079 if ((TREE_CODE (type) == POINTER_TYPE
4080 || TREE_CODE (type) == REFERENCE_TYPE)
4081 && variably_modified_type_p (TREE_TYPE (type)))
4084 /* If TYPE is an array, it is variably modified if the array
4085 elements are. (Note that the VLA case has already been checked
4087 if (TREE_CODE (type) == ARRAY_TYPE
4088 && variably_modified_type_p (TREE_TYPE (type)))
4091 /* If TYPE is a function type, it is variably modified if any of the
4092 parameters or the return type are variably modified. */
4093 if (TREE_CODE (type) == FUNCTION_TYPE
4094 || TREE_CODE (type) == METHOD_TYPE)
4098 if (variably_modified_type_p (TREE_TYPE (type)))
4100 for (parm = TYPE_ARG_TYPES (type);
4101 parm && parm != void_list_node;
4102 parm = TREE_CHAIN (parm))
4103 if (variably_modified_type_p (TREE_VALUE (parm)))
4107 /* The current language may have other cases to check, but in general,
4108 all other types are not variably modified. */
4109 return (*lang_hooks.tree_inlining.var_mod_type_p) (type);
4112 /* Given a DECL or TYPE, return the scope in which it was declared, or
4113 NULL_TREE if there is no containing scope. */
4116 get_containing_scope (t)
4119 return (TYPE_P (t) ? TYPE_CONTEXT (t) : DECL_CONTEXT (t));
4122 /* Return the innermost context enclosing DECL that is
4123 a FUNCTION_DECL, or zero if none. */
4126 decl_function_context (decl)
4131 if (TREE_CODE (decl) == ERROR_MARK)
4134 if (TREE_CODE (decl) == SAVE_EXPR)
4135 context = SAVE_EXPR_CONTEXT (decl);
4137 /* C++ virtual functions use DECL_CONTEXT for the class of the vtable
4138 where we look up the function at runtime. Such functions always take
4139 a first argument of type 'pointer to real context'.
4141 C++ should really be fixed to use DECL_CONTEXT for the real context,
4142 and use something else for the "virtual context". */
4143 else if (TREE_CODE (decl) == FUNCTION_DECL && DECL_VINDEX (decl))
4146 (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl)))));
4148 context = DECL_CONTEXT (decl);
4150 while (context && TREE_CODE (context) != FUNCTION_DECL)
4152 if (TREE_CODE (context) == BLOCK)
4153 context = BLOCK_SUPERCONTEXT (context);
4155 context = get_containing_scope (context);
4161 /* Return the innermost context enclosing DECL that is
4162 a RECORD_TYPE, UNION_TYPE or QUAL_UNION_TYPE, or zero if none.
4163 TYPE_DECLs and FUNCTION_DECLs are transparent to this function. */
4166 decl_type_context (decl)
4169 tree context = DECL_CONTEXT (decl);
4173 if (TREE_CODE (context) == NAMESPACE_DECL)
4176 if (TREE_CODE (context) == RECORD_TYPE
4177 || TREE_CODE (context) == UNION_TYPE
4178 || TREE_CODE (context) == QUAL_UNION_TYPE)
4181 if (TREE_CODE (context) == TYPE_DECL
4182 || TREE_CODE (context) == FUNCTION_DECL)
4183 context = DECL_CONTEXT (context);
4185 else if (TREE_CODE (context) == BLOCK)
4186 context = BLOCK_SUPERCONTEXT (context);
4189 /* Unhandled CONTEXT!? */
4195 /* CALL is a CALL_EXPR. Return the declaration for the function
4196 called, or NULL_TREE if the called function cannot be
4200 get_callee_fndecl (call)
4205 /* It's invalid to call this function with anything but a
4207 if (TREE_CODE (call) != CALL_EXPR)
4210 /* The first operand to the CALL is the address of the function
4212 addr = TREE_OPERAND (call, 0);
4216 /* If this is a readonly function pointer, extract its initial value. */
4217 if (DECL_P (addr) && TREE_CODE (addr) != FUNCTION_DECL
4218 && TREE_READONLY (addr) && ! TREE_THIS_VOLATILE (addr)
4219 && DECL_INITIAL (addr))
4220 addr = DECL_INITIAL (addr);
4222 /* If the address is just `&f' for some function `f', then we know
4223 that `f' is being called. */
4224 if (TREE_CODE (addr) == ADDR_EXPR
4225 && TREE_CODE (TREE_OPERAND (addr, 0)) == FUNCTION_DECL)
4226 return TREE_OPERAND (addr, 0);
4228 /* We couldn't figure out what was being called. */
4232 /* Print debugging information about the obstack O, named STR. */
4235 print_obstack_statistics (str, o)
4239 struct _obstack_chunk *chunk = o->chunk;
4243 n_alloc += o->next_free - chunk->contents;
4244 chunk = chunk->prev;
4248 n_alloc += chunk->limit - &chunk->contents[0];
4249 chunk = chunk->prev;
4251 fprintf (stderr, "obstack %s: %u bytes, %d chunks\n",
4252 str, n_alloc, n_chunks);
4255 /* Print debugging information about tree nodes generated during the compile,
4256 and any language-specific information. */
4259 dump_tree_statistics ()
4261 #ifdef GATHER_STATISTICS
4263 int total_nodes, total_bytes;
4266 fprintf (stderr, "\n??? tree nodes created\n\n");
4267 #ifdef GATHER_STATISTICS
4268 fprintf (stderr, "Kind Nodes Bytes\n");
4269 fprintf (stderr, "-------------------------------------\n");
4270 total_nodes = total_bytes = 0;
4271 for (i = 0; i < (int) all_kinds; i++)
4273 fprintf (stderr, "%-20s %6d %9d\n", tree_node_kind_names[i],
4274 tree_node_counts[i], tree_node_sizes[i]);
4275 total_nodes += tree_node_counts[i];
4276 total_bytes += tree_node_sizes[i];
4278 fprintf (stderr, "-------------------------------------\n");
4279 fprintf (stderr, "%-20s %6d %9d\n", "Total", total_nodes, total_bytes);
4280 fprintf (stderr, "-------------------------------------\n");
4282 fprintf (stderr, "(No per-node statistics)\n");
4284 print_type_hash_statistics ();
4285 (*lang_hooks.print_statistics) ();
4288 #define FILE_FUNCTION_FORMAT "_GLOBAL__%s_%s"
4290 /* Appends 6 random characters to TEMPLATE to (hopefully) avoid name
4291 clashes in cases where we can't reliably choose a unique name.
4293 Derived from mkstemp.c in libiberty. */
4296 append_random_chars (template)
4299 static const char letters[]
4300 = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
4301 static unsigned HOST_WIDE_INT value;
4302 unsigned HOST_WIDE_INT v;
4308 /* VALUE should be unique for each file and must not change between
4309 compiles since this can cause bootstrap comparison errors. */
4311 if (stat (main_input_filename, &st) < 0)
4313 /* This can happen when preprocessed text is shipped between
4314 machines, e.g. with bug reports. Assume that uniqueness
4315 isn't actually an issue. */
4320 /* In VMS, ino is an array, so we have to use both values. We
4321 conditionalize that. */
4323 #define INO_TO_INT(INO) ((int) (INO)[1] << 16 ^ (int) (INO)[2])
4325 #define INO_TO_INT(INO) INO
4327 value = st.st_dev ^ INO_TO_INT (st.st_ino) ^ st.st_mtime;
4331 template += strlen (template);
4335 /* Fill in the random bits. */
4336 template[0] = letters[v % 62];
4338 template[1] = letters[v % 62];
4340 template[2] = letters[v % 62];
4342 template[3] = letters[v % 62];
4344 template[4] = letters[v % 62];
4346 template[5] = letters[v % 62];
4351 /* P is a string that will be used in a symbol. Mask out any characters
4352 that are not valid in that context. */
4355 clean_symbol_name (p)
4360 #ifndef NO_DOLLAR_IN_LABEL /* this for `$'; unlikely, but... -- kr */
4363 #ifndef NO_DOT_IN_LABEL /* this for `.'; unlikely, but... */
4370 /* Generate a name for a function unique to this translation unit.
4371 TYPE is some string to identify the purpose of this function to the
4372 linker or collect2. */
4375 get_file_function_name_long (type)
4382 if (first_global_object_name)
4383 p = first_global_object_name;
4386 /* We don't have anything that we know to be unique to this translation
4387 unit, so use what we do have and throw in some randomness. */
4389 const char *name = weak_global_object_name;
4390 const char *file = main_input_filename;
4395 file = input_filename;
4397 q = (char *) alloca (7 + strlen (name) + strlen (file));
4399 sprintf (q, "%s%s", name, file);
4400 append_random_chars (q);
4404 buf = (char *) alloca (sizeof (FILE_FUNCTION_FORMAT) + strlen (p)
4407 /* Set up the name of the file-level functions we may need.
4408 Use a global object (which is already required to be unique over
4409 the program) rather than the file name (which imposes extra
4411 sprintf (buf, FILE_FUNCTION_FORMAT, type, p);
4413 /* Don't need to pull weird characters out of global names. */
4414 if (p != first_global_object_name)
4415 clean_symbol_name (buf + 11);
4417 return get_identifier (buf);
4420 /* If KIND=='I', return a suitable global initializer (constructor) name.
4421 If KIND=='D', return a suitable global clean-up (destructor) name. */
4424 get_file_function_name (kind)
4432 return get_file_function_name_long (p);
4435 /* Expand (the constant part of) a SET_TYPE CONSTRUCTOR node.
4436 The result is placed in BUFFER (which has length BIT_SIZE),
4437 with one bit in each char ('\000' or '\001').
4439 If the constructor is constant, NULL_TREE is returned.
4440 Otherwise, a TREE_LIST of the non-constant elements is emitted. */
4443 get_set_constructor_bits (init, buffer, bit_size)
4450 HOST_WIDE_INT domain_min
4451 = tree_low_cst (TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (init))), 0);
4452 tree non_const_bits = NULL_TREE;
4454 for (i = 0; i < bit_size; i++)
4457 for (vals = TREE_OPERAND (init, 1);
4458 vals != NULL_TREE; vals = TREE_CHAIN (vals))
4460 if (!host_integerp (TREE_VALUE (vals), 0)
4461 || (TREE_PURPOSE (vals) != NULL_TREE
4462 && !host_integerp (TREE_PURPOSE (vals), 0)))
4464 = tree_cons (TREE_PURPOSE (vals), TREE_VALUE (vals), non_const_bits);
4465 else if (TREE_PURPOSE (vals) != NULL_TREE)
4467 /* Set a range of bits to ones. */
4468 HOST_WIDE_INT lo_index
4469 = tree_low_cst (TREE_PURPOSE (vals), 0) - domain_min;
4470 HOST_WIDE_INT hi_index
4471 = tree_low_cst (TREE_VALUE (vals), 0) - domain_min;
4473 if (lo_index < 0 || lo_index >= bit_size
4474 || hi_index < 0 || hi_index >= bit_size)
4476 for (; lo_index <= hi_index; lo_index++)
4477 buffer[lo_index] = 1;
4481 /* Set a single bit to one. */
4483 = tree_low_cst (TREE_VALUE (vals), 0) - domain_min;
4484 if (index < 0 || index >= bit_size)
4486 error ("invalid initializer for bit string");
4492 return non_const_bits;
4495 /* Expand (the constant part of) a SET_TYPE CONSTRUCTOR node.
4496 The result is placed in BUFFER (which is an array of bytes).
4497 If the constructor is constant, NULL_TREE is returned.
4498 Otherwise, a TREE_LIST of the non-constant elements is emitted. */
4501 get_set_constructor_bytes (init, buffer, wd_size)
4503 unsigned char *buffer;
4507 int set_word_size = BITS_PER_UNIT;
4508 int bit_size = wd_size * set_word_size;
4510 unsigned char *bytep = buffer;
4511 char *bit_buffer = (char *) alloca (bit_size);
4512 tree non_const_bits = get_set_constructor_bits (init, bit_buffer, bit_size);
4514 for (i = 0; i < wd_size; i++)
4517 for (i = 0; i < bit_size; i++)
4521 if (BYTES_BIG_ENDIAN)
4522 *bytep |= (1 << (set_word_size - 1 - bit_pos));
4524 *bytep |= 1 << bit_pos;
4527 if (bit_pos >= set_word_size)
4528 bit_pos = 0, bytep++;
4530 return non_const_bits;
4533 #if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
4534 /* Complain that the tree code of NODE does not match the expected CODE.
4535 FILE, LINE, and FUNCTION are of the caller. */
4538 tree_check_failed (node, code, file, line, function)
4540 enum tree_code code;
4543 const char *function;
4545 internal_error ("tree check: expected %s, have %s in %s, at %s:%d",
4546 tree_code_name[code], tree_code_name[TREE_CODE (node)],
4547 function, trim_filename (file), line);
4550 /* Similar to above, except that we check for a class of tree
4551 code, given in CL. */
4554 tree_class_check_failed (node, cl, file, line, function)
4559 const char *function;
4562 ("tree check: expected class '%c', have '%c' (%s) in %s, at %s:%d",
4563 cl, TREE_CODE_CLASS (TREE_CODE (node)),
4564 tree_code_name[TREE_CODE (node)], function, trim_filename (file), line);
4567 /* Similar to above, except that the check is for the bounds of a TREE_VEC's
4568 (dynamically sized) vector. */
4571 tree_vec_elt_check_failed (idx, len, file, line, function)
4576 const char *function;
4579 ("tree check: accessed elt %d of tree_vec with %d elts in %s, at %s:%d",
4580 idx + 1, len, function, trim_filename (file), line);
4583 #endif /* ENABLE_TREE_CHECKING */
4585 /* For a new vector type node T, build the information necessary for
4586 debugging output. */
4589 finish_vector_type (t)
4595 tree index = build_int_2 (TYPE_VECTOR_SUBPARTS (t) - 1, 0);
4596 tree array = build_array_type (TREE_TYPE (t),
4597 build_index_type (index));
4598 tree rt = make_node (RECORD_TYPE);
4600 TYPE_FIELDS (rt) = build_decl (FIELD_DECL, get_identifier ("f"), array);
4601 DECL_CONTEXT (TYPE_FIELDS (rt)) = rt;
4603 TYPE_DEBUG_REPRESENTATION_TYPE (t) = rt;
4604 /* In dwarfout.c, type lookup uses TYPE_UID numbers. We want to output
4605 the representation type, and we want to find that die when looking up
4606 the vector type. This is most easily achieved by making the TYPE_UID
4608 TYPE_UID (rt) = TYPE_UID (t);
4612 /* Create nodes for all integer types (and error_mark_node) using the sizes
4613 of C datatypes. The caller should call set_sizetype soon after calling
4614 this function to select one of the types as sizetype. */
4617 build_common_tree_nodes (signed_char)
4620 error_mark_node = make_node (ERROR_MARK);
4621 TREE_TYPE (error_mark_node) = error_mark_node;
4623 initialize_sizetypes ();
4625 /* Define both `signed char' and `unsigned char'. */
4626 signed_char_type_node = make_signed_type (CHAR_TYPE_SIZE);
4627 unsigned_char_type_node = make_unsigned_type (CHAR_TYPE_SIZE);
4629 /* Define `char', which is like either `signed char' or `unsigned char'
4630 but not the same as either. */
4633 ? make_signed_type (CHAR_TYPE_SIZE)
4634 : make_unsigned_type (CHAR_TYPE_SIZE));
4636 short_integer_type_node = make_signed_type (SHORT_TYPE_SIZE);
4637 short_unsigned_type_node = make_unsigned_type (SHORT_TYPE_SIZE);
4638 integer_type_node = make_signed_type (INT_TYPE_SIZE);
4639 unsigned_type_node = make_unsigned_type (INT_TYPE_SIZE);
4640 long_integer_type_node = make_signed_type (LONG_TYPE_SIZE);
4641 long_unsigned_type_node = make_unsigned_type (LONG_TYPE_SIZE);
4642 long_long_integer_type_node = make_signed_type (LONG_LONG_TYPE_SIZE);
4643 long_long_unsigned_type_node = make_unsigned_type (LONG_LONG_TYPE_SIZE);
4645 intQI_type_node = make_signed_type (GET_MODE_BITSIZE (QImode));
4646 intHI_type_node = make_signed_type (GET_MODE_BITSIZE (HImode));
4647 intSI_type_node = make_signed_type (GET_MODE_BITSIZE (SImode));
4648 intDI_type_node = make_signed_type (GET_MODE_BITSIZE (DImode));
4649 intTI_type_node = make_signed_type (GET_MODE_BITSIZE (TImode));
4651 unsigned_intQI_type_node = make_unsigned_type (GET_MODE_BITSIZE (QImode));
4652 unsigned_intHI_type_node = make_unsigned_type (GET_MODE_BITSIZE (HImode));
4653 unsigned_intSI_type_node = make_unsigned_type (GET_MODE_BITSIZE (SImode));
4654 unsigned_intDI_type_node = make_unsigned_type (GET_MODE_BITSIZE (DImode));
4655 unsigned_intTI_type_node = make_unsigned_type (GET_MODE_BITSIZE (TImode));
4658 /* Call this function after calling build_common_tree_nodes and set_sizetype.
4659 It will create several other common tree nodes. */
4662 build_common_tree_nodes_2 (short_double)
4665 /* Define these next since types below may used them. */
4666 integer_zero_node = build_int_2 (0, 0);
4667 integer_one_node = build_int_2 (1, 0);
4668 integer_minus_one_node = build_int_2 (-1, -1);
4670 size_zero_node = size_int (0);
4671 size_one_node = size_int (1);
4672 bitsize_zero_node = bitsize_int (0);
4673 bitsize_one_node = bitsize_int (1);
4674 bitsize_unit_node = bitsize_int (BITS_PER_UNIT);
4676 void_type_node = make_node (VOID_TYPE);
4677 layout_type (void_type_node);
4679 /* We are not going to have real types in C with less than byte alignment,
4680 so we might as well not have any types that claim to have it. */
4681 TYPE_ALIGN (void_type_node) = BITS_PER_UNIT;
4682 TYPE_USER_ALIGN (void_type_node) = 0;
4684 null_pointer_node = build_int_2 (0, 0);
4685 TREE_TYPE (null_pointer_node) = build_pointer_type (void_type_node);
4686 layout_type (TREE_TYPE (null_pointer_node));
4688 ptr_type_node = build_pointer_type (void_type_node);
4690 = build_pointer_type (build_type_variant (void_type_node, 1, 0));
4692 float_type_node = make_node (REAL_TYPE);
4693 TYPE_PRECISION (float_type_node) = FLOAT_TYPE_SIZE;
4694 layout_type (float_type_node);
4696 double_type_node = make_node (REAL_TYPE);
4698 TYPE_PRECISION (double_type_node) = FLOAT_TYPE_SIZE;
4700 TYPE_PRECISION (double_type_node) = DOUBLE_TYPE_SIZE;
4701 layout_type (double_type_node);
4703 long_double_type_node = make_node (REAL_TYPE);
4704 TYPE_PRECISION (long_double_type_node) = LONG_DOUBLE_TYPE_SIZE;
4705 layout_type (long_double_type_node);
4707 complex_integer_type_node = make_node (COMPLEX_TYPE);
4708 TREE_TYPE (complex_integer_type_node) = integer_type_node;
4709 layout_type (complex_integer_type_node);
4711 complex_float_type_node = make_node (COMPLEX_TYPE);
4712 TREE_TYPE (complex_float_type_node) = float_type_node;
4713 layout_type (complex_float_type_node);
4715 complex_double_type_node = make_node (COMPLEX_TYPE);
4716 TREE_TYPE (complex_double_type_node) = double_type_node;
4717 layout_type (complex_double_type_node);
4719 complex_long_double_type_node = make_node (COMPLEX_TYPE);
4720 TREE_TYPE (complex_long_double_type_node) = long_double_type_node;
4721 layout_type (complex_long_double_type_node);
4725 BUILD_VA_LIST_TYPE (t);
4727 /* Many back-ends define record types without seting TYPE_NAME.
4728 If we copied the record type here, we'd keep the original
4729 record type without a name. This breaks name mangling. So,
4730 don't copy record types and let c_common_nodes_and_builtins()
4731 declare the type to be __builtin_va_list. */
4732 if (TREE_CODE (t) != RECORD_TYPE)
4733 t = build_type_copy (t);
4735 va_list_type_node = t;
4738 unsigned_V4SI_type_node
4739 = make_vector (V4SImode, unsigned_intSI_type_node, 1);
4740 unsigned_V2HI_type_node
4741 = make_vector (V2HImode, unsigned_intHI_type_node, 1);
4742 unsigned_V2SI_type_node
4743 = make_vector (V2SImode, unsigned_intSI_type_node, 1);
4744 unsigned_V2DI_type_node
4745 = make_vector (V2DImode, unsigned_intDI_type_node, 1);
4746 unsigned_V4HI_type_node
4747 = make_vector (V4HImode, unsigned_intHI_type_node, 1);
4748 unsigned_V8QI_type_node
4749 = make_vector (V8QImode, unsigned_intQI_type_node, 1);
4750 unsigned_V8HI_type_node
4751 = make_vector (V8HImode, unsigned_intHI_type_node, 1);
4752 unsigned_V16QI_type_node
4753 = make_vector (V16QImode, unsigned_intQI_type_node, 1);
4754 unsigned_V1DI_type_node
4755 = make_vector (V1DImode, unsigned_intDI_type_node, 1);
4757 V16SF_type_node = make_vector (V16SFmode, float_type_node, 0);
4758 V4SF_type_node = make_vector (V4SFmode, float_type_node, 0);
4759 V4SI_type_node = make_vector (V4SImode, intSI_type_node, 0);
4760 V2HI_type_node = make_vector (V2HImode, intHI_type_node, 0);
4761 V2SI_type_node = make_vector (V2SImode, intSI_type_node, 0);
4762 V2DI_type_node = make_vector (V2DImode, intDI_type_node, 0);
4763 V4HI_type_node = make_vector (V4HImode, intHI_type_node, 0);
4764 V8QI_type_node = make_vector (V8QImode, intQI_type_node, 0);
4765 V8HI_type_node = make_vector (V8HImode, intHI_type_node, 0);
4766 V2SF_type_node = make_vector (V2SFmode, float_type_node, 0);
4767 V2DF_type_node = make_vector (V2DFmode, double_type_node, 0);
4768 V16QI_type_node = make_vector (V16QImode, intQI_type_node, 0);
4769 V1DI_type_node = make_vector (V1DImode, intDI_type_node, 0);
4772 /* Returns a vector tree node given a vector mode, the inner type, and
4776 make_vector (mode, innertype, unsignedp)
4777 enum machine_mode mode;
4783 t = make_node (VECTOR_TYPE);
4784 TREE_TYPE (t) = innertype;
4785 TYPE_MODE (t) = mode;
4786 TREE_UNSIGNED (TREE_TYPE (t)) = unsignedp;
4787 finish_vector_type (t);
4792 /* Given an initializer INIT, return TRUE if INIT is zero or some
4793 aggregate of zeros. Otherwise return FALSE. */
4796 initializer_zerop (init)
4801 switch (TREE_CODE (init))
4804 return integer_zerop (init);
4806 return real_zerop (init)
4807 && ! REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (init));
4809 return integer_zerop (init)
4810 || (real_zerop (init)
4811 && ! REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (TREE_REALPART (init)))
4812 && ! REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (TREE_IMAGPART (init))));
4815 if (AGGREGATE_TYPE_P (TREE_TYPE (init)))
4817 tree aggr_init = TREE_OPERAND (init, 1);
4821 if (! initializer_zerop (TREE_VALUE (aggr_init)))
4823 aggr_init = TREE_CHAIN (aggr_init);
4834 #include "gt-tree.h"