diff options
Diffstat (limited to 'contrib/gcc/tree.c')
| -rw-r--r-- | contrib/gcc/tree.c | 1661 |
1 files changed, 903 insertions, 758 deletions
diff --git a/contrib/gcc/tree.c b/contrib/gcc/tree.c index e8c2541..32f1c18 100644 --- a/contrib/gcc/tree.c +++ b/contrib/gcc/tree.c @@ -1,6 +1,6 @@ /* Language-independent node constructors for parse phase of GNU compiler. Copyright (C) 1987, 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998, - 1999, 2000, 2001, 2002 Free Software Foundation, Inc. + 1999, 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc. This file is part of GCC. @@ -31,6 +31,8 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA #include "config.h" #include "system.h" +#include "coretypes.h" +#include "tm.h" #include "flags.h" #include "tree.h" #include "real.h" @@ -45,32 +47,15 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA #include "langhooks.h" /* obstack.[ch] explicitly declined to prototype this. */ -extern int _obstack_allocated_p PARAMS ((struct obstack *h, PTR obj)); +extern int _obstack_allocated_p (struct obstack *h, void *obj); #ifdef GATHER_STATISTICS /* Statistics-gathering stuff. */ -typedef enum -{ - d_kind, - t_kind, - b_kind, - s_kind, - r_kind, - e_kind, - c_kind, - id_kind, - perm_list_kind, - temp_list_kind, - vec_kind, - x_kind, - lang_decl, - lang_type, - all_kinds -} tree_node_kind; int tree_node_counts[(int) all_kinds]; int tree_node_sizes[(int) all_kinds]; +/* Keep in sync with tree.h:enum tree_node_kind. */ static const char * const tree_node_kind_names[] = { "decls", "types", @@ -90,9 +75,9 @@ static const char * const tree_node_kind_names[] = { #endif /* GATHER_STATISTICS */ /* Unique id for next decl created. */ -static int next_decl_uid; +static GTY(()) int next_decl_uid; /* Unique id for next type created. */ -static int next_type_uid = 1; +static GTY(()) int next_type_uid = 1; /* Since we cannot rehash a type after it is in the table, we have to keep the hash code. */ @@ -116,14 +101,13 @@ struct type_hash GTY(()) static GTY ((if_marked ("type_hash_marked_p"), param_is (struct type_hash))) htab_t type_hash_table; -static void set_type_quals PARAMS ((tree, int)); -static void append_random_chars PARAMS ((char *)); -static int type_hash_eq PARAMS ((const void *, const void *)); -static hashval_t type_hash_hash PARAMS ((const void *)); -static void print_type_hash_statistics PARAMS((void)); -static void finish_vector_type PARAMS((tree)); -static tree make_vector PARAMS ((enum machine_mode, tree, int)); -static int type_hash_marked_p PARAMS ((const void *)); +static void set_type_quals (tree, int); +static int type_hash_eq (const void *, const void *); +static hashval_t type_hash_hash (const void *); +static void print_type_hash_statistics (void); +static void finish_vector_type (tree); +static tree make_vector (enum machine_mode, tree, int); +static int type_hash_marked_p (const void *); tree global_trees[TI_MAX]; tree integer_types[itk_none]; @@ -131,11 +115,11 @@ tree integer_types[itk_none]; /* Init tree.c. */ void -init_ttree () +init_ttree (void) { /* Initialize the hash table of types. */ - type_hash_table = htab_create (TYPE_HASH_INITIAL_SIZE, type_hash_hash, - type_hash_eq, 0); + type_hash_table = htab_create_ggc (TYPE_HASH_INITIAL_SIZE, type_hash_hash, + type_hash_eq, 0); } @@ -143,8 +127,7 @@ init_ttree () translations made by ASM_OUTPUT_LABELREF). Often this is the same as DECL_NAME. It is an IDENTIFIER_NODE. */ tree -decl_assembler_name (decl) - tree decl; +decl_assembler_name (tree decl) { if (!DECL_ASSEMBLER_NAME_SET_P (decl)) (*lang_hooks.set_decl_assembler_name) (decl); @@ -154,8 +137,7 @@ decl_assembler_name (decl) /* Compute the number of bytes occupied by 'node'. This routine only looks at TREE_CODE and, if the code is TREE_VEC, TREE_VEC_LENGTH. */ size_t -tree_size (node) - tree node; +tree_size (tree node) { enum tree_code code = TREE_CODE (node); @@ -180,28 +162,32 @@ tree_size (node) + TREE_CODE_LENGTH (code) * sizeof (char *) - sizeof (char *)); case 'c': /* a constant */ - /* We can't use TREE_CODE_LENGTH for INTEGER_CST, since the number of - words is machine-dependent due to varying length of HOST_WIDE_INT, - which might be wider than a pointer (e.g., long long). Similarly - for REAL_CST, since the number of words is machine-dependent due - to varying size and alignment of `double'. */ - if (code == INTEGER_CST) - return sizeof (struct tree_int_cst); - else if (code == REAL_CST) - return sizeof (struct tree_real_cst); - else - return (sizeof (struct tree_common) - + TREE_CODE_LENGTH (code) * sizeof (char *)); + switch (code) + { + case INTEGER_CST: return sizeof (struct tree_int_cst); + case REAL_CST: return sizeof (struct tree_real_cst); + case COMPLEX_CST: return sizeof (struct tree_complex); + case VECTOR_CST: return sizeof (struct tree_vector); + case STRING_CST: return sizeof (struct tree_string); + default: + return (*lang_hooks.tree_size) (code); + } case 'x': /* something random, like an identifier. */ - { - size_t length; - length = (sizeof (struct tree_common) - + TREE_CODE_LENGTH (code) * sizeof (char *)); - if (code == TREE_VEC) - length += TREE_VEC_LENGTH (node) * sizeof (char *) - sizeof (char *); - return length; - } + switch (code) + { + case IDENTIFIER_NODE: return lang_hooks.identifier_size; + case TREE_LIST: return sizeof (struct tree_list); + case TREE_VEC: return (sizeof (struct tree_vec) + + TREE_VEC_LENGTH(node) * sizeof(char *) + - sizeof (char *)); + + case ERROR_MARK: + case PLACEHOLDER_EXPR: return sizeof (struct tree_common); + + default: + return (*lang_hooks.tree_size) (code); + } default: abort (); @@ -215,8 +201,7 @@ tree_size (node) Achoo! I got a code in the node. */ tree -make_node (code) - enum tree_code code; +make_node (enum tree_code code) { tree t; int type = TREE_CODE_CLASS (code); @@ -287,7 +272,7 @@ make_node (code) t = ggc_alloc_tree (length); - memset ((PTR) t, 0, length); + memset (t, 0, length); TREE_SET_CODE (t, code); @@ -295,7 +280,6 @@ make_node (code) { case 's': TREE_SIDE_EFFECTS (t) = 1; - TREE_TYPE (t) = void_type_node; break; case 'd': @@ -303,9 +287,7 @@ make_node (code) DECL_ALIGN (t) = 1; DECL_USER_ALIGN (t) = 0; DECL_IN_SYSTEM_HEADER (t) = in_system_header; - DECL_SOURCE_LINE (t) = lineno; - DECL_SOURCE_FILE (t) = - (input_filename) ? input_filename : "<built-in>"; + DECL_SOURCE_LOCATION (t) = input_location; DECL_UID (t) = next_decl_uid++; /* We have not yet computed the alias set for this declaration. */ @@ -359,8 +341,7 @@ make_node (code) TREE_CHAIN is zero and it has a fresh uid. */ tree -copy_node (node) - tree node; +copy_node (tree node) { tree t; enum tree_code code = TREE_CODE (node); @@ -394,8 +375,7 @@ copy_node (node) For example, this can copy a list made of TREE_LIST nodes. */ tree -copy_list (list) - tree list; +copy_list (tree list) { tree head; tree prev, next; @@ -422,9 +402,7 @@ copy_list (list) This function should be used via the `build_int_2' macro. */ tree -build_int_2_wide (low, hi) - unsigned HOST_WIDE_INT low; - HOST_WIDE_INT hi; +build_int_2_wide (unsigned HOST_WIDE_INT low, HOST_WIDE_INT hi) { tree t = make_node (INTEGER_CST); @@ -438,8 +416,7 @@ build_int_2_wide (low, hi) are in a list pointed by VALS. */ tree -build_vector (type, vals) - tree type, vals; +build_vector (tree type, tree vals) { tree v = make_node (VECTOR_CST); int over1 = 0, over2 = 0; @@ -463,12 +440,32 @@ build_vector (type, vals) return v; } +/* Return a new CONSTRUCTOR node whose type is TYPE and whose values + are in a list pointed to by VALS. */ +tree +build_constructor (tree type, tree vals) +{ + tree c = make_node (CONSTRUCTOR); + TREE_TYPE (c) = type; + CONSTRUCTOR_ELTS (c) = vals; + + /* ??? May not be necessary. Mirrors what build does. */ + if (vals) + { + TREE_SIDE_EFFECTS (c) = TREE_SIDE_EFFECTS (vals); + TREE_READONLY (c) = TREE_READONLY (vals); + TREE_CONSTANT (c) = TREE_CONSTANT (vals); + } + else + TREE_CONSTANT (c) = 0; /* safe side */ + + return c; +} + /* Return a new REAL_CST node whose type is TYPE and value is D. */ tree -build_real (type, d) - tree type; - REAL_VALUE_TYPE d; +build_real (tree type, REAL_VALUE_TYPE d) { tree v; REAL_VALUE_TYPE *dp; @@ -491,21 +488,17 @@ build_real (type, d) and whose value is the integer value of the INTEGER_CST node I. */ REAL_VALUE_TYPE -real_value_from_int_cst (type, i) - tree type ATTRIBUTE_UNUSED, i; +real_value_from_int_cst (tree type, tree i) { REAL_VALUE_TYPE d; /* Clear all bits of the real value type so that we can later do bitwise comparisons to see if two values are the same. */ - memset ((char *) &d, 0, sizeof d); + memset (&d, 0, sizeof d); - if (! TREE_UNSIGNED (TREE_TYPE (i))) - REAL_VALUE_FROM_INT (d, TREE_INT_CST_LOW (i), TREE_INT_CST_HIGH (i), - TYPE_MODE (type)); - else - REAL_VALUE_FROM_UNSIGNED_INT (d, TREE_INT_CST_LOW (i), - TREE_INT_CST_HIGH (i), TYPE_MODE (type)); + real_from_integer (&d, type ? TYPE_MODE (type) : VOIDmode, + TREE_INT_CST_LOW (i), TREE_INT_CST_HIGH (i), + TREE_UNSIGNED (TREE_TYPE (i))); return d; } @@ -513,9 +506,7 @@ real_value_from_int_cst (type, i) representing the same value as a floating-point constant of type TYPE. */ tree -build_real_from_int_cst (type, i) - tree type; - tree i; +build_real_from_int_cst (tree type, tree i) { tree v; int overflow = TREE_OVERFLOW (i); @@ -532,9 +523,7 @@ build_real_from_int_cst (type, i) The TREE_TYPE is not initialized. */ tree -build_string (len, str) - int len; - const char *str; +build_string (int len, const char *str) { tree s = make_node (STRING_CST); @@ -550,9 +539,7 @@ build_string (len, str) will be the type of the COMPLEX_CST; otherwise a new type will be made. */ tree -build_complex (type, real, imag) - tree type; - tree real, imag; +build_complex (tree type, tree real, tree imag) { tree t = make_node (COMPLEX_CST); @@ -568,8 +555,7 @@ build_complex (type, real, imag) /* Build a newly constructed TREE_VEC node of length LEN. */ tree -make_tree_vec (len) - int len; +make_tree_vec (int len) { tree t; int length = (len - 1) * sizeof (tree) + sizeof (struct tree_vec); @@ -581,7 +567,7 @@ make_tree_vec (len) t = ggc_alloc_tree (length); - memset ((PTR) t, 0, length); + memset (t, 0, length); TREE_SET_CODE (t, TREE_VEC); TREE_VEC_LENGTH (t) = len; @@ -592,8 +578,7 @@ make_tree_vec (len) of zero. */ int -integer_zerop (expr) - tree expr; +integer_zerop (tree expr) { STRIP_NOPS (expr); @@ -610,8 +595,7 @@ integer_zerop (expr) complex constant. */ int -integer_onep (expr) - tree expr; +integer_onep (tree expr) { STRIP_NOPS (expr); @@ -628,8 +612,7 @@ integer_onep (expr) it contains. Likewise for the corresponding complex constant. */ int -integer_all_onesp (expr) - tree expr; +integer_all_onesp (tree expr) { int prec; int uns; @@ -681,8 +664,7 @@ integer_all_onesp (expr) one bit on). */ int -integer_pow2p (expr) - tree expr; +integer_pow2p (tree expr) { int prec; HOST_WIDE_INT high, low; @@ -723,12 +705,28 @@ integer_pow2p (expr) || (low == 0 && (high & (high - 1)) == 0)); } +/* Return 1 if EXPR is an integer constant other than zero or a + complex constant other than zero. */ + +int +integer_nonzerop (tree expr) +{ + STRIP_NOPS (expr); + + return ((TREE_CODE (expr) == INTEGER_CST + && ! TREE_CONSTANT_OVERFLOW (expr) + && (TREE_INT_CST_LOW (expr) != 0 + || TREE_INT_CST_HIGH (expr) != 0)) + || (TREE_CODE (expr) == COMPLEX_CST + && (integer_nonzerop (TREE_REALPART (expr)) + || integer_nonzerop (TREE_IMAGPART (expr))))); +} + /* Return the power of two represented by a tree node known to be a power of two. */ int -tree_log2 (expr) - tree expr; +tree_log2 (tree expr) { int prec; HOST_WIDE_INT high, low; @@ -766,8 +764,7 @@ tree_log2 (expr) than or equal to EXPR. */ int -tree_floor_log2 (expr) - tree expr; +tree_floor_log2 (tree expr) { int prec; HOST_WIDE_INT high, low; @@ -805,8 +802,7 @@ tree_floor_log2 (expr) /* Return 1 if EXPR is the real constant zero. */ int -real_zerop (expr) - tree expr; +real_zerop (tree expr) { STRIP_NOPS (expr); @@ -821,8 +817,7 @@ real_zerop (expr) /* Return 1 if EXPR is the real constant one in real or complex form. */ int -real_onep (expr) - tree expr; +real_onep (tree expr) { STRIP_NOPS (expr); @@ -837,8 +832,7 @@ real_onep (expr) /* Return 1 if EXPR is the real constant two. */ int -real_twop (expr) - tree expr; +real_twop (tree expr) { STRIP_NOPS (expr); @@ -853,8 +847,7 @@ real_twop (expr) /* Return 1 if EXPR is the real constant minus one. */ int -real_minus_onep (expr) - tree expr; +real_minus_onep (tree expr) { STRIP_NOPS (expr); @@ -869,8 +862,7 @@ real_minus_onep (expr) /* Nonzero if EXP is a constant or a cast of a constant. */ int -really_constant_p (exp) - tree exp; +really_constant_p (tree exp) { /* This is not quite the same as STRIP_NOPS. It does more. */ while (TREE_CODE (exp) == NOP_EXPR @@ -884,8 +876,7 @@ really_constant_p (exp) Return 0 if ELEM is not in LIST. */ tree -value_member (elem, list) - tree elem, list; +value_member (tree elem, tree list) { while (list) { @@ -900,8 +891,7 @@ value_member (elem, list) Return 0 if ELEM is not in LIST. */ tree -purpose_member (elem, list) - tree elem, list; +purpose_member (tree elem, tree list) { while (list) { @@ -916,8 +906,7 @@ purpose_member (elem, list) Return 0 if ELEM is not in LIST. */ tree -binfo_member (elem, list) - tree elem, list; +binfo_member (tree elem, tree list) { while (list) { @@ -931,8 +920,7 @@ binfo_member (elem, list) /* Return nonzero if ELEM is part of the chain CHAIN. */ int -chain_member (elem, chain) - tree elem, chain; +chain_member (tree elem, tree chain) { while (chain) { @@ -944,48 +932,12 @@ chain_member (elem, chain) return 0; } -/* Return nonzero if ELEM is equal to TREE_VALUE (CHAIN) for any piece of - chain CHAIN. This and the next function are currently unused, but - are retained for completeness. */ - -int -chain_member_value (elem, chain) - tree elem, chain; -{ - while (chain) - { - if (elem == TREE_VALUE (chain)) - return 1; - chain = TREE_CHAIN (chain); - } - - return 0; -} - -/* Return nonzero if ELEM is equal to TREE_PURPOSE (CHAIN) - for any piece of chain CHAIN. */ - -int -chain_member_purpose (elem, chain) - tree elem, chain; -{ - while (chain) - { - if (elem == TREE_PURPOSE (chain)) - return 1; - chain = TREE_CHAIN (chain); - } - - return 0; -} - /* Return the length of a chain of nodes chained through TREE_CHAIN. We expect a null pointer to mark the end of the chain. This is the Lisp primitive `length'. */ int -list_length (t) - tree t; +list_length (tree t) { tree tail; int len = 0; @@ -999,8 +951,7 @@ list_length (t) /* Returns the number of FIELD_DECLs in TYPE. */ int -fields_length (type) - tree type; +fields_length (tree type) { tree t = TYPE_FIELDS (type); int count = 0; @@ -1017,36 +968,35 @@ fields_length (type) This is the Lisp primitive `nconc'. */ tree -chainon (op1, op2) - tree op1, op2; +chainon (tree op1, tree op2) { + tree t1; - if (op1) - { - tree t1; -#ifdef ENABLE_TREE_CHECKING - tree t2; -#endif + if (!op1) + return op2; + if (!op2) + return op1; + + for (t1 = op1; TREE_CHAIN (t1); t1 = TREE_CHAIN (t1)) + continue; + TREE_CHAIN (t1) = op2; - for (t1 = op1; TREE_CHAIN (t1); t1 = TREE_CHAIN (t1)) - ; - TREE_CHAIN (t1) = op2; #ifdef ENABLE_TREE_CHECKING - for (t2 = op2; t2; t2 = TREE_CHAIN (t2)) - if (t2 == t1) - abort (); /* Circularity created. */ + { + tree t2; + for (t2 = op2; t2; t2 = TREE_CHAIN (t2)) + if (t2 == t1) + abort (); /* Circularity created. */ + } #endif - return op1; - } - else - return op2; + + return op1; } /* Return the last node in a chain of nodes (chained through TREE_CHAIN). */ tree -tree_last (chain) - tree chain; +tree_last (tree chain) { tree next; if (chain) @@ -1059,8 +1009,7 @@ tree_last (chain) and return the new head of the chain (old last element). */ tree -nreverse (t) - tree t; +nreverse (tree t) { tree prev = 0, decl, next; for (decl = t; decl; decl = next) @@ -1071,38 +1020,12 @@ nreverse (t) } return prev; } - -/* Given a chain CHAIN of tree nodes, - construct and return a list of those nodes. */ - -tree -listify (chain) - tree chain; -{ - tree result = NULL_TREE; - tree in_tail = chain; - tree out_tail = NULL_TREE; - - while (in_tail) - { - tree next = tree_cons (NULL_TREE, in_tail, NULL_TREE); - if (out_tail) - TREE_CHAIN (out_tail) = next; - else - result = next; - out_tail = next; - in_tail = TREE_CHAIN (in_tail); - } - - return result; -} /* Return a newly created TREE_LIST node whose purpose and value fields are PARM and VALUE. */ tree -build_tree_list (parm, value) - tree parm, value; +build_tree_list (tree parm, tree value) { tree t = make_node (TREE_LIST); TREE_PURPOSE (t) = parm; @@ -1111,12 +1034,11 @@ build_tree_list (parm, value) } /* Return a newly created TREE_LIST node whose - purpose and value fields are PARM and VALUE + purpose and value fields are PURPOSE and VALUE and whose TREE_CHAIN is CHAIN. */ tree -tree_cons (purpose, value, chain) - tree purpose, value, chain; +tree_cons (tree purpose, tree value, tree chain) { tree node; @@ -1136,6 +1058,44 @@ tree_cons (purpose, value, chain) return node; } +/* Return the first expression in a sequence of COMPOUND_EXPRs. */ + +tree +expr_first (tree expr) +{ + if (expr == NULL_TREE) + return expr; + while (TREE_CODE (expr) == COMPOUND_EXPR) + expr = TREE_OPERAND (expr, 0); + return expr; +} + +/* Return the last expression in a sequence of COMPOUND_EXPRs. */ + +tree +expr_last (tree expr) +{ + if (expr == NULL_TREE) + return expr; + while (TREE_CODE (expr) == COMPOUND_EXPR) + expr = TREE_OPERAND (expr, 1); + return expr; +} + +/* Return the number of subexpressions in a sequence of COMPOUND_EXPRs. */ + +int +expr_length (tree expr) +{ + int len = 0; + + if (expr == NULL_TREE) + return 0; + for (; TREE_CODE (expr) == COMPOUND_EXPR; expr = TREE_OPERAND (expr, 1)) + len += expr_length (TREE_OPERAND (expr, 0)); + ++len; + return len; +} /* Return the size nominally occupied by an object of type TYPE when it resides in memory. The value is measured in units of bytes, @@ -1144,8 +1104,7 @@ tree_cons (purpose, value, chain) make_unsigned_type). */ tree -size_in_bytes (type) - tree type; +size_in_bytes (tree type) { tree t; @@ -1171,8 +1130,7 @@ size_in_bytes (type) or return -1 if the size can vary or is larger than an integer. */ HOST_WIDE_INT -int_size_in_bytes (type) - tree type; +int_size_in_bytes (tree type) { tree t; @@ -1196,10 +1154,8 @@ int_size_in_bytes (type) This is a tree of type bitsizetype. */ tree -bit_position (field) - tree field; +bit_position (tree field) { - return bit_from_pos (DECL_FIELD_OFFSET (field), DECL_FIELD_BIT_OFFSET (field)); } @@ -1209,8 +1165,7 @@ bit_position (field) of returning -1 like int_size_in_byte can. */ HOST_WIDE_INT -int_bit_position (field) - tree field; +int_bit_position (tree field) { return tree_low_cst (bit_position (field), 0); } @@ -1219,8 +1174,7 @@ int_bit_position (field) This is a tree of type sizetype. */ tree -byte_position (field) - tree field; +byte_position (tree field) { return byte_from_pos (DECL_FIELD_OFFSET (field), DECL_FIELD_BIT_OFFSET (field)); @@ -1231,8 +1185,7 @@ byte_position (field) of returning -1 like int_size_in_byte can. */ HOST_WIDE_INT -int_byte_position (field) - tree field; +int_byte_position (tree field) { return tree_low_cst (byte_position (field), 0); } @@ -1240,8 +1193,7 @@ int_byte_position (field) /* Return the strictest alignment, in bits, that T is known to have. */ unsigned int -expr_align (t) - tree t; +expr_align (tree t) { unsigned int align0, align1; @@ -1288,8 +1240,7 @@ expr_align (t) ARRAY_TYPE) minus one. This counts only elements of the top array. */ tree -array_type_nelts (type) - tree type; +array_type_nelts (tree type) { tree index_type, min, max; @@ -1311,8 +1262,7 @@ array_type_nelts (type) static storage. This is not the same as the C meaning of `static'. */ int -staticp (arg) - tree arg; +staticp (tree arg) { switch (TREE_CODE (arg)) { @@ -1389,39 +1339,24 @@ staticp (arg) are used for. */ tree -save_expr (expr) - tree expr; +save_expr (tree expr) { tree t = fold (expr); tree inner; - /* We don't care about whether this can be used as an lvalue in this - context. */ - while (TREE_CODE (t) == NON_LVALUE_EXPR) - t = TREE_OPERAND (t, 0); - - /* If we have simple operations applied to a SAVE_EXPR or to a SAVE_EXPR and - a constant, it will be more efficient to not make another SAVE_EXPR since - it will allow better simplification and GCSE will be able to merge the - computations if they actualy occur. */ - for (inner = t; - (TREE_CODE_CLASS (TREE_CODE (inner)) == '1' - || (TREE_CODE_CLASS (TREE_CODE (inner)) == '2' - && TREE_CONSTANT (TREE_OPERAND (inner, 1)))); - inner = TREE_OPERAND (inner, 0)) - ; - /* If the tree evaluates to a constant, then we don't want to hide that fact (i.e. this allows further folding, and direct checks for constants). However, a read-only object that has side effects cannot be bypassed. Since it is no problem to reevaluate literals, we just return the literal node. */ + inner = skip_simple_arithmetic (t); if (TREE_CONSTANT (inner) || (TREE_READONLY (inner) && ! TREE_SIDE_EFFECTS (inner)) - || TREE_CODE (inner) == SAVE_EXPR || TREE_CODE (inner) == ERROR_MARK) + || TREE_CODE (inner) == SAVE_EXPR + || TREE_CODE (inner) == ERROR_MARK) return t; - /* If T contains a PLACEHOLDER_EXPR, we must evaluate it each time, since + /* If INNER contains a PLACEHOLDER_EXPR, we must evaluate it each time, since it means that the size or offset of some field of an object depends on the value within another field. @@ -1430,7 +1365,7 @@ save_expr (expr) evaluated more than once. Front-ends must assure this case cannot happen by surrounding any such subexpressions in their own SAVE_EXPR and forcing evaluation at the proper time. */ - if (contains_placeholder_p (t)) + if (contains_placeholder_p (inner)) return t; t = build (SAVE_EXPR, TREE_TYPE (expr), t, current_function_decl, NULL_TREE); @@ -1443,13 +1378,59 @@ save_expr (expr) return t; } +/* Look inside EXPR and into any simple arithmetic operations. Return + the innermost non-arithmetic node. */ + +tree +skip_simple_arithmetic (tree expr) +{ + tree inner; + + /* We don't care about whether this can be used as an lvalue in this + context. */ + while (TREE_CODE (expr) == NON_LVALUE_EXPR) + expr = TREE_OPERAND (expr, 0); + + /* If we have simple operations applied to a SAVE_EXPR or to a SAVE_EXPR and + a constant, it will be more efficient to not make another SAVE_EXPR since + it will allow better simplification and GCSE will be able to merge the + computations if they actually occur. */ + inner = expr; + while (1) + { + if (TREE_CODE_CLASS (TREE_CODE (inner)) == '1') + inner = TREE_OPERAND (inner, 0); + else if (TREE_CODE_CLASS (TREE_CODE (inner)) == '2') + { + if (TREE_CONSTANT (TREE_OPERAND (inner, 1))) + inner = TREE_OPERAND (inner, 0); + else if (TREE_CONSTANT (TREE_OPERAND (inner, 0))) + inner = TREE_OPERAND (inner, 1); + else + break; + } + else + break; + } + + return inner; +} + +/* Return TRUE if EXPR is a SAVE_EXPR or wraps simple arithmetic around a + SAVE_EXPR. Return FALSE otherwise. */ + +bool +saved_expr_p (tree expr) +{ + return TREE_CODE (skip_simple_arithmetic (expr)) == SAVE_EXPR; +} + /* Arrange for an expression to be expanded multiple independent times. This is useful for cleanup actions, as the backend can expand them multiple times in different places. */ tree -unsave_expr (expr) - tree expr; +unsave_expr (tree expr) { tree t; @@ -1466,8 +1447,7 @@ unsave_expr (expr) of operands if all are trees. */ int -first_rtl_op (code) - enum tree_code code; +first_rtl_op (enum tree_code code) { switch (code) { @@ -1478,8 +1458,6 @@ first_rtl_op (code) return 0; case WITH_CLEANUP_EXPR: return 2; - case METHOD_CALL_EXPR: - return 3; default: return TREE_CODE_LENGTH (code); } @@ -1488,17 +1466,16 @@ first_rtl_op (code) /* Return which tree structure is used by T. */ enum tree_node_structure_enum -tree_node_structure (t) - tree t; +tree_node_structure (tree t) { enum tree_code code = TREE_CODE (t); - + switch (TREE_CODE_CLASS (code)) { case 'd': return TS_DECL; case 't': return TS_TYPE; case 'b': return TS_BLOCK; - case 'r': case '<': case '1': case '2': case 'e': case 's': + case 'r': case '<': case '1': case '2': case 'e': case 's': return TS_EXP; default: /* 'c' and 'x' */ break; @@ -1527,8 +1504,7 @@ tree_node_structure (t) not recurse into EXPR's subtrees. */ void -unsave_expr_1 (expr) - tree expr; +unsave_expr_1 (tree expr) { switch (TREE_CODE (expr)) { @@ -1563,8 +1539,7 @@ unsave_expr_1 (expr) /* Default lang hook for "unsave_expr_now". */ tree -lhd_unsave_expr_now (expr) - tree expr; +lhd_unsave_expr_now (tree expr) { enum tree_code code; @@ -1629,8 +1604,7 @@ lhd_unsave_expr_now (expr) never possible to unsave them. */ int -unsafe_for_reeval (expr) - tree expr; +unsafe_for_reeval (tree expr) { int unsafeness = 0; enum tree_code code; @@ -1648,6 +1622,7 @@ unsafe_for_reeval (expr) { case SAVE_EXPR: case RTL_EXPR: + case TRY_CATCH_EXPR: return 2; case TREE_LIST: @@ -1668,6 +1643,13 @@ unsafe_for_reeval (expr) unsafeness = 1; break; + case EXIT_BLOCK_EXPR: + /* EXIT_BLOCK_LABELED_BLOCK, a.k.a. TREE_OPERAND (expr, 0), holds + a reference to an ancestor LABELED_BLOCK, so we need to avoid + unbounded recursion in the 'e' traversal code below. */ + exp = EXIT_BLOCK_RETURN (expr); + return exp ? unsafe_for_reeval (exp) : 0; + default: tmp = (*lang_hooks.unsafe_for_reeval) (expr); if (tmp >= 0) @@ -1706,9 +1688,8 @@ unsafe_for_reeval (expr) /* Return 1 if EXP contains a PLACEHOLDER_EXPR; i.e., if it represents a size or offset that depends on a field within a record. */ -int -contains_placeholder_p (exp) - tree exp; +bool +contains_placeholder_p (tree exp) { enum tree_code code; int result; @@ -1731,13 +1712,12 @@ contains_placeholder_p (exp) position computations since they will be converted into a WITH_RECORD_EXPR involving the reference, which will assume here will be valid. */ - return contains_placeholder_p (TREE_OPERAND (exp, 0)); + return CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 0)); case 'x': if (code == TREE_LIST) - return (contains_placeholder_p (TREE_VALUE (exp)) - || (TREE_CHAIN (exp) != 0 - && contains_placeholder_p (TREE_CHAIN (exp)))); + return (CONTAINS_PLACEHOLDER_P (TREE_VALUE (exp)) + || CONTAINS_PLACEHOLDER_P (TREE_CHAIN (exp))); break; case '1': @@ -1747,16 +1727,16 @@ contains_placeholder_p (exp) { case COMPOUND_EXPR: /* Ignoring the first operand isn't quite right, but works best. */ - return contains_placeholder_p (TREE_OPERAND (exp, 1)); + return CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 1)); case RTL_EXPR: case CONSTRUCTOR: return 0; case COND_EXPR: - return (contains_placeholder_p (TREE_OPERAND (exp, 0)) - || contains_placeholder_p (TREE_OPERAND (exp, 1)) - || contains_placeholder_p (TREE_OPERAND (exp, 2))); + return (CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 0)) + || CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 1)) + || CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 2))); case SAVE_EXPR: /* If we already know this doesn't have a placeholder, don't @@ -1765,15 +1745,14 @@ contains_placeholder_p (exp) return 0; SAVE_EXPR_NOPLACEHOLDER (exp) = 1; - result = contains_placeholder_p (TREE_OPERAND (exp, 0)); + result = CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 0)); if (result) SAVE_EXPR_NOPLACEHOLDER (exp) = 0; return result; case CALL_EXPR: - return (TREE_OPERAND (exp, 1) != 0 - && contains_placeholder_p (TREE_OPERAND (exp, 1))); + return CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 1)); default: break; @@ -1782,10 +1761,10 @@ contains_placeholder_p (exp) switch (TREE_CODE_LENGTH (code)) { case 1: - return contains_placeholder_p (TREE_OPERAND (exp, 0)); + return CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 0)); case 2: - return (contains_placeholder_p (TREE_OPERAND (exp, 0)) - || contains_placeholder_p (TREE_OPERAND (exp, 1))); + return (CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 0)) + || CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 1))); default: return 0; } @@ -1796,12 +1775,113 @@ contains_placeholder_p (exp) return 0; } +/* Return 1 if any part of the computation of TYPE involves a PLACEHOLDER_EXPR. + This includes size, bounds, qualifiers (for QUAL_UNION_TYPE) and field + positions. */ + +bool +type_contains_placeholder_p (tree type) +{ + /* If the size contains a placeholder or the parent type (component type in + the case of arrays) type involves a placeholder, this type does. */ + if (CONTAINS_PLACEHOLDER_P (TYPE_SIZE (type)) + || CONTAINS_PLACEHOLDER_P (TYPE_SIZE_UNIT (type)) + || (TREE_TYPE (type) != 0 + && type_contains_placeholder_p (TREE_TYPE (type)))) + return 1; + + /* Now do type-specific checks. Note that the last part of the check above + greatly limits what we have to do below. */ + switch (TREE_CODE (type)) + { + case VOID_TYPE: + case COMPLEX_TYPE: + case VECTOR_TYPE: + case ENUMERAL_TYPE: + case BOOLEAN_TYPE: + case CHAR_TYPE: + case POINTER_TYPE: + case OFFSET_TYPE: + case REFERENCE_TYPE: + case METHOD_TYPE: + case FILE_TYPE: + case FUNCTION_TYPE: + return 0; + + case INTEGER_TYPE: + case REAL_TYPE: + /* Here we just check the bounds. */ + return (CONTAINS_PLACEHOLDER_P (TYPE_MIN_VALUE (type)) + || CONTAINS_PLACEHOLDER_P (TYPE_MAX_VALUE (type))); + + case ARRAY_TYPE: + case SET_TYPE: + /* We're already checked the component type (TREE_TYPE), so just check + the index type. */ + return type_contains_placeholder_p (TYPE_DOMAIN (type)); + + case RECORD_TYPE: + case UNION_TYPE: + case QUAL_UNION_TYPE: + { + static tree seen_types = 0; + tree field; + bool ret = 0; + + /* We have to be careful here that we don't end up in infinite + recursions due to a field of a type being a pointer to that type + or to a mutually-recursive type. So we store a list of record + types that we've seen and see if this type is in them. To save + memory, we don't use a list for just one type. Here we check + whether we've seen this type before and store it if not. */ + if (seen_types == 0) + seen_types = type; + else if (TREE_CODE (seen_types) != TREE_LIST) + { + if (seen_types == type) + return 0; + + seen_types = tree_cons (NULL_TREE, type, + build_tree_list (NULL_TREE, seen_types)); + } + else + { + if (value_member (type, seen_types) != 0) + return 0; + + seen_types = tree_cons (NULL_TREE, type, seen_types); + } + + for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field)) + if (TREE_CODE (field) == FIELD_DECL + && (CONTAINS_PLACEHOLDER_P (DECL_FIELD_OFFSET (field)) + || (TREE_CODE (type) == QUAL_UNION_TYPE + && CONTAINS_PLACEHOLDER_P (DECL_QUALIFIER (field))) + || type_contains_placeholder_p (TREE_TYPE (field)))) + { + ret = true; + break; + } + + /* Now remove us from seen_types and return the result. */ + if (seen_types == type) + seen_types = 0; + else + seen_types = TREE_CHAIN (seen_types); + + return ret; + } + + default: + abort (); + } +} + /* Return 1 if EXP contains any expressions that produce cleanups for an outer scope to deal with. Used by fold. */ int -has_cleanups (exp) - tree exp; +has_cleanups (tree exp) { int i, nops, cmp; @@ -1862,10 +1942,7 @@ has_cleanups (exp) PLACEHOLDER_EXPR occurring only in its arglist. */ tree -substitute_in_expr (exp, f, r) - tree exp; - tree f; - tree r; +substitute_in_expr (tree exp, tree f, tree r) { enum tree_code code = TREE_CODE (exp); tree op0, op1, op2; @@ -1919,8 +1996,13 @@ substitute_in_expr (exp, f, r) else if (code == CONSTRUCTOR) abort (); - op0 = substitute_in_expr (TREE_OPERAND (exp, 0), f, r); - op1 = substitute_in_expr (TREE_OPERAND (exp, 1), f, r); + op0 = TREE_OPERAND (exp, 0); + op1 = TREE_OPERAND (exp, 1); + if (CONTAINS_PLACEHOLDER_P (op0)) + op0 = substitute_in_expr (op0, f, r); + if (CONTAINS_PLACEHOLDER_P (op1)) + op1 = substitute_in_expr (op1, f, r); + if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1)) return exp; @@ -1946,9 +2028,17 @@ substitute_in_expr (exp, f, r) else if (code != COND_EXPR) abort (); - op0 = substitute_in_expr (TREE_OPERAND (exp, 0), f, r); - op1 = substitute_in_expr (TREE_OPERAND (exp, 1), f, r); - op2 = substitute_in_expr (TREE_OPERAND (exp, 2), f, r); + op0 = TREE_OPERAND (exp, 0); + op1 = TREE_OPERAND (exp, 1); + op2 = TREE_OPERAND (exp, 2); + + if (CONTAINS_PLACEHOLDER_P (op0)) + op0 = substitute_in_expr (op0, f, r); + if (CONTAINS_PLACEHOLDER_P (op1)) + op1 = substitute_in_expr (op1, f, r); + if (CONTAINS_PLACEHOLDER_P (op2)) + op2 = substitute_in_expr (op2, f, r); + if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1) && op2 == TREE_OPERAND (exp, 2)) return exp; @@ -2032,8 +2122,7 @@ substitute_in_expr (exp, f, r) Any other kind of expression is returned unchanged. */ tree -stabilize_reference (ref) - tree ref; +stabilize_reference (tree ref) { tree result; enum tree_code code = TREE_CODE (ref); @@ -2130,8 +2219,7 @@ stabilize_reference (ref) multiple utterances of the same expression should that prove fruitful. */ tree -stabilize_reference_1 (e) - tree e; +stabilize_reference_1 (tree e) { tree result; enum tree_code code = TREE_CODE (e); @@ -2206,17 +2294,17 @@ stabilize_reference_1 (e) Constants, decls, types and misc nodes cannot be. */ tree -build VPARAMS ((enum tree_code code, tree tt, ...)) +build (enum tree_code code, tree tt, ...) { tree t; int length; int i; int fro; int constant; + va_list p; + tree node; - VA_OPEN (p, tt); - VA_FIXEDARG (p, enum tree_code, code); - VA_FIXEDARG (p, tree, tt); + va_start (p, tt); t = make_node (code); length = TREE_CODE_LENGTH (code); @@ -2293,9 +2381,27 @@ build VPARAMS ((enum tree_code code, tree tt, ...)) } } } - VA_CLOSE (p); + va_end (p); TREE_CONSTANT (t) = constant; + + if (code == CALL_EXPR && !TREE_SIDE_EFFECTS (t)) + { + /* Calls have side-effects, except those to const or + pure functions. */ + i = call_expr_flags (t); + if (!(i & (ECF_CONST | ECF_PURE))) + TREE_SIDE_EFFECTS (t) = 1; + + /* And even those have side-effects if their arguments do. */ + else for (node = TREE_OPERAND (t, 1); node; node = TREE_CHAIN (node)) + if (TREE_SIDE_EFFECTS (TREE_VALUE (node))) + { + TREE_SIDE_EFFECTS (t) = 1; + break; + } + } + return t; } @@ -2304,22 +2410,30 @@ build VPARAMS ((enum tree_code code, tree tt, ...)) of varargs, which is expensive for RISC machines. */ tree -build1 (code, type, node) - enum tree_code code; - tree type; - tree node; +build1 (enum tree_code code, tree type, tree node) { - int length; + int length = sizeof (struct tree_exp); #ifdef GATHER_STATISTICS tree_node_kind kind; #endif tree t; #ifdef GATHER_STATISTICS - if (TREE_CODE_CLASS (code) == 'r') - kind = r_kind; - else - kind = e_kind; + switch (TREE_CODE_CLASS (code)) + { + case 's': /* an expression with side effects */ + kind = s_kind; + break; + case 'r': /* a reference */ + kind = r_kind; + break; + default: + kind = e_kind; + break; + } + + tree_node_counts[(int) kind]++; + tree_node_sizes[(int) kind] += length; #endif #ifdef ENABLE_CHECKING @@ -2329,16 +2443,9 @@ build1 (code, type, node) abort (); #endif /* ENABLE_CHECKING */ - length = sizeof (struct tree_exp); - t = ggc_alloc_tree (length); - memset ((PTR) t, 0, sizeof (struct tree_common)); - -#ifdef GATHER_STATISTICS - tree_node_counts[(int) kind]++; - tree_node_sizes[(int) kind] += length; -#endif + memset (t, 0, sizeof (struct tree_common)); TREE_SET_CODE (t, code); @@ -2351,7 +2458,9 @@ build1 (code, type, node) TREE_READONLY (t) = TREE_READONLY (node); } - switch (code) + if (TREE_CODE_CLASS (code) == 's') + TREE_SIDE_EFFECTS (t) = 1; + else switch (code) { case INIT_EXPR: case MODIFY_EXPR: @@ -2373,6 +2482,29 @@ build1 (code, type, node) TREE_READONLY (t) = 0; break; + case ADDR_EXPR: + if (node) + { + /* The address of a volatile decl or reference does not have + side-effects. But be careful not to ignore side-effects from + other sources deeper in the expression--if node is a _REF and + one of its operands has side-effects, so do we. */ + if (TREE_THIS_VOLATILE (node)) + { + TREE_SIDE_EFFECTS (t) = 0; + if (!DECL_P (node)) + { + int i = first_rtl_op (TREE_CODE (node)) - 1; + for (; i >= 0; --i) + { + if (TREE_SIDE_EFFECTS (TREE_OPERAND (node, i))) + TREE_SIDE_EFFECTS (t) = 1; + } + } + } + } + break; + default: if (TREE_CODE_CLASS (code) == '1' && node && TREE_CONSTANT (node)) TREE_CONSTANT (t) = 1; @@ -2388,14 +2520,14 @@ build1 (code, type, node) or even garbage if their values do not matter. */ tree -build_nt VPARAMS ((enum tree_code code, ...)) +build_nt (enum tree_code code, ...) { tree t; int length; int i; + va_list p; - VA_OPEN (p, code); - VA_FIXEDARG (p, enum tree_code, code); + va_start (p, code); t = make_node (code); length = TREE_CODE_LENGTH (code); @@ -2403,7 +2535,7 @@ build_nt VPARAMS ((enum tree_code code, ...)) for (i = 0; i < length; i++) TREE_OPERAND (t, i) = va_arg (p, tree); - VA_CLOSE (p); + va_end (p); return t; } @@ -2414,9 +2546,7 @@ build_nt VPARAMS ((enum tree_code code, ...)) Other slots are initialized to 0 or null pointers. */ tree -build_decl (code, name, type) - enum tree_code code; - tree name, type; +build_decl (enum tree_code code, tree name, tree type) { tree t; @@ -2443,8 +2573,8 @@ build_decl (code, name, type) compiled. This information is used for outputting debugging info. */ tree -build_block (vars, tags, subblocks, supercontext, chain) - tree vars, tags ATTRIBUTE_UNUSED, subblocks, supercontext, chain; +build_block (tree vars, tree tags ATTRIBUTE_UNUSED, tree subblocks, + tree supercontext, tree chain) { tree block = make_node (BLOCK); @@ -2461,10 +2591,7 @@ build_block (vars, tags, subblocks, supercontext, chain) recursively more than one file (Java is one of them). */ tree -build_expr_wfl (node, file, line, col) - tree node; - const char *file; - int line, col; +build_expr_wfl (tree node, const char *file, int line, int col) { static const char *last_file = 0; static tree last_filenode = NULL_TREE; @@ -2492,8 +2619,7 @@ build_expr_wfl (node, file, line, col) is ATTRIBUTE. */ tree -build_decl_attribute_variant (ddecl, attribute) - tree ddecl, attribute; +build_decl_attribute_variant (tree ddecl, tree attribute) { DECL_ATTRIBUTES (ddecl) = attribute; return ddecl; @@ -2505,8 +2631,7 @@ build_decl_attribute_variant (ddecl, attribute) Record such modified types already made so we don't make duplicates. */ tree -build_type_attribute_variant (ttype, attribute) - tree ttype, attribute; +build_type_attribute_variant (tree ttype, tree attribute) { if (! attribute_list_equal (TYPE_ATTRIBUTES (ttype), attribute)) { @@ -2562,9 +2687,7 @@ build_type_attribute_variant (ttype, attribute) their canonicalized form. */ int -is_attribute_p (attr, ident) - const char *attr; - tree ident; +is_attribute_p (const char *attr, tree ident) { int ident_len, attr_len; const char *p; @@ -2609,9 +2732,7 @@ is_attribute_p (attr, ident) be passed back in if further occurrences are wanted. */ tree -lookup_attribute (attr_name, list) - const char *attr_name; - tree list; +lookup_attribute (const char *attr_name, tree list) { tree l; @@ -2629,8 +2750,7 @@ lookup_attribute (attr_name, list) /* Return an attribute list that is the union of a1 and a2. */ tree -merge_attributes (a1, a2) - tree a1, a2; +merge_attributes (tree a1, tree a2) { tree attributes; @@ -2680,8 +2800,7 @@ merge_attributes (a1, a2) the result. */ tree -merge_type_attributes (t1, t2) - tree t1, t2; +merge_type_attributes (tree t1, tree t2) { return merge_attributes (TYPE_ATTRIBUTES (t1), TYPE_ATTRIBUTES (t2)); @@ -2691,8 +2810,7 @@ merge_type_attributes (t1, t2) the result. */ tree -merge_decl_attributes (olddecl, newdecl) - tree olddecl, newdecl; +merge_decl_attributes (tree olddecl, tree newdecl) { return merge_attributes (DECL_ATTRIBUTES (olddecl), DECL_ATTRIBUTES (newdecl)); @@ -2710,9 +2828,7 @@ merge_decl_attributes (olddecl, newdecl) The second instance of `foo' nullifies the dllimport. */ tree -merge_dllimport_decl_attributes (old, new) - tree old; - tree new; +merge_dllimport_decl_attributes (tree old, tree new) { tree a; int delete_dllimport_p; @@ -2759,9 +2875,7 @@ merge_dllimport_decl_attributes (old, new) of the various TYPE_QUAL values. */ static void -set_type_quals (type, type_quals) - tree type; - int type_quals; +set_type_quals (tree type, int type_quals) { TYPE_READONLY (type) = (type_quals & TYPE_QUAL_CONST) != 0; TYPE_VOLATILE (type) = (type_quals & TYPE_QUAL_VOLATILE) != 0; @@ -2773,9 +2887,7 @@ set_type_quals (type, type_quals) return NULL_TREE. */ tree -get_qualified_type (type, type_quals) - tree type; - int type_quals; +get_qualified_type (tree type, int type_quals) { tree t; @@ -2784,7 +2896,8 @@ get_qualified_type (type, type_quals) preserve the TYPE_NAME, since there is code that depends on this. */ for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t)) if (TYPE_QUALS (t) == type_quals && TYPE_NAME (t) == TYPE_NAME (type) - && TYPE_CONTEXT (t) == TYPE_CONTEXT (type)) + && TYPE_CONTEXT (t) == TYPE_CONTEXT (type) + && attribute_list_equal (TYPE_ATTRIBUTES (t), TYPE_ATTRIBUTES (type))) return t; return NULL_TREE; @@ -2794,9 +2907,7 @@ get_qualified_type (type, type_quals) exist. This function never returns NULL_TREE. */ tree -build_qualified_type (type, type_quals) - tree type; - int type_quals; +build_qualified_type (tree type, int type_quals) { tree t; @@ -2817,8 +2928,7 @@ build_qualified_type (type, type_quals) This is so the caller can modify it. */ tree -build_type_copy (type) - tree type; +build_type_copy (tree type) { tree t, m = TYPE_MAIN_VARIANT (type); @@ -2842,8 +2952,7 @@ build_type_copy (type) of the individual types. */ unsigned int -type_hash_list (list) - tree list; +type_hash_list (tree list) { unsigned int hashcode; tree tail; @@ -2859,9 +2968,7 @@ type_hash_list (list) /* Returns true if the types are equal. */ static int -type_hash_eq (va, vb) - const void *va; - const void *vb; +type_hash_eq (const void *va, const void *vb) { const struct type_hash *a = va, *b = vb; if (a->hash == b->hash @@ -2891,8 +2998,7 @@ type_hash_eq (va, vb) /* Return the cached hash value. */ static hashval_t -type_hash_hash (item) - const void *item; +type_hash_hash (const void *item) { return ((const struct type_hash *) item)->hash; } @@ -2901,9 +3007,7 @@ type_hash_hash (item) If one is found, return it. Otherwise return 0. */ tree -type_hash_lookup (hashcode, type) - unsigned int hashcode; - tree type; +type_hash_lookup (unsigned int hashcode, tree type) { struct type_hash *h, in; @@ -2924,14 +3028,12 @@ type_hash_lookup (hashcode, type) for a type TYPE whose hash code is HASHCODE. */ void -type_hash_add (hashcode, type) - unsigned int hashcode; - tree type; +type_hash_add (unsigned int hashcode, tree type) { struct type_hash *h; void **loc; - h = (struct type_hash *) ggc_alloc (sizeof (struct type_hash)); + h = ggc_alloc (sizeof (struct type_hash)); h->hash = hashcode; h->type = type; loc = htab_find_slot_with_hash (type_hash_table, h, hashcode, INSERT); @@ -2953,9 +3055,7 @@ type_hash_add (hashcode, type) int debug_no_type_hash = 0; tree -type_hash_canon (hashcode, type) - unsigned int hashcode; - tree type; +type_hash_canon (unsigned int hashcode, tree type) { tree t1; @@ -2987,8 +3087,7 @@ type_hash_canon (hashcode, type) the number of garbage collections. */ static int -type_hash_marked_p (p) - const void *p; +type_hash_marked_p (const void *p) { tree type = ((struct type_hash *) p)->type; @@ -2996,7 +3095,7 @@ type_hash_marked_p (p) } static void -print_type_hash_statistics () +print_type_hash_statistics (void) { fprintf (stderr, "Type hash: size %ld, %ld elements, %f collisions\n", (long) htab_size (type_hash_table), @@ -3009,8 +3108,7 @@ print_type_hash_statistics () by adding the hash codes of the individual attributes. */ unsigned int -attribute_hash_list (list) - tree list; +attribute_hash_list (tree list) { unsigned int hashcode; tree tail; @@ -3025,8 +3123,7 @@ attribute_hash_list (list) equivalent to l1. */ int -attribute_list_equal (l1, l2) - tree l1, l2; +attribute_list_equal (tree l1, tree l2) { return attribute_list_contained (l1, l2) && attribute_list_contained (l2, l1); @@ -3041,8 +3138,7 @@ attribute_list_equal (l1, l2) correctly. */ int -attribute_list_contained (l1, l2) - tree l1, l2; +attribute_list_contained (tree l1, tree l2) { tree t1, t2; @@ -3089,8 +3185,7 @@ attribute_list_contained (l1, l2) Also, the TREE_PURPOSEs must match. */ int -type_list_equal (l1, l2) - tree l1, l2; +type_list_equal (tree l1, tree l2) { tree t1, t2; @@ -3110,8 +3205,7 @@ type_list_equal (l1, l2) then this function counts only the ordinary arguments. */ int -type_num_arguments (type) - tree type; +type_num_arguments (tree type) { int i = 0; tree t; @@ -3131,8 +3225,7 @@ type_num_arguments (type) represent the same constant value. */ int -tree_int_cst_equal (t1, t2) - tree t1, t2; +tree_int_cst_equal (tree t1, tree t2) { if (t1 == t2) return 1; @@ -3153,8 +3246,7 @@ tree_int_cst_equal (t1, t2) The precise way of comparison depends on their data type. */ int -tree_int_cst_lt (t1, t2) - tree t1, t2; +tree_int_cst_lt (tree t1, tree t2) { if (t1 == t2) return 0; @@ -3181,9 +3273,7 @@ tree_int_cst_lt (t1, t2) /* Returns -1 if T1 < T2, 0 if T1 == T2, and 1 if T1 > T2. */ int -tree_int_cst_compare (t1, t2) - tree t1; - tree t2; +tree_int_cst_compare (tree t1, tree t2) { if (tree_int_cst_lt (t1, t2)) return -1; @@ -3199,9 +3289,7 @@ tree_int_cst_compare (t1, t2) be represented in a single unsigned HOST_WIDE_INT. */ int -host_integerp (t, pos) - tree t; - int pos; +host_integerp (tree t, int pos) { return (TREE_CODE (t) == INTEGER_CST && ! TREE_OVERFLOW (t) @@ -3218,9 +3306,7 @@ host_integerp (t, pos) be positive. Abort if we cannot satisfy the above conditions. */ HOST_WIDE_INT -tree_low_cst (t, pos) - tree t; - int pos; +tree_low_cst (tree t, int pos) { if (host_integerp (t, pos)) return TREE_INT_CST_LOW (t); @@ -3231,8 +3317,7 @@ tree_low_cst (t, pos) /* Return the most significant bit of the integer constant T. */ int -tree_int_cst_msb (t) - tree t; +tree_int_cst_msb (tree t) { int prec; HOST_WIDE_INT h; @@ -3251,8 +3336,7 @@ tree_int_cst_msb (t) Note that -1 will never be returned it T's type is unsigned. */ int -tree_int_cst_sgn (t) - tree t; +tree_int_cst_sgn (tree t) { if (TREE_INT_CST_LOW (t) == 0 && TREE_INT_CST_HIGH (t) == 0) return 0; @@ -3268,8 +3352,7 @@ tree_int_cst_sgn (t) are known to be equal; otherwise return 0. */ int -simple_cst_list_equal (l1, l2) - tree l1, l2; +simple_cst_list_equal (tree l1, tree l2) { while (l1 != NULL_TREE && l2 != NULL_TREE) { @@ -3290,8 +3373,7 @@ simple_cst_list_equal (l1, l2) this function. */ int -simple_cst_equal (t1, t2) - tree t1, t2; +simple_cst_equal (tree t1, tree t2) { enum tree_code code1, code2; int cmp; @@ -3429,9 +3511,7 @@ simple_cst_equal (t1, t2) than U, respectively. */ int -compare_tree_int (t, u) - tree t; - unsigned HOST_WIDE_INT u; +compare_tree_int (tree t, unsigned HOST_WIDE_INT u) { if (tree_int_cst_sgn (t) < 0) return -1; @@ -3444,31 +3524,123 @@ compare_tree_int (t, u) else return 1; } + +/* Generate a hash value for an expression. This can be used iteratively + by passing a previous result as the "val" argument. + + This function is intended to produce the same hash for expressions which + would compare equal using operand_equal_p. */ + +hashval_t +iterative_hash_expr (tree t, hashval_t val) +{ + int i; + enum tree_code code; + char class; + + if (t == NULL_TREE) + return iterative_hash_object (t, val); + + code = TREE_CODE (t); + class = TREE_CODE_CLASS (code); + + if (class == 'd') + { + /* Decls we can just compare by pointer. */ + val = iterative_hash_object (t, val); + } + else if (class == 'c') + { + /* Alas, constants aren't shared, so we can't rely on pointer + identity. */ + if (code == INTEGER_CST) + { + val = iterative_hash_object (TREE_INT_CST_LOW (t), val); + val = iterative_hash_object (TREE_INT_CST_HIGH (t), val); + } + else if (code == REAL_CST) + val = iterative_hash (TREE_REAL_CST_PTR (t), + sizeof (REAL_VALUE_TYPE), val); + else if (code == STRING_CST) + val = iterative_hash (TREE_STRING_POINTER (t), + TREE_STRING_LENGTH (t), val); + else if (code == COMPLEX_CST) + { + val = iterative_hash_expr (TREE_REALPART (t), val); + val = iterative_hash_expr (TREE_IMAGPART (t), val); + } + else if (code == VECTOR_CST) + val = iterative_hash_expr (TREE_VECTOR_CST_ELTS (t), val); + else + abort (); + } + else if (IS_EXPR_CODE_CLASS (class)) + { + val = iterative_hash_object (code, val); + + if (code == NOP_EXPR || code == CONVERT_EXPR + || code == NON_LVALUE_EXPR) + val = iterative_hash_object (TREE_TYPE (t), val); + + if (code == PLUS_EXPR || code == MULT_EXPR || code == MIN_EXPR + || code == MAX_EXPR || code == BIT_IOR_EXPR || code == BIT_XOR_EXPR + || code == BIT_AND_EXPR || code == NE_EXPR || code == EQ_EXPR) + { + /* It's a commutative expression. We want to hash it the same + however it appears. We do this by first hashing both operands + and then rehashing based on the order of their independent + hashes. */ + hashval_t one = iterative_hash_expr (TREE_OPERAND (t, 0), 0); + hashval_t two = iterative_hash_expr (TREE_OPERAND (t, 1), 0); + hashval_t t; + + if (one > two) + t = one, one = two, two = t; + + val = iterative_hash_object (one, val); + val = iterative_hash_object (two, val); + } + else + for (i = first_rtl_op (code) - 1; i >= 0; --i) + val = iterative_hash_expr (TREE_OPERAND (t, i), val); + } + else if (code == TREE_LIST) + { + /* A list of expressions, for a CALL_EXPR or as the elements of a + VECTOR_CST. */ + for (; t; t = TREE_CHAIN (t)) + val = iterative_hash_expr (TREE_VALUE (t), val); + } + else + abort (); + + return val; +} /* Constructors for pointer, array and function types. (RECORD_TYPE, UNION_TYPE and ENUMERAL_TYPE nodes are constructed by language-dependent code, not here.) */ -/* Construct, lay out and return the type of pointers to TO_TYPE. - If such a type has already been constructed, reuse it. */ +/* Construct, lay out and return the type of pointers to TO_TYPE + with mode MODE. If such a type has already been constructed, + reuse it. */ tree -build_pointer_type (to_type) - tree to_type; +build_pointer_type_for_mode (tree to_type, enum machine_mode mode) { tree t = TYPE_POINTER_TO (to_type); /* First, if we already have a type for pointers to TO_TYPE, use it. */ - - if (t != 0) + if (t != 0 && mode == ptr_mode) return t; - /* We need a new one. */ t = make_node (POINTER_TYPE); TREE_TYPE (t) = to_type; + TYPE_MODE (t) = mode; /* Record this type as the pointer to TO_TYPE. */ + if (mode == ptr_mode) TYPE_POINTER_TO (to_type) = t; /* Lay out the type. This function has many callers that are concerned @@ -3479,25 +3651,34 @@ build_pointer_type (to_type) return t; } -/* Build the node for the type of references-to-TO_TYPE. */ +/* By default build pointers in ptr_mode. */ tree -build_reference_type (to_type) - tree to_type; +build_pointer_type (tree to_type) +{ + return build_pointer_type_for_mode (to_type, ptr_mode); +} + +/* Construct, lay out and return the type of references to TO_TYPE + with mode MODE. If such a type has already been constructed, + reuse it. */ + +tree +build_reference_type_for_mode (tree to_type, enum machine_mode mode) { tree t = TYPE_REFERENCE_TO (to_type); /* First, if we already have a type for pointers to TO_TYPE, use it. */ - - if (t) + if (t != 0 && mode == ptr_mode) return t; - /* We need a new one. */ t = make_node (REFERENCE_TYPE); TREE_TYPE (t) = to_type; + TYPE_MODE (t) = mode; /* Record this type as the pointer to TO_TYPE. */ + if (mode == ptr_mode) TYPE_REFERENCE_TO (to_type) = t; layout_type (t); @@ -3505,14 +3686,23 @@ build_reference_type (to_type) return t; } + +/* Build the node for the type of references-to-TO_TYPE by default + in ptr_mode. */ + +tree +build_reference_type (tree to_type) +{ + return build_reference_type_for_mode (to_type, ptr_mode); +} + /* Build a type that is compatible with t but has no cv quals anywhere in its type, thus const char *const *const * -> char ***. */ tree -build_type_no_quals (t) - tree t; +build_type_no_quals (tree t) { switch (TREE_CODE (t)) { @@ -3535,8 +3725,7 @@ build_type_no_quals (t) sizes that use more than one HOST_WIDE_INT. */ tree -build_index_type (maxval) - tree maxval; +build_index_type (tree maxval) { tree itype = make_node (INTEGER_TYPE); @@ -3562,8 +3751,7 @@ build_index_type (maxval) if TYPE==NULL_TREE, sizetype is used. */ tree -build_range_type (type, lowval, highval) - tree type, lowval, highval; +build_range_type (tree type, tree lowval, tree highval) { tree itype = make_node (INTEGER_TYPE); @@ -3593,49 +3781,17 @@ build_range_type (type, lowval, highval) of just highval (maxval). */ tree -build_index_2_type (lowval, highval) - tree lowval, highval; +build_index_2_type (tree lowval, tree highval) { return build_range_type (sizetype, lowval, highval); } -/* Return nonzero iff ITYPE1 and ITYPE2 are equal (in the LISP sense). - Needed because when index types are not hashed, equal index types - built at different times appear distinct, even though structurally, - they are not. */ - -int -index_type_equal (itype1, itype2) - tree itype1, itype2; -{ - if (TREE_CODE (itype1) != TREE_CODE (itype2)) - return 0; - - if (TREE_CODE (itype1) == INTEGER_TYPE) - { - if (TYPE_PRECISION (itype1) != TYPE_PRECISION (itype2) - || TYPE_MODE (itype1) != TYPE_MODE (itype2) - || simple_cst_equal (TYPE_SIZE (itype1), TYPE_SIZE (itype2)) != 1 - || TYPE_ALIGN (itype1) != TYPE_ALIGN (itype2)) - return 0; - - if (1 == simple_cst_equal (TYPE_MIN_VALUE (itype1), - TYPE_MIN_VALUE (itype2)) - && 1 == simple_cst_equal (TYPE_MAX_VALUE (itype1), - TYPE_MAX_VALUE (itype2))) - return 1; - } - - return 0; -} - /* Construct, lay out and return the type of arrays of elements with ELT_TYPE and number of elements specified by the range of values of INDEX_TYPE. If such a type has already been constructed, reuse it. */ tree -build_array_type (elt_type, index_type) - tree elt_type, index_type; +build_array_type (tree elt_type, tree index_type) { tree t; unsigned int hashcode; @@ -3672,8 +3828,7 @@ build_array_type (elt_type, index_type) the innermost dimension of ARRAY. */ tree -get_inner_array_type (array) - tree array; +get_inner_array_type (tree array) { tree type = TREE_TYPE (array); @@ -3691,8 +3846,7 @@ get_inner_array_type (array) If such a type has already been constructed, reuse it. */ tree -build_function_type (value_type, arg_types) - tree value_type, arg_types; +build_function_type (tree value_type, tree arg_types) { tree t; unsigned int hashcode; @@ -3717,18 +3871,18 @@ build_function_type (value_type, arg_types) return t; } -/* Build a function type. The RETURN_TYPE is the type retured by the +/* Build a function type. The RETURN_TYPE is the type returned by the function. If additional arguments are provided, they are additional argument types. The list of argument types must always be terminated by NULL_TREE. */ tree -build_function_type_list VPARAMS ((tree return_type, ...)) +build_function_type_list (tree return_type, ...) { tree t, args, last; + va_list p; - VA_OPEN (p, return_type); - VA_FIXEDARG (p, tree, return_type); + va_start (p, return_type); t = va_arg (p, tree); for (args = NULL_TREE; t != NULL_TREE; t = va_arg (p, tree)) @@ -3739,40 +3893,41 @@ build_function_type_list VPARAMS ((tree return_type, ...)) TREE_CHAIN (last) = void_list_node; args = build_function_type (return_type, args); - VA_CLOSE (p); + va_end (p); return args; } -/* Construct, lay out and return the type of methods belonging to class - BASETYPE and whose arguments and values are described by TYPE. - If that type exists already, reuse it. - TYPE must be a FUNCTION_TYPE node. */ +/* Build a METHOD_TYPE for a member of BASETYPE. The RETTYPE (a TYPE) + and ARGTYPES (a TREE_LIST) are the return type and arguments types + for the method. An implicit additional parameter (of type + pointer-to-BASETYPE) is added to the ARGTYPES. */ tree -build_method_type (basetype, type) - tree basetype, type; +build_method_type_directly (tree basetype, + tree rettype, + tree argtypes) { tree t; - unsigned int hashcode; + tree ptype; + int hashcode; /* Make a node of the sort we want. */ t = make_node (METHOD_TYPE); - if (TREE_CODE (type) != FUNCTION_TYPE) - abort (); - TYPE_METHOD_BASETYPE (t) = TYPE_MAIN_VARIANT (basetype); - TREE_TYPE (t) = TREE_TYPE (type); + TREE_TYPE (t) = rettype; + ptype = build_pointer_type (basetype); /* The actual arglist for this function includes a "hidden" argument which is "this". Put it into the list of argument types. */ + argtypes = tree_cons (NULL_TREE, ptype, argtypes); + TYPE_ARG_TYPES (t) = argtypes; - TYPE_ARG_TYPES (t) - = tree_cons (NULL_TREE, - build_pointer_type (basetype), TYPE_ARG_TYPES (type)); + /* If we already have such a type, use the old one and free this one. + Note that it also frees up the above cons cell if found. */ + hashcode = TYPE_HASH (basetype) + TYPE_HASH (rettype) + + type_hash_list (argtypes); - /* If we already have such a type, use the old one and free this one. */ - hashcode = TYPE_HASH (basetype) + TYPE_HASH (type); t = type_hash_canon (hashcode, t); if (!COMPLETE_TYPE_P (t)) @@ -3781,13 +3936,28 @@ build_method_type (basetype, type) return t; } +/* Construct, lay out and return the type of methods belonging to class + BASETYPE and whose arguments and values are described by TYPE. + If that type exists already, reuse it. + TYPE must be a FUNCTION_TYPE node. */ + +tree +build_method_type (tree basetype, tree type) +{ + if (TREE_CODE (type) != FUNCTION_TYPE) + abort (); + + return build_method_type_directly (basetype, + TREE_TYPE (type), + TYPE_ARG_TYPES (type)); +} + /* Construct, lay out and return the type of offsets to a value of type TYPE, within an object of type BASETYPE. If a suitable offset type exists already, reuse it. */ tree -build_offset_type (basetype, type) - tree basetype, type; +build_offset_type (tree basetype, tree type) { tree t; unsigned int hashcode; @@ -3811,8 +3981,7 @@ build_offset_type (basetype, type) /* Create a complex type whose components are COMPONENT_TYPE. */ tree -build_complex_type (component_type) - tree component_type; +build_complex_type (tree component_type) { tree t; unsigned int hashcode; @@ -3892,9 +4061,7 @@ build_complex_type (component_type) is different from (int) OP. */ tree -get_unwidened (op, for_type) - tree op; - tree for_type; +get_unwidened (tree op, tree for_type) { /* Set UNS initially if converting OP to FOR_TYPE is a zero-extension. */ tree type = TREE_TYPE (op); @@ -3954,7 +4121,8 @@ get_unwidened (op, for_type) { unsigned int innerprec = tree_low_cst (DECL_SIZE (TREE_OPERAND (op, 1)), 1); - int unsignedp = TREE_UNSIGNED (TREE_OPERAND (op, 1)); + int unsignedp = (TREE_UNSIGNED (TREE_OPERAND (op, 1)) + || TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op, 1)))); type = (*lang_hooks.types.type_for_size) (innerprec, unsignedp); /* We can get this structure field in the narrowest type it fits in. @@ -3963,10 +4131,10 @@ get_unwidened (op, for_type) The resulting extension to its nominal type (a fullword type) must fit the same conditions as for other extensions. */ - if (innerprec < TYPE_PRECISION (TREE_TYPE (op)) + if (type != 0 + && INT_CST_LT_UNSIGNED (TYPE_SIZE (type), TYPE_SIZE (TREE_TYPE (op))) && (for_type || ! DECL_BIT_FIELD (TREE_OPERAND (op, 1))) - && (! uns || final_prec <= innerprec || unsignedp) - && type != 0) + && (! uns || final_prec <= innerprec || unsignedp)) { win = build (COMPONENT_REF, type, TREE_OPERAND (op, 0), TREE_OPERAND (op, 1)); @@ -3984,9 +4152,7 @@ get_unwidened (op, for_type) or 0 if the value should be sign-extended. */ tree -get_narrower (op, unsignedp_ptr) - tree op; - int *unsignedp_ptr; +get_narrower (tree op, int *unsignedp_ptr) { int uns = 0; int first = 1; @@ -4040,8 +4206,9 @@ get_narrower (op, unsignedp_ptr) { unsigned HOST_WIDE_INT innerprec = tree_low_cst (DECL_SIZE (TREE_OPERAND (op, 1)), 1); - tree type = (*lang_hooks.types.type_for_size) (innerprec, - TREE_UNSIGNED (op)); + int unsignedp = (TREE_UNSIGNED (TREE_OPERAND (op, 1)) + || TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op, 1)))); + tree type = (*lang_hooks.types.type_for_size) (innerprec, unsignedp); /* We can get this structure field in a narrower type that fits it, but the resulting extension to its nominal type (a fullword type) @@ -4072,32 +4239,60 @@ get_narrower (op, unsignedp_ptr) for type TYPE (an INTEGER_TYPE). */ int -int_fits_type_p (c, type) - tree c, type; -{ - /* If the bounds of the type are integers, we can check ourselves. - If not, but this type is a subtype, try checking against that. - Otherwise, use force_fit_type, which checks against the precision. */ - if (TYPE_MAX_VALUE (type) != NULL_TREE - && TYPE_MIN_VALUE (type) != NULL_TREE - && TREE_CODE (TYPE_MAX_VALUE (type)) == INTEGER_CST - && TREE_CODE (TYPE_MIN_VALUE (type)) == INTEGER_CST) +int_fits_type_p (tree c, tree type) +{ + tree type_low_bound = TYPE_MIN_VALUE (type); + tree type_high_bound = TYPE_MAX_VALUE (type); + int ok_for_low_bound, ok_for_high_bound; + + /* Perform some generic filtering first, which may allow making a decision + even if the bounds are not constant. First, negative integers never fit + in unsigned types, */ + if ((TREE_UNSIGNED (type) && tree_int_cst_sgn (c) < 0) + /* Also, unsigned integers with top bit set never fit signed types. */ + || (! TREE_UNSIGNED (type) + && TREE_UNSIGNED (TREE_TYPE (c)) && tree_int_cst_msb (c))) + return 0; + + /* If at least one bound of the type is a constant integer, we can check + ourselves and maybe make a decision. If no such decision is possible, but + this type is a subtype, try checking against that. Otherwise, use + force_fit_type, which checks against the precision. + + Compute the status for each possibly constant bound, and return if we see + one does not match. Use ok_for_xxx_bound for this purpose, assigning -1 + for "unknown if constant fits", 0 for "constant known *not* to fit" and 1 + for "constant known to fit". */ + + ok_for_low_bound = -1; + ok_for_high_bound = -1; + + /* Check if C >= type_low_bound. */ + if (type_low_bound && TREE_CODE (type_low_bound) == INTEGER_CST) { - if (TREE_UNSIGNED (type)) - return (! INT_CST_LT_UNSIGNED (TYPE_MAX_VALUE (type), c) - && ! INT_CST_LT_UNSIGNED (c, TYPE_MIN_VALUE (type)) - /* Negative ints never fit unsigned types. */ - && ! (TREE_INT_CST_HIGH (c) < 0 - && ! TREE_UNSIGNED (TREE_TYPE (c)))); - else - return (! INT_CST_LT (TYPE_MAX_VALUE (type), c) - && ! INT_CST_LT (c, TYPE_MIN_VALUE (type)) - /* Unsigned ints with top bit set never fit signed types. */ - && ! (TREE_INT_CST_HIGH (c) < 0 - && TREE_UNSIGNED (TREE_TYPE (c)))); + ok_for_low_bound = ! tree_int_cst_lt (c, type_low_bound); + if (! ok_for_low_bound) + return 0; } + + /* Check if c <= type_high_bound. */ + if (type_high_bound && TREE_CODE (type_high_bound) == INTEGER_CST) + { + ok_for_high_bound = ! tree_int_cst_lt (type_high_bound, c); + if (! ok_for_high_bound) + return 0; + } + + /* If the constant fits both bounds, the result is known. */ + if (ok_for_low_bound == 1 && ok_for_high_bound == 1) + return 1; + + /* If we haven't been able to decide at this point, there nothing more we + can check ourselves here. Look at the base type if we have one. */ else if (TREE_CODE (type) == INTEGER_TYPE && TREE_TYPE (type) != 0) return int_fits_type_p (c, TREE_TYPE (type)); + + /* Or to force_fit_type, if nothing else. */ else { c = copy_node (c); @@ -4111,56 +4306,68 @@ int_fits_type_p (c, type) modified types': in C99, a struct type is never variably modified because a VLA may not appear as a structure member. However, in GNU C code like: - + struct S { int i[f()]; }; is valid, and other languages may define similar constructs. */ bool -variably_modified_type_p (type) - tree type; +variably_modified_type_p (tree type) { + tree t; + if (type == error_mark_node) return false; - /* If TYPE itself has variable size, it is variably modified. + /* If TYPE itself has variable size, it is variably modified. We do not yet have a representation of the C99 '[*]' syntax. When a representation is chosen, this function should be modified to test for that case as well. */ - if (TYPE_SIZE (type) - && TYPE_SIZE (type) != error_mark_node - && TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST) - return true; - - /* If TYPE is a pointer or reference, it is variably modified if - the type pointed to is variably modified. */ - if ((TREE_CODE (type) == POINTER_TYPE - || TREE_CODE (type) == REFERENCE_TYPE) - && variably_modified_type_p (TREE_TYPE (type))) - return true; - - /* If TYPE is an array, it is variably modified if the array - elements are. (Note that the VLA case has already been checked - above.) */ - if (TREE_CODE (type) == ARRAY_TYPE - && variably_modified_type_p (TREE_TYPE (type))) + t = TYPE_SIZE (type); + if (t && t != error_mark_node && TREE_CODE (t) != INTEGER_CST) return true; - /* If TYPE is a function type, it is variably modified if any of the - parameters or the return type are variably modified. */ - if (TREE_CODE (type) == FUNCTION_TYPE - || TREE_CODE (type) == METHOD_TYPE) + switch (TREE_CODE (type)) { - tree parm; + case POINTER_TYPE: + case REFERENCE_TYPE: + case ARRAY_TYPE: + /* If TYPE is a pointer or reference, it is variably modified if + the type pointed to is variably modified. Similarly for arrays; + note that VLAs are handled by the TYPE_SIZE check above. */ + return variably_modified_type_p (TREE_TYPE (type)); + + case FUNCTION_TYPE: + case METHOD_TYPE: + /* If TYPE is a function type, it is variably modified if any of the + parameters or the return type are variably modified. */ + { + tree parm; - if (variably_modified_type_p (TREE_TYPE (type))) - return true; - for (parm = TYPE_ARG_TYPES (type); - parm && parm != void_list_node; - parm = TREE_CHAIN (parm)) - if (variably_modified_type_p (TREE_VALUE (parm))) + if (variably_modified_type_p (TREE_TYPE (type))) return true; + for (parm = TYPE_ARG_TYPES (type); + parm && parm != void_list_node; + parm = TREE_CHAIN (parm)) + if (variably_modified_type_p (TREE_VALUE (parm))) + return true; + } + break; + + case INTEGER_TYPE: + /* Scalar types are variably modified if their end points + aren't constant. */ + t = TYPE_MIN_VALUE (type); + if (t && t != error_mark_node && TREE_CODE (t) != INTEGER_CST) + return true; + t = TYPE_MAX_VALUE (type); + if (t && t != error_mark_node && TREE_CODE (t) != INTEGER_CST) + return true; + return false; + + default: + break; } /* The current language may have other cases to check, but in general, @@ -4172,8 +4379,7 @@ variably_modified_type_p (type) NULL_TREE if there is no containing scope. */ tree -get_containing_scope (t) - tree t; +get_containing_scope (tree t) { return (TYPE_P (t) ? TYPE_CONTEXT (t) : DECL_CONTEXT (t)); } @@ -4182,8 +4388,7 @@ get_containing_scope (t) a FUNCTION_DECL, or zero if none. */ tree -decl_function_context (decl) - tree decl; +decl_function_context (tree decl) { tree context; @@ -4222,32 +4427,35 @@ decl_function_context (decl) TYPE_DECLs and FUNCTION_DECLs are transparent to this function. */ tree -decl_type_context (decl) - tree decl; +decl_type_context (tree decl) { tree context = DECL_CONTEXT (decl); while (context) - { - if (TREE_CODE (context) == NAMESPACE_DECL) + switch (TREE_CODE (context)) + { + case NAMESPACE_DECL: + case TRANSLATION_UNIT_DECL: return NULL_TREE; - if (TREE_CODE (context) == RECORD_TYPE - || TREE_CODE (context) == UNION_TYPE - || TREE_CODE (context) == QUAL_UNION_TYPE) + case RECORD_TYPE: + case UNION_TYPE: + case QUAL_UNION_TYPE: return context; - - if (TREE_CODE (context) == TYPE_DECL - || TREE_CODE (context) == FUNCTION_DECL) + + case TYPE_DECL: + case FUNCTION_DECL: context = DECL_CONTEXT (context); - - else if (TREE_CODE (context) == BLOCK) + break; + + case BLOCK: context = BLOCK_SUPERCONTEXT (context); - - else - /* Unhandled CONTEXT!? */ + break; + + default: abort (); - } + } + return NULL_TREE; } @@ -4256,8 +4464,7 @@ decl_type_context (decl) determined. */ tree -get_callee_fndecl (call) - tree call; +get_callee_fndecl (tree call) { tree addr; @@ -4283,39 +4490,17 @@ get_callee_fndecl (call) if (TREE_CODE (addr) == ADDR_EXPR && TREE_CODE (TREE_OPERAND (addr, 0)) == FUNCTION_DECL) return TREE_OPERAND (addr, 0); - - /* We couldn't figure out what was being called. */ - return NULL_TREE; -} - -/* Print debugging information about the obstack O, named STR. */ - -void -print_obstack_statistics (str, o) - const char *str; - struct obstack *o; -{ - struct _obstack_chunk *chunk = o->chunk; - int n_chunks = 1; - int n_alloc = 0; - - n_alloc += o->next_free - chunk->contents; - chunk = chunk->prev; - while (chunk) - { - n_chunks += 1; - n_alloc += chunk->limit - &chunk->contents[0]; - chunk = chunk->prev; - } - fprintf (stderr, "obstack %s: %u bytes, %d chunks\n", - str, n_alloc, n_chunks); + + /* We couldn't figure out what was being called. Maybe the front + end has some idea. */ + return (*lang_hooks.lang_get_callee_fndecl) (call); } /* Print debugging information about tree nodes generated during the compile, and any language-specific information. */ void -dump_tree_statistics () +dump_tree_statistics (void) { #ifdef GATHER_STATISTICS int i; @@ -4324,19 +4509,19 @@ dump_tree_statistics () fprintf (stderr, "\n??? tree nodes created\n\n"); #ifdef GATHER_STATISTICS - fprintf (stderr, "Kind Nodes Bytes\n"); - fprintf (stderr, "-------------------------------------\n"); + fprintf (stderr, "Kind Nodes Bytes\n"); + fprintf (stderr, "---------------------------------------\n"); total_nodes = total_bytes = 0; for (i = 0; i < (int) all_kinds; i++) { - fprintf (stderr, "%-20s %6d %9d\n", tree_node_kind_names[i], + fprintf (stderr, "%-20s %7d %10d\n", tree_node_kind_names[i], tree_node_counts[i], tree_node_sizes[i]); total_nodes += tree_node_counts[i]; total_bytes += tree_node_sizes[i]; } - fprintf (stderr, "-------------------------------------\n"); - fprintf (stderr, "%-20s %6d %9d\n", "Total", total_nodes, total_bytes); - fprintf (stderr, "-------------------------------------\n"); + fprintf (stderr, "---------------------------------------\n"); + fprintf (stderr, "%-20s %7d %10d\n", "Total", total_nodes, total_bytes); + fprintf (stderr, "---------------------------------------\n"); #else fprintf (stderr, "(No per-node statistics)\n"); #endif @@ -4346,85 +4531,34 @@ dump_tree_statistics () #define FILE_FUNCTION_FORMAT "_GLOBAL__%s_%s" -const char *flag_random_seed; - -/* Set up a default flag_random_seed value, if there wasn't one already. */ - -void -default_flag_random_seed () -{ - unsigned HOST_WIDE_INT value; - char *new_random_seed; - - if (flag_random_seed != NULL) - return; - - /* Get some more or less random data. */ -#ifdef HAVE_GETTIMEOFDAY - { - struct timeval tv; - - gettimeofday (&tv, NULL); - value = (((unsigned HOST_WIDE_INT) tv.tv_usec << 16) - ^ tv.tv_sec ^ getpid ()); - } -#else - value = getpid (); -#endif - - /* This slightly overestimates the space required. */ - new_random_seed = xmalloc (HOST_BITS_PER_WIDE_INT / 3 + 2); - sprintf (new_random_seed, HOST_WIDE_INT_PRINT_UNSIGNED, value); - flag_random_seed = new_random_seed; -} - -/* Appends 6 random characters to TEMPLATE to (hopefully) avoid name - clashes in cases where we can't reliably choose a unique name. - - Derived from mkstemp.c in libiberty. */ +/* Generate a crc32 of a string. */ -static void -append_random_chars (template) - char *template; +unsigned +crc32_string (unsigned chksum, const char *string) { - static const char letters[] - = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"; - unsigned HOST_WIDE_INT v; - size_t i; - - default_flag_random_seed (); - - /* This isn't a very good hash, but it does guarantee no collisions - when the random string is generated by the code above and the time - delta is small. */ - v = 0; - for (i = 0; i < strlen (flag_random_seed); i++) - v = (v << 4) ^ (v >> (HOST_BITS_PER_WIDE_INT - 4)) ^ flag_random_seed[i]; - - template += strlen (template); - - /* Fill in the random bits. */ - template[0] = letters[v % 62]; - v /= 62; - template[1] = letters[v % 62]; - v /= 62; - template[2] = letters[v % 62]; - v /= 62; - template[3] = letters[v % 62]; - v /= 62; - template[4] = letters[v % 62]; - v /= 62; - template[5] = letters[v % 62]; - - template[6] = '\0'; + do + { + unsigned value = *string << 24; + unsigned ix; + + for (ix = 8; ix--; value <<= 1) + { + unsigned feedback; + + feedback = (value ^ chksum) & 0x80000000 ? 0x04c11db7 : 0; + chksum <<= 1; + chksum ^= feedback; + } + } + while (*string++); + return chksum; } /* P is a string that will be used in a symbol. Mask out any characters that are not valid in that context. */ void -clean_symbol_name (p) - char *p; +clean_symbol_name (char *p) { for (; *p; p++) if (! (ISALNUM (*p) @@ -4443,8 +4577,7 @@ clean_symbol_name (p) linker or collect2. */ tree -get_file_function_name_long (type) - const char *type; +get_file_function_name_long (const char *type) { char *buf; const char *p; @@ -4456,7 +4589,7 @@ get_file_function_name_long (type) { /* We don't have anything that we know to be unique to this translation unit, so use what we do have and throw in some randomness. */ - + unsigned len; const char *name = weak_global_object_name; const char *file = main_input_filename; @@ -4465,15 +4598,18 @@ get_file_function_name_long (type) if (! file) file = input_filename; - q = (char *) alloca (7 + strlen (name) + strlen (file)); + len = strlen (file); + q = alloca (9 * 2 + len + 1); + memcpy (q, file, len + 1); + clean_symbol_name (q); + + sprintf (q + len, "_%08X_%08X", crc32_string (0, name), + crc32_string (0, flag_random_seed)); - sprintf (q, "%s%s", name, file); - append_random_chars (q); p = q; } - buf = (char *) alloca (sizeof (FILE_FUNCTION_FORMAT) + strlen (p) - + strlen (type)); + buf = alloca (sizeof (FILE_FUNCTION_FORMAT) + strlen (p) + strlen (type)); /* Set up the name of the file-level functions we may need. Use a global object (which is already required to be unique over @@ -4481,10 +4617,6 @@ get_file_function_name_long (type) constraints). */ sprintf (buf, FILE_FUNCTION_FORMAT, type, p); - /* Don't need to pull weird characters out of global names. */ - if (p != first_global_object_name) - clean_symbol_name (buf + 11); - return get_identifier (buf); } @@ -4492,8 +4624,7 @@ get_file_function_name_long (type) If KIND=='D', return a suitable global clean-up (destructor) name. */ tree -get_file_function_name (kind) - int kind; +get_file_function_name (int kind) { char p[2]; @@ -4511,10 +4642,7 @@ get_file_function_name (kind) Otherwise, a TREE_LIST of the non-constant elements is emitted. */ tree -get_set_constructor_bits (init, buffer, bit_size) - tree init; - char *buffer; - int bit_size; +get_set_constructor_bits (tree init, char *buffer, int bit_size) { int i; tree vals; @@ -4569,17 +4697,14 @@ get_set_constructor_bits (init, buffer, bit_size) Otherwise, a TREE_LIST of the non-constant elements is emitted. */ tree -get_set_constructor_bytes (init, buffer, wd_size) - tree init; - unsigned char *buffer; - int wd_size; +get_set_constructor_bytes (tree init, unsigned char *buffer, int wd_size) { int i; int set_word_size = BITS_PER_UNIT; int bit_size = wd_size * set_word_size; int bit_pos = 0; unsigned char *bytep = buffer; - char *bit_buffer = (char *) alloca (bit_size); + char *bit_buffer = alloca (bit_size); tree non_const_bits = get_set_constructor_bits (init, bit_buffer, bit_size); for (i = 0; i < wd_size; i++) @@ -4606,12 +4731,8 @@ get_set_constructor_bytes (init, buffer, wd_size) FILE, LINE, and FUNCTION are of the caller. */ void -tree_check_failed (node, code, file, line, function) - const tree node; - enum tree_code code; - const char *file; - int line; - const char *function; +tree_check_failed (const tree node, enum tree_code code, const char *file, + int line, const char *function) { internal_error ("tree check: expected %s, have %s in %s, at %s:%d", tree_code_name[code], tree_code_name[TREE_CODE (node)], @@ -4622,12 +4743,8 @@ tree_check_failed (node, code, file, line, function) code, given in CL. */ void -tree_class_check_failed (node, cl, file, line, function) - const tree node; - int cl; - const char *file; - int line; - const char *function; +tree_class_check_failed (const tree node, int cl, const char *file, + int line, const char *function) { internal_error ("tree check: expected class '%c', have '%c' (%s) in %s, at %s:%d", @@ -4639,26 +4756,33 @@ tree_class_check_failed (node, cl, file, line, function) (dynamically sized) vector. */ void -tree_vec_elt_check_failed (idx, len, file, line, function) - int idx; - int len; - const char *file; - int line; - const char *function; +tree_vec_elt_check_failed (int idx, int len, const char *file, int line, + const char *function) { internal_error ("tree check: accessed elt %d of tree_vec with %d elts in %s, at %s:%d", idx + 1, len, function, trim_filename (file), line); } +/* Similar to above, except that the check is for the bounds of the operand + vector of an expression node. */ + +void +tree_operand_check_failed (int idx, enum tree_code code, const char *file, + int line, const char *function) +{ + internal_error + ("tree check: accessed operand %d of %s with %d operands in %s, at %s:%d", + idx + 1, tree_code_name[code], TREE_CODE_LENGTH (code), + function, trim_filename (file), line); +} #endif /* ENABLE_TREE_CHECKING */ /* For a new vector type node T, build the information necessary for debugging output. */ static void -finish_vector_type (t) - tree t; +finish_vector_type (tree t) { layout_type (t); @@ -4685,8 +4809,7 @@ finish_vector_type (t) this function to select one of the types as sizetype. */ void -build_common_tree_nodes (signed_char) - int signed_char; +build_common_tree_nodes (int signed_char) { error_mark_node = make_node (ERROR_MARK); TREE_TYPE (error_mark_node) = error_mark_node; @@ -4713,6 +4836,16 @@ build_common_tree_nodes (signed_char) long_long_integer_type_node = make_signed_type (LONG_LONG_TYPE_SIZE); long_long_unsigned_type_node = make_unsigned_type (LONG_LONG_TYPE_SIZE); + /* Define a boolean type. This type only represents boolean values but + may be larger than char depending on the value of BOOL_TYPE_SIZE. + Front ends which want to override this size (i.e. Java) can redefine + boolean_type_node before calling build_common_tree_nodes_2. */ + boolean_type_node = make_unsigned_type (BOOL_TYPE_SIZE); + TREE_SET_CODE (boolean_type_node, BOOLEAN_TYPE); + TYPE_MAX_VALUE (boolean_type_node) = build_int_2 (1, 0); + TREE_TYPE (TYPE_MAX_VALUE (boolean_type_node)) = boolean_type_node; + TYPE_PRECISION (boolean_type_node) = 1; + intQI_type_node = make_signed_type (GET_MODE_BITSIZE (QImode)); intHI_type_node = make_signed_type (GET_MODE_BITSIZE (HImode)); intSI_type_node = make_signed_type (GET_MODE_BITSIZE (SImode)); @@ -4724,14 +4857,17 @@ build_common_tree_nodes (signed_char) unsigned_intSI_type_node = make_unsigned_type (GET_MODE_BITSIZE (SImode)); unsigned_intDI_type_node = make_unsigned_type (GET_MODE_BITSIZE (DImode)); unsigned_intTI_type_node = make_unsigned_type (GET_MODE_BITSIZE (TImode)); + + access_public_node = get_identifier ("public"); + access_protected_node = get_identifier ("protected"); + access_private_node = get_identifier ("private"); } /* Call this function after calling build_common_tree_nodes and set_sizetype. It will create several other common tree nodes. */ void -build_common_tree_nodes_2 (short_double) - int short_double; +build_common_tree_nodes_2 (int short_double) { /* Define these next since types below may used them. */ integer_zero_node = build_int_2 (0, 0); @@ -4744,6 +4880,9 @@ build_common_tree_nodes_2 (short_double) bitsize_one_node = bitsize_int (1); bitsize_unit_node = bitsize_int (BITS_PER_UNIT); + boolean_false_node = TYPE_MIN_VALUE (boolean_type_node); + boolean_true_node = TYPE_MAX_VALUE (boolean_type_node); + void_type_node = make_node (VOID_TYPE); layout_type (void_type_node); @@ -4775,6 +4914,11 @@ build_common_tree_nodes_2 (short_double) TYPE_PRECISION (long_double_type_node) = LONG_DOUBLE_TYPE_SIZE; layout_type (long_double_type_node); + float_ptr_type_node = build_pointer_type (float_type_node); + double_ptr_type_node = build_pointer_type (double_type_node); + long_double_ptr_type_node = build_pointer_type (long_double_type_node); + integer_ptr_type_node = build_pointer_type (integer_type_node); + complex_integer_type_node = make_node (COMPLEX_TYPE); TREE_TYPE (complex_integer_type_node) = integer_type_node; layout_type (complex_integer_type_node); @@ -4792,10 +4936,9 @@ build_common_tree_nodes_2 (short_double) layout_type (complex_long_double_type_node); { - tree t; - BUILD_VA_LIST_TYPE (t); + tree t = (*targetm.build_builtin_va_list) (); - /* Many back-ends define record types without seting TYPE_NAME. + /* Many back-ends define record types without setting TYPE_NAME. If we copied the record type here, we'd keep the original record type without a name. This breaks name mangling. So, don't copy record types and let c_common_nodes_and_builtins() @@ -4838,16 +4981,14 @@ build_common_tree_nodes_2 (short_double) V2DF_type_node = make_vector (V2DFmode, double_type_node, 0); V16QI_type_node = make_vector (V16QImode, intQI_type_node, 0); V1DI_type_node = make_vector (V1DImode, intDI_type_node, 0); + V4DF_type_node = make_vector (V4DFmode, double_type_node, 0); } /* Returns a vector tree node given a vector mode, the inner type, and the signness. */ static tree -make_vector (mode, innertype, unsignedp) - enum machine_mode mode; - tree innertype; - int unsignedp; +make_vector (enum machine_mode mode, tree innertype, int unsignedp) { tree t; @@ -4864,8 +5005,7 @@ make_vector (mode, innertype, unsignedp) aggregate of zeros. Otherwise return FALSE. */ bool -initializer_zerop (init) - tree init; +initializer_zerop (tree init) { STRIP_NOPS (init); @@ -4883,9 +5023,14 @@ initializer_zerop (init) && ! REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (TREE_IMAGPART (init)))); case CONSTRUCTOR: { + /* Set is empty if it has no elements. */ + if ((TREE_CODE (TREE_TYPE (init)) == SET_TYPE) + && CONSTRUCTOR_ELTS (init)) + return false; + if (AGGREGATE_TYPE_P (TREE_TYPE (init))) { - tree aggr_init = TREE_OPERAND (init, 1); + tree aggr_init = CONSTRUCTOR_ELTS (init); while (aggr_init) { |
