#include "tree-flow.h"
#include "params.h"
+/* Each tree code class has an associated string representation.
+ These must correspond to the tree_code_class entries. */
+
+const char *const tree_code_class_strings[] =
+{
+ "exceptional",
+ "constant",
+ "type",
+ "declaration",
+ "reference",
+ "comparison",
+ "unary",
+ "binary",
+ "statement",
+ "expression",
+};
+
/* obstack.[ch] explicitly declined to prototype this. */
extern int _obstack_allocated_p (struct obstack *h, void *obj);
return DECL_CHECK (decl)->decl.assembler_name;
}
-/* 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. */
+/* Compute the number of bytes occupied by a tree with code CODE.
+ This function cannot be used for TREE_VEC, PHI_NODE, or STRING_CST
+ codes, which are of variable length. */
size_t
-tree_size (tree node)
+tree_code_size (enum tree_code code)
{
- enum tree_code code = TREE_CODE (node);
-
switch (TREE_CODE_CLASS (code))
{
- case 'd': /* A decl node */
+ case tcc_declaration: /* A decl node */
return sizeof (struct tree_decl);
- case 't': /* a type node */
+ case tcc_type: /* a type node */
return sizeof (struct tree_type);
- case 'r': /* a reference */
- case 'e': /* an expression */
- case 's': /* an expression with side effects */
- case '<': /* a comparison expression */
- case '1': /* a unary arithmetic expression */
- case '2': /* a binary arithmetic expression */
+ case tcc_reference: /* a reference */
+ case tcc_expression: /* an expression */
+ case tcc_statement: /* an expression with side effects */
+ case tcc_comparison: /* a comparison expression */
+ case tcc_unary: /* a unary arithmetic expression */
+ case tcc_binary: /* a binary arithmetic expression */
return (sizeof (struct tree_exp)
- + TREE_CODE_LENGTH (code) * sizeof (char *) - sizeof (char *));
+ + (TREE_CODE_LENGTH (code) - 1) * sizeof (char *));
- case 'c': /* a constant */
+ case tcc_constant: /* a constant */
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);
+ case STRING_CST: gcc_unreachable ();
default:
return lang_hooks.tree_size (code);
}
- case 'x': /* something random, like an identifier. */
+ case tcc_exceptional: /* something random, like an identifier. */
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);
- case PHI_NODE: return (sizeof (struct tree_phi_node)
- + (PHI_ARG_CAPACITY (node) - 1) *
- sizeof (struct phi_arg_d));
+ case TREE_VEC:
+ case PHI_NODE: gcc_unreachable ();
case SSA_NAME: return sizeof (struct tree_ssa_name);
}
}
-/* Return a newly allocated node of code CODE.
- For decl and type nodes, some other fields are initialized.
- The rest of the node is initialized to zero.
+/* Compute the number of bytes occupied by NODE. This routine only
+ looks at TREE_CODE, except for PHI_NODE and TREE_VEC nodes. */
+size_t
+tree_size (tree node)
+{
+ enum tree_code code = TREE_CODE (node);
+ switch (code)
+ {
+ case PHI_NODE:
+ return (sizeof (struct tree_phi_node)
+ + (PHI_ARG_CAPACITY (node) - 1) * sizeof (struct phi_arg_d));
+
+ case TREE_VEC:
+ return (sizeof (struct tree_vec)
+ + (TREE_VEC_LENGTH (node) - 1) * sizeof(char *));
+
+ case STRING_CST:
+ return sizeof (struct tree_string) + TREE_STRING_LENGTH (node) - 1;
+
+ default:
+ return tree_code_size (code);
+ }
+}
+
+/* Return a newly allocated node of code CODE. For decl and type
+ nodes, some other fields are initialized. The rest of the node is
+ initialized to zero. This function cannot be used for PHI_NODE or
+ TREE_VEC nodes, which is enforced by asserts in tree_code_size.
Achoo! I got a code in the node. */
make_node_stat (enum tree_code code MEM_STAT_DECL)
{
tree t;
- int type = TREE_CODE_CLASS (code);
- size_t length;
+ enum tree_code_class type = TREE_CODE_CLASS (code);
+ size_t length = tree_code_size (code);
#ifdef GATHER_STATISTICS
tree_node_kind kind;
-#endif
- struct tree_common ttmp;
-
- /* We can't allocate a TREE_VEC, PHI_NODE, or STRING_CST
- without knowing how many elements it will have. */
- gcc_assert (code != TREE_VEC);
- gcc_assert (code != PHI_NODE);
- TREE_SET_CODE ((tree)&ttmp, code);
- length = tree_size ((tree)&ttmp);
-
-#ifdef GATHER_STATISTICS
switch (type)
{
- case 'd': /* A decl node */
+ case tcc_declaration: /* A decl node */
kind = d_kind;
break;
- case 't': /* a type node */
+ case tcc_type: /* a type node */
kind = t_kind;
break;
- case 's': /* an expression with side effects */
+ case tcc_statement: /* an expression with side effects */
kind = s_kind;
break;
- case 'r': /* a reference */
+ case tcc_reference: /* a reference */
kind = r_kind;
break;
- case 'e': /* an expression */
- case '<': /* a comparison expression */
- case '1': /* a unary arithmetic expression */
- case '2': /* a binary arithmetic expression */
+ case tcc_expression: /* an expression */
+ case tcc_comparison: /* a comparison expression */
+ case tcc_unary: /* a unary arithmetic expression */
+ case tcc_binary: /* a binary arithmetic expression */
kind = e_kind;
break;
- case 'c': /* a constant */
+ case tcc_constant: /* a constant */
kind = c_kind;
break;
- case 'x': /* something random, like an identifier. */
- if (code == IDENTIFIER_NODE)
- kind = id_kind;
- else if (code == TREE_VEC)
- kind = vec_kind;
- else if (code == TREE_BINFO)
- kind = binfo_kind;
- else if (code == PHI_NODE)
- kind = phi_kind;
- else if (code == SSA_NAME)
- kind = ssa_name_kind;
- else if (code == BLOCK)
- kind = b_kind;
- else
- kind = x_kind;
- break;
+ case tcc_exceptional: /* something random, like an identifier. */
+ switch (code)
+ {
+ case IDENTIFIER_NODE:
+ kind = id_kind;
+ break;
+ case TREE_VEC:;
+ kind = vec_kind;
+ break;
+
+ case TREE_BINFO:
+ kind = binfo_kind;
+ break;
+
+ case PHI_NODE:
+ kind = phi_kind;
+ break;
+
+ case SSA_NAME:
+ kind = ssa_name_kind;
+ break;
+
+ case BLOCK:
+ kind = b_kind;
+ break;
+
+ default:
+ kind = x_kind;
+ break;
+ }
+ break;
+
default:
gcc_unreachable ();
}
switch (type)
{
- case 's':
+ case tcc_statement:
TREE_SIDE_EFFECTS (t) = 1;
break;
- case 'd':
+ case tcc_declaration:
if (code != FUNCTION_DECL)
DECL_ALIGN (t) = 1;
DECL_USER_ALIGN (t) = 0;
DECL_POINTER_ALIAS_SET (t) = -1;
break;
- case 't':
+ case tcc_type:
TYPE_UID (t) = next_type_uid++;
TYPE_ALIGN (t) = char_type_node ? TYPE_ALIGN (char_type_node) : 0;
TYPE_USER_ALIGN (t) = 0;
TYPE_ALIAS_SET (t) = -1;
break;
- case 'c':
+ case tcc_constant:
TREE_CONSTANT (t) = 1;
TREE_INVARIANT (t) = 1;
break;
- case 'e':
+ case tcc_expression:
switch (code)
{
case INIT_EXPR:
break;
}
break;
+
+ default:
+ /* Other classes need no special treatment. */
+ break;
}
return t;
TREE_VISITED (t) = 0;
t->common.ann = 0;
- if (TREE_CODE_CLASS (code) == 'd')
+ if (TREE_CODE_CLASS (code) == tcc_declaration)
DECL_UID (t) = next_decl_uid++;
- else if (TREE_CODE_CLASS (code) == 't')
+ else if (TREE_CODE_CLASS (code) == tcc_type)
{
TYPE_UID (t) = next_type_uid++;
/* The following is so that the debug code for
tree
build_string (int len, const char *str)
{
- tree s = make_node (STRING_CST);
+ tree s;
+ size_t length;
+
+ length = len + sizeof (struct tree_string);
+
+#ifdef GATHER_STATISTICS
+ tree_node_counts[(int) c_kind]++;
+ tree_node_sizes[(int) c_kind] += length;
+#endif
+ s = ggc_alloc_tree (length);
+
+ memset (s, 0, sizeof (struct tree_common));
+ TREE_SET_CODE (s, STRING_CST);
TREE_STRING_LENGTH (s) = len;
- TREE_STRING_POINTER (s) = ggc_alloc_string (str, len);
+ memcpy ((char *) TREE_STRING_POINTER (s), str, len);
+ ((char *) TREE_STRING_POINTER (s))[len] = '\0';
return s;
}
case BIT_FIELD_REF:
return NULL;
+ case MISALIGNED_INDIRECT_REF:
+ case ALIGN_INDIRECT_REF:
case INDIRECT_REF:
return TREE_CONSTANT (TREE_OPERAND (arg, 0)) ? arg : NULL;
inner = expr;
while (1)
{
- if (TREE_CODE_CLASS (TREE_CODE (inner)) == '1')
+ if (UNARY_CLASS_P (inner))
inner = TREE_OPERAND (inner, 0);
- else if (TREE_CODE_CLASS (TREE_CODE (inner)) == '2')
+ else if (BINARY_CLASS_P (inner))
{
if (TREE_INVARIANT (TREE_OPERAND (inner, 1)))
inner = TREE_OPERAND (inner, 0);
switch (TREE_CODE_CLASS (code))
{
- case 'd': return TS_DECL;
- case 't': return TS_TYPE;
- case 'r': case '<': case '1': case '2': case 'e': case 's':
+ case tcc_declaration:
+ return TS_DECL;
+ case tcc_type:
+ return TS_TYPE;
+ case tcc_reference:
+ case tcc_comparison:
+ case tcc_unary:
+ case tcc_binary:
+ case tcc_expression:
+ case tcc_statement:
return TS_EXP;
- default: /* 'c' and 'x' */
+ default: /* tcc_constant and tcc_exceptional */
break;
}
switch (code)
{
- /* 'c' cases. */
+ /* tcc_constant cases. */
case INTEGER_CST: return TS_INT_CST;
case REAL_CST: return TS_REAL_CST;
case COMPLEX_CST: return TS_COMPLEX;
case VECTOR_CST: return TS_VECTOR;
case STRING_CST: return TS_STRING;
- /* 'x' cases. */
+ /* tcc_exceptional cases. */
case ERROR_MARK: return TS_COMMON;
case IDENTIFIER_NODE: return TS_IDENTIFIER;
case TREE_LIST: return TS_LIST;
switch (TREE_CODE_CLASS (code))
{
- case 'r':
+ case tcc_reference:
/* Don't look at any PLACEHOLDER_EXPRs that might be in index or bit
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));
- case 'x':
+ case tcc_exceptional:
if (code == TREE_LIST)
return (CONTAINS_PLACEHOLDER_P (TREE_VALUE (exp))
|| CONTAINS_PLACEHOLDER_P (TREE_CHAIN (exp)));
break;
- case '1':
- case '2': case '<':
- case 'e':
+ case tcc_unary:
+ case tcc_binary:
+ case tcc_comparison:
+ case tcc_expression:
switch (code)
{
case COMPOUND_EXPR:
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. */
+/* Return true 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)
+static bool
+type_contains_placeholder_1 (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. */
|| CONTAINS_PLACEHOLDER_P (TYPE_SIZE_UNIT (type))
|| (TREE_TYPE (type) != 0
&& type_contains_placeholder_p (TREE_TYPE (type))))
- return 1;
+ return true;
/* Now do type-specific checks. Note that the last part of the check above
greatly limits what we have to do below. */
case METHOD_TYPE:
case FILE_TYPE:
case FUNCTION_TYPE:
- return 0;
+ return false;
case INTEGER_TYPE:
case REAL_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
|| (TREE_CODE (type) == QUAL_UNION_TYPE
&& CONTAINS_PLACEHOLDER_P (DECL_QUALIFIER (field)))
|| type_contains_placeholder_p (TREE_TYPE (field))))
- {
- ret = true;
- break;
- }
+ return true;
- /* 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;
+ return false;
}
default:
}
}
-/* Return 1 if EXP contains any expressions that produce cleanups for an
- outer scope to deal with. Used by fold. */
-
-int
-has_cleanups (tree exp)
+bool
+type_contains_placeholder_p (tree type)
{
- int i, nops, cmp;
+ bool result;
- if (! TREE_SIDE_EFFECTS (exp))
- return 0;
+ /* If the contains_placeholder_bits field has been initialized,
+ then we know the answer. */
+ if (TYPE_CONTAINS_PLACEHOLDER_INTERNAL (type) > 0)
+ return TYPE_CONTAINS_PLACEHOLDER_INTERNAL (type) - 1;
- switch (TREE_CODE (exp))
- {
- case TARGET_EXPR:
- case WITH_CLEANUP_EXPR:
- return 1;
-
- case CLEANUP_POINT_EXPR:
- return 0;
+ /* Indicate that we've seen this type node, and the answer is false.
+ This is what we want to return if we run into recursion via fields. */
+ TYPE_CONTAINS_PLACEHOLDER_INTERNAL (type) = 1;
- case CALL_EXPR:
- for (exp = TREE_OPERAND (exp, 1); exp; exp = TREE_CHAIN (exp))
- {
- cmp = has_cleanups (TREE_VALUE (exp));
- if (cmp)
- return cmp;
- }
- return 0;
+ /* Compute the real value. */
+ result = type_contains_placeholder_1 (type);
- case DECL_EXPR:
- return (DECL_INITIAL (DECL_EXPR_DECL (exp))
- && has_cleanups (DECL_INITIAL (DECL_EXPR_DECL (exp))));
+ /* Store the real value. */
+ TYPE_CONTAINS_PLACEHOLDER_INTERNAL (type) = result + 1;
- default:
- break;
- }
-
- /* This general rule works for most tree codes. All exceptions should be
- handled above. If this is a language-specific tree code, we can't
- trust what might be in the operand, so say we don't know
- the situation. */
- if ((int) TREE_CODE (exp) >= (int) LAST_AND_UNUSED_TREE_CODE)
- return -1;
-
- nops = first_rtl_op (TREE_CODE (exp));
- for (i = 0; i < nops; i++)
- if (TREE_OPERAND (exp, i) != 0)
- {
- int type = TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp, i)));
- if (type == 'e' || type == '<' || type == '1' || type == '2'
- || type == 'r' || type == 's')
- {
- cmp = has_cleanups (TREE_OPERAND (exp, i));
- if (cmp)
- return cmp;
- }
- }
-
- return 0;
+ return result;
}
\f
/* Given a tree EXP, a FIELD_DECL F, and a replacement value R,
/* If this expression is getting a value from a PLACEHOLDER_EXPR
and it is the right field, replace it with R. */
for (inner = TREE_OPERAND (exp, 0);
- TREE_CODE_CLASS (TREE_CODE (inner)) == 'r';
+ REFERENCE_CLASS_P (inner);
inner = TREE_OPERAND (inner, 0))
;
if (TREE_CODE (inner) == PLACEHOLDER_EXPR
else
switch (TREE_CODE_CLASS (code))
{
- case 'c':
- case 'd':
+ case tcc_constant:
+ case tcc_declaration:
return exp;
- case 'x':
- case '1':
- case '2':
- case '<':
- case 'e':
- case 'r':
+ case tcc_exceptional:
+ case tcc_unary:
+ case tcc_binary:
+ case tcc_comparison:
+ case tcc_expression:
+ case tcc_reference:
switch (first_rtl_op (code))
{
case 0:
elt = ((TREE_CODE (elt) == COMPOUND_EXPR
|| TREE_CODE (elt) == COND_EXPR)
? TREE_OPERAND (elt, 1)
- : (TREE_CODE_CLASS (TREE_CODE (elt)) == 'r'
- || TREE_CODE_CLASS (TREE_CODE (elt)) == '1'
- || TREE_CODE_CLASS (TREE_CODE (elt)) == '2'
- || TREE_CODE_CLASS (TREE_CODE (elt)) == 'e')
+ : (REFERENCE_CLASS_P (elt)
+ || UNARY_CLASS_P (elt)
+ || BINARY_CLASS_P (elt)
+ || EXPRESSION_CLASS_P (elt))
? TREE_OPERAND (elt, 0) : 0))
if (TYPE_MAIN_VARIANT (TREE_TYPE (elt)) == need_type)
return elt;
elt = ((TREE_CODE (elt) == COMPOUND_EXPR
|| TREE_CODE (elt) == COND_EXPR)
? TREE_OPERAND (elt, 1)
- : (TREE_CODE_CLASS (TREE_CODE (elt)) == 'r'
- || TREE_CODE_CLASS (TREE_CODE (elt)) == '1'
- || TREE_CODE_CLASS (TREE_CODE (elt)) == '2'
- || TREE_CODE_CLASS (TREE_CODE (elt)) == 'e')
+ : (REFERENCE_CLASS_P (elt)
+ || UNARY_CLASS_P (elt)
+ || BINARY_CLASS_P (elt)
+ || EXPRESSION_CLASS_P (elt))
? TREE_OPERAND (elt, 0) : 0))
if (POINTER_TYPE_P (TREE_TYPE (elt))
&& (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (elt)))
else
switch (TREE_CODE_CLASS (code))
{
- case 'c':
- case 'd':
+ case tcc_constant:
+ case tcc_declaration:
return exp;
- case 'x':
- case '1':
- case '2':
- case '<':
- case 'e':
- case 'r':
- case 's':
+ case tcc_exceptional:
+ case tcc_unary:
+ case tcc_binary:
+ case tcc_comparison:
+ case tcc_expression:
+ case tcc_reference:
+ case tcc_statement:
switch (first_rtl_op (code))
{
case 0:
switch (TREE_CODE_CLASS (code))
{
- case 'x':
- case 't':
- case 'd':
- case '<':
- case 's':
- case 'e':
- case 'r':
+ case tcc_exceptional:
+ case tcc_type:
+ case tcc_declaration:
+ case tcc_comparison:
+ case tcc_statement:
+ case tcc_expression:
+ case tcc_reference:
/* If the expression has side-effects, then encase it in a SAVE_EXPR
so that it will only be evaluated once. */
/* The reference (r) and comparison (<) classes could be handled as
return save_expr (e);
return e;
- case 'c':
+ case tcc_constant:
/* Constants need no processing. In fact, we should never reach
here. */
return e;
- case '2':
+ case tcc_binary:
/* Division is slow and tends to be compiled with jumps,
especially the division by powers of 2 that is often
found inside of an array reference. So do it just once. */
stabilize_reference_1 (TREE_OPERAND (e, 1)));
break;
- case '1':
+ case tcc_unary:
/* Recursively stabilize each operand. */
result = build_nt (code, stabilize_reference_1 (TREE_OPERAND (e, 0)));
break;
else
ti = tc = false;
}
- else if (TREE_CODE_CLASS (TREE_CODE (node)) == 'c')
+ else if (CONSTANT_CLASS_P (node))
;
else
{
#ifdef GATHER_STATISTICS
switch (TREE_CODE_CLASS (code))
{
- case 's': /* an expression with side effects */
+ case tcc_statement: /* an expression with side effects */
kind = s_kind;
break;
- case 'r': /* a reference */
+ case tcc_reference: /* a reference */
kind = r_kind;
break;
default:
TREE_READONLY (t) = TREE_READONLY (node);
}
- if (TREE_CODE_CLASS (code) == 's')
+ if (TREE_CODE_CLASS (code) == tcc_statement)
TREE_SIDE_EFFECTS (t) = 1;
else switch (code)
{
TREE_READONLY (t) = 0;
break;
+ case MISALIGNED_INDIRECT_REF:
+ case ALIGN_INDIRECT_REF:
case INDIRECT_REF:
/* Whether a dereference is readonly has nothing to do with whether
its operand is readonly. */
break;
default:
- if (TREE_CODE_CLASS (code) == '1' && node && !TYPE_P (node)
+ if (TREE_CODE_CLASS (code) == tcc_unary
+ && node && !TYPE_P (node)
&& TREE_CONSTANT (node))
TREE_CONSTANT (t) = 1;
- if (TREE_CODE_CLASS (code) == '1' && node && TREE_INVARIANT (node))
+ if (TREE_CODE_CLASS (code) == tcc_unary
+ && node && TREE_INVARIANT (node))
TREE_INVARIANT (t) = 1;
- if (TREE_CODE_CLASS (code) == 'r' && node && TREE_THIS_VOLATILE (node))
+ if (TREE_CODE_CLASS (code) == tcc_reference
+ && node && TREE_THIS_VOLATILE (node))
TREE_THIS_VOLATILE (t) = 1;
break;
}
/* Expressions without side effects may be constant if their
arguments are as well. */
- constant = (TREE_CODE_CLASS (code) == '<'
- || TREE_CODE_CLASS (code) == '2');
+ constant = (TREE_CODE_CLASS (code) == tcc_comparison
+ || TREE_CODE_CLASS (code) == tcc_binary);
read_only = 1;
side_effects = TREE_SIDE_EFFECTS (t);
invariant = constant;
TREE_INVARIANT (t) = invariant;
TREE_SIDE_EFFECTS (t) = side_effects;
TREE_THIS_VOLATILE (t)
- = TREE_CODE_CLASS (code) == 'r' && arg0 && TREE_THIS_VOLATILE (arg0);
+ = (TREE_CODE_CLASS (code) == tcc_reference
+ && arg0 && TREE_THIS_VOLATILE (arg0));
return t;
}
TREE_SIDE_EFFECTS (t) = side_effects;
TREE_THIS_VOLATILE (t)
- = TREE_CODE_CLASS (code) == 'r' && arg0 && TREE_THIS_VOLATILE (arg0);
+ = (TREE_CODE_CLASS (code) == tcc_reference
+ && arg0 && TREE_THIS_VOLATILE (arg0));
return t;
}
TREE_SIDE_EFFECTS (t) = side_effects;
TREE_THIS_VOLATILE (t)
- = TREE_CODE_CLASS (code) == 'r' && arg0 && TREE_THIS_VOLATILE (arg0);
+ = (TREE_CODE_CLASS (code) == tcc_reference
+ && arg0 && TREE_THIS_VOLATILE (arg0));
return t;
}
}
if (TREE_CODE (node) != RECORD_TYPE && TREE_CODE (node) != UNION_TYPE)
{
- warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
+ warning ("%qs attribute ignored", IDENTIFIER_POINTER (name));
*no_add_attrs = true;
}
if (TREE_CODE (node) == FUNCTION_DECL && DECL_INITIAL (node)
&& !DECL_DECLARED_INLINE_P (node))
{
- error ("%Jfunction `%D' definition is marked dllimport.", node, node);
+ error ("%Jfunction %qD definition is marked dllimport.", node, node);
*no_add_attrs = true;
}
{
if (DECL_INITIAL (node))
{
- error ("%Jvariable `%D' definition is marked dllimport.",
+ error ("%Jvariable %qD definition is marked dllimport.",
node, node);
*no_add_attrs = true;
}
&& (TREE_CODE (node) == VAR_DECL
|| TREE_CODE (node) == FUNCTION_DECL))
{
- error ("%Jexternal linkage required for symbol '%D' because of "
- "'%s' attribute.", node, node, IDENTIFIER_POINTER (name));
+ error ("%Jexternal linkage required for symbol %qD because of "
+ "%qs attribute.", node, node, IDENTIFIER_POINTER (name));
*no_add_attrs = true;
}
switch (TREE_CODE_CLASS (code1))
{
- case '1':
- case '2':
- case '<':
- case 'e':
- case 'r':
- case 's':
+ case tcc_unary:
+ case tcc_binary:
+ case tcc_comparison:
+ case tcc_expression:
+ case tcc_reference:
+ case tcc_statement:
cmp = 1;
for (i = 0; i < TREE_CODE_LENGTH (code1); i++)
{
default:
class = TREE_CODE_CLASS (code);
- if (class == 'd')
+ if (class == tcc_declaration)
{
/* Decls we can just compare by pointer. */
val = iterative_hash_pointer (t, val);
}
- else if (IS_EXPR_CODE_CLASS (class))
+ else
{
+ gcc_assert (IS_EXPR_CODE_CLASS (class));
+
val = iterative_hash_object (code, val);
/* Don't hash the type, that can lead to having nodes which
for (i = first_rtl_op (code) - 1; i >= 0; --i)
val = iterative_hash_expr (TREE_OPERAND (t, i), val);
}
- else
- gcc_unreachable ();
return val;
break;
}
TREE_TYPE (itype) = sizetype;
TYPE_PRECISION (itype) = TYPE_PRECISION (sizetype);
TYPE_MIN_VALUE (itype) = size_zero_node;
- TYPE_MAX_VALUE (itype) = convert (sizetype, maxval);
+ TYPE_MAX_VALUE (itype) = fold_convert (sizetype, maxval);
TYPE_MODE (itype) = TYPE_MODE (sizetype);
TYPE_SIZE (itype) = TYPE_SIZE (sizetype);
TYPE_SIZE_UNIT (itype) = TYPE_SIZE_UNIT (sizetype);
if (TYPE_P (*tp))
*walk_subtrees = 0;
- else if (DECL_P (*tp) && lang_hooks.tree_inlining.auto_var_in_fn_p (*tp, fn))
+ else if (DECL_P (*tp)
+ && lang_hooks.tree_inlining.auto_var_in_fn_p (*tp, fn))
return *tp;
return NULL_TREE;
code, given in CL. */
void
-tree_class_check_failed (const tree node, int cl, const char *file,
- int line, const char *function)
+tree_class_check_failed (const tree node, const enum tree_code_class cl,
+ const char *file, int line, const char *function)
{
internal_error
- ("tree check: expected class '%c', have '%c' (%s) in %s, at %s:%d",
- cl, TREE_CODE_CLASS (TREE_CODE (node)),
+ ("tree check: expected class %qs, have %qs (%s) in %s, at %s:%d",
+ TREE_CODE_CLASS_STRING (cl),
+ TREE_CODE_CLASS_STRING (TREE_CODE_CLASS (TREE_CODE (node))),
tree_code_name[TREE_CODE (node)], function, trim_filename (file), line);
}
}
else if (TREE_CODE (type) == METHOD_TYPE)
{
+ tree argtypes;
inner = reconstruct_complex_type (TREE_TYPE (type), bottom);
+ /* The build_method_type_directly() routine prepends 'this' to argument list,
+ so we must compensate by getting rid of it. */
+ argtypes = TYPE_ARG_TYPES (type);
outer = build_method_type_directly (TYPE_METHOD_BASETYPE (type),
inner,
TYPE_ARG_TYPES (type));
+ TYPE_ARG_TYPES (outer) = argtypes;
}
else
return bottom;
}
}
+/* Returns unsigned variant of TYPE. */
+
+tree
+unsigned_type_for (tree type)
+{
+ return lang_hooks.types.unsigned_type (type);
+}
+
+/* Returns signed variant of TYPE. */
+
+tree
+signed_type_for (tree type)
+{
+ return lang_hooks.types.signed_type (type);
+}
+
#include "gt-tree.h"