#include "tree-iterator.h"
#include "basic-block.h"
#include "tree-flow.h"
+#include "opts.h"
/* obstack.[ch] explicitly declined to prototype this. */
extern int _obstack_allocated_p (struct obstack *h, void *obj);
"perm_tree_lists",
"temp_tree_lists",
"vecs",
+ "binfos",
"phi_nodes",
"ssa names",
"random kinds",
tree type;
};
+/* Additional language-dependent binfo slots. */
+unsigned binfo_lang_slots;
+
/* Initial size of the hash table (rounded to next prime). */
#define TYPE_HASH_INITIAL_SIZE 1000
case STATEMENT_LIST: return sizeof (struct tree_statement_list);
case BLOCK: return sizeof (struct tree_block);
+ case VALUE_HANDLE: return sizeof (struct tree_value_handle);
default:
return lang_hooks.tree_size (code);
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)
DECL_USER_ALIGN (t) = 0;
DECL_IN_SYSTEM_HEADER (t) = in_system_header;
DECL_SOURCE_LOCATION (t) = input_location;
- DECL_UID (t) = next_decl_uid++;
+ if (code == TRANSLATION_UNIT_DECL)
+ DECL_UID (t) = cur_in_fname;
+ else
+ DECL_UID (t) = next_decl_uid++;
/* We have not yet computed the alias set for this declaration. */
DECL_POINTER_ALIAS_SET (t) = -1;
case INIT_EXPR:
case MODIFY_EXPR:
case VA_ARG_EXPR:
- case RTL_EXPR:
case PREDECREMENT_EXPR:
case PREINCREMENT_EXPR:
case POSTDECREMENT_EXPR:
TREE_VISITED (t) = 0;
t->common.ann = 0;
- if (TREE_CODE_CLASS (code) == 'd')
+ if (TREE_CODE_CLASS (code) == 'd' && code != TRANSLATION_UNIT_DECL)
DECL_UID (t) = next_decl_uid++;
else if (TREE_CODE_CLASS (code) == 't')
{
return t;
}
+/* Build a BINFO with LEN language slots. */
+
+tree
+make_tree_binfo_stat (unsigned lang_slots MEM_STAT_DECL)
+{
+ tree t;
+ static unsigned length;
+
+ if (!length)
+ {
+ length = (offsetof (struct tree_binfo, lang_slots)
+ + (sizeof (((struct tree_binfo *)0)->lang_slots[0])
+ * lang_slots));
+ binfo_lang_slots = lang_slots;
+ }
+ else if (binfo_lang_slots != lang_slots)
+ abort ();
+
+#ifdef GATHER_STATISTICS
+ tree_node_counts[(int) binfo_kind]++;
+ tree_node_sizes[(int) binfo_kind] += length;
+#endif
+
+ t = ggc_alloc_zone_stat (length, tree_zone PASS_MEM_STAT);
+
+ memset (t, 0, length);
+
+ TREE_SET_CODE (t, TREE_BINFO);
+
+ return t;
+}
+
+
/* Build a newly constructed TREE_VEC node of length LEN. */
tree
if (contains_placeholder_p (inner))
return t;
- t = build3 (SAVE_EXPR, TREE_TYPE (expr), t, current_function_decl,
- NULL_TREE);
+ t = build1 (SAVE_EXPR, TREE_TYPE (expr), t);
/* This expression might be placed ahead of a jump to ensure that the
value was computed on both sides of the jump. So make sure it isn't
{
switch (code)
{
- case SAVE_EXPR:
- return 2;
case GOTO_SUBROUTINE_EXPR:
- case RTL_EXPR:
return 0;
case WITH_CLEANUP_EXPR:
return 2;
case PLACEHOLDER_EXPR: return TS_COMMON;
case STATEMENT_LIST: return TS_STATEMENT_LIST;
case BLOCK: return TS_BLOCK;
+ case TREE_BINFO: return TS_BINFO;
+ case VALUE_HANDLE: return TS_VALUE_HANDLE;
default:
abort ();
{
switch (TREE_CODE (expr))
{
- case SAVE_EXPR:
- if (! SAVE_EXPR_PERSISTENT_P (expr))
- SAVE_EXPR_RTL (expr) = 0;
- break;
-
case TARGET_EXPR:
/* Don't mess with a TARGET_EXPR that hasn't been expanded.
It's OK for this to happen if it was part of a subtree that
TREE_OPERAND (expr, 3) = NULL_TREE;
break;
- case RTL_EXPR:
- /* I don't yet know how to emit a sequence multiple times. */
- if (RTL_EXPR_SEQUENCE (expr) != 0)
- abort ();
- break;
-
default:
break;
}
SAVE_EXPRs basically *only* appear replicated in an expression tree,
occasionally across the whole of a function. It is therefore only
safe to unsave a SAVE_EXPR if you know that all occurrences appear
- below the UNSAVE_EXPR.
-
- RTL_EXPRs consume their rtl during evaluation. It is therefore
- never possible to unsave them. */
+ below the UNSAVE_EXPR. */
int
unsafe_for_reeval (tree expr)
switch (code)
{
case SAVE_EXPR:
- case RTL_EXPR:
return 2;
/* A label can only be emitted once. */
contains_placeholder_p (tree exp)
{
enum tree_code code;
- int result;
if (!exp)
return 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
- check again. */
- if (SAVE_EXPR_NOPLACEHOLDER (exp) || SAVE_EXPR_RTL (exp) != 0)
- return 0;
-
- SAVE_EXPR_NOPLACEHOLDER (exp) = 1;
- result = CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 0));
- if (result)
- SAVE_EXPR_NOPLACEHOLDER (exp) = 0;
-
- return result;
-
default:
break;
}
}
return 0;
+ case DECL_EXPR:
+ return (DECL_INITIAL (DECL_EXPR_DECL (exp))
+ && has_cleanups (DECL_INITIAL (DECL_EXPR_DECL (exp))));
+
default:
break;
}
volatiles. */
return stabilize_reference_1 (ref);
- case RTL_EXPR:
- result = build1 (INDIRECT_REF, TREE_TYPE (ref),
- save_expr (build1 (ADDR_EXPR,
- build_pointer_type (TREE_TYPE (ref)),
- ref)));
- break;
-
/* If arg isn't a kind of lvalue we recognize, make no change.
Caller should recognize the error for an invalid lvalue. */
default:
}
/* Now see what's inside. If it's an INDIRECT_REF, copy our properties from
- it. If it's a decl, it's definitely invariant and it's constant if the
- decl is static. (Taking the address of a volatile variable is not
- volatile.) If it's a constant, the address is both invariant and
- constant. Otherwise it's neither. */
+ it. If it's a decl, it's invariant and constant if the decl is static.
+ It's also invariant if it's a decl in the current function. (Taking the
+ address of a volatile variable is not volatile.) If it's a constant,
+ the address is both invariant and constant. Otherwise it's neither. */
if (TREE_CODE (node) == INDIRECT_REF)
UPDATE_TITCSE (node);
else if (DECL_P (node))
{
- if (!staticp (node))
+ if (staticp (node))
+ ;
+ else if (decl_function_context (node) == current_function_decl)
tc = false;
+ else
+ ti = tc = false;
}
else if (TREE_CODE_CLASS (TREE_CODE (node)) == 'c')
;
TREE_SET_CODE (t, code);
TREE_TYPE (t) = type;
+#ifdef USE_MAPPED_LOCATION
+ SET_EXPR_LOCATION (t, UNKNOWN_LOCATION);
+#else
SET_EXPR_LOCUS (t, NULL);
+#endif
TREE_COMPLEXITY (t) = 0;
TREE_OPERAND (t, 0) = node;
TREE_BLOCK (t) = NULL_TREE;
case INIT_EXPR:
case MODIFY_EXPR:
case VA_ARG_EXPR:
- case RTL_EXPR:
case PREDECREMENT_EXPR:
case PREINCREMENT_EXPR:
case POSTDECREMENT_EXPR:
TREE_CONSTANT (t) = 1;
if (TREE_CODE_CLASS (code) == '1' && node && TREE_INVARIANT (node))
TREE_INVARIANT (t) = 1;
+ if (TREE_CODE_CLASS (code) == 'r' && node && TREE_THIS_VOLATILE (node))
+ TREE_THIS_VOLATILE (t) = 1;
break;
}
return block;
}
+#if 1 /* ! defined(USE_MAPPED_LOCATION) */
+/* ??? gengtype doesn't handle conditionals */
static GTY(()) tree last_annotated_node;
+#endif
+
+#ifdef USE_MAPPED_LOCATION
+
+expanded_location
+expand_location (source_location loc)
+{
+ expanded_location xloc;
+ if (loc == 0) { xloc.file = NULL; xloc.line = 0; }
+ else
+ {
+ const struct line_map *map = linemap_lookup (&line_table, loc);
+ xloc.file = map->to_file;
+ xloc.line = SOURCE_LINE (map, loc);
+ };
+ return xloc;
+}
+
+#else
/* Record the exact location where an expression or an identifier were
encountered. */
{
annotate_with_file_line (node, locus.file, locus.line);
}
+#endif
\f
/* Return a declaration like DDECL except that its DECL_ATTRIBUTES
is ATTRIBUTE. */
|| tree_int_cst_equal (TYPE_MAX_VALUE (a->type),
TYPE_MAX_VALUE (b->type)))
&& (TYPE_MIN_VALUE (a->type) == TYPE_MIN_VALUE (b->type)
- && tree_int_cst_equal (TYPE_MIN_VALUE (a->type),
+ || tree_int_cst_equal (TYPE_MIN_VALUE (a->type),
TYPE_MIN_VALUE (b->type))));
case OFFSET_TYPE:
code = TREE_CODE (t);
class = TREE_CODE_CLASS (code);
- if (class == 'd')
+ if (class == 'd'
+ || TREE_CODE (t) == VALUE_HANDLE)
{
/* Decls we can just compare by pointer. */
val = iterative_hash_object (t, val);
}
}
+/* Subprogram of following function. Called by walk_tree.
+
+ Return *TP if it is an automatic variable or parameter of the
+ function passed in as DATA. */
+
+static tree
+find_var_from_fn (tree *tp, int *walk_subtrees, void *data)
+{
+ tree fn = (tree) data;
+
+ if (TYPE_P (*tp))
+ *walk_subtrees = 0;
+
+ else if (DECL_P (*tp) && lang_hooks.tree_inlining.auto_var_in_fn_p (*tp, fn))
+ return *tp;
+
+ return NULL_TREE;
+}
+
/* Returns true if T is, contains, or refers to a type with variable
- size. This concept is more general than that of C99 'variably
- 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:
+ size. If FN is nonzero, only return true if a modifier of the type
+ or position of FN is a variable or parameter inside FN.
+
+ This concept is more general than that of C99 'variably 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 (tree type)
+variably_modified_type_p (tree type, tree fn)
{
tree t;
+/* Test if T is either variable (if FN is zero) or an expression containing
+ a variable in FN. */
+#define RETURN_TRUE_IF_VAR(T) \
+ do { tree _t = (T); \
+ if (_t && _t != error_mark_node && TREE_CODE (_t) != INTEGER_CST \
+ && (!fn || walk_tree (&_t, find_var_from_fn, fn, NULL))) \
+ return true; } while (0)
+
if (type == error_mark_node)
return false;
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. */
- t = TYPE_SIZE (type);
- if (t && t != error_mark_node && TREE_CODE (t) != INTEGER_CST)
- return true;
+ RETURN_TRUE_IF_VAR (TYPE_SIZE (type));
+ RETURN_TRUE_IF_VAR (TYPE_SIZE_UNIT(type));
switch (TREE_CODE (type))
{
case ARRAY_TYPE:
case SET_TYPE:
case VECTOR_TYPE:
- if (variably_modified_type_p (TREE_TYPE (type)))
+ if (variably_modified_type_p (TREE_TYPE (type), fn))
return true;
break;
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. */
- if (variably_modified_type_p (TREE_TYPE (type)))
+ if (variably_modified_type_p (TREE_TYPE (type), fn))
return true;
for (t = TYPE_ARG_TYPES (type);
t && t != void_list_node;
t = TREE_CHAIN (t))
- if (variably_modified_type_p (TREE_VALUE (t)))
+ if (variably_modified_type_p (TREE_VALUE (t), fn))
return true;
break;
case CHAR_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_TRUE_IF_VAR (TYPE_MIN_VALUE (type));
+ RETURN_TRUE_IF_VAR (TYPE_MAX_VALUE (type));
break;
case RECORD_TYPE:
for (t = TYPE_FIELDS (type); t; t = TREE_CHAIN (t))
if (TREE_CODE (t) == FIELD_DECL)
{
- tree t1 = DECL_FIELD_OFFSET (t);
+ RETURN_TRUE_IF_VAR (DECL_FIELD_OFFSET (t));
+ RETURN_TRUE_IF_VAR (DECL_SIZE (t));
+ RETURN_TRUE_IF_VAR (DECL_SIZE_UNIT (t));
- if (t1 && t1 != error_mark_node && TREE_CODE (t1) != INTEGER_CST)
- return true;
-
- t1 = DECL_SIZE (t);
- if (t1 && t1 != error_mark_node && TREE_CODE (t1) != INTEGER_CST)
- return true;
+ if (TREE_CODE (type) == QUAL_UNION_TYPE)
+ RETURN_TRUE_IF_VAR (DECL_QUALIFIER (t));
}
break;
/* The current language may have other cases to check, but in general,
all other types are not variably modified. */
- return lang_hooks.tree_inlining.var_mod_type_p (type);
+ return lang_hooks.tree_inlining.var_mod_type_p (type, fn);
+
+#undef RETURN_TRUE_IF_VAR
}
/* Given a DECL or TYPE, return the scope in which it was declared, or
if (TREE_CODE (decl) == ERROR_MARK)
return 0;
- if (TREE_CODE (decl) == SAVE_EXPR)
- context = SAVE_EXPR_CONTEXT (decl);
-
/* C++ virtual functions use DECL_CONTEXT for the class of the vtable
where we look up the function at runtime. Such functions always take
a first argument of type 'pointer to real context'.
\f
#if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
-/* Complain that the tree code of NODE does not match the expected CODE.
- FILE, LINE, and FUNCTION are of the caller. */
+/* Complain that the tree code of NODE does not match the expected 0
+ terminated list of trailing codes. FILE, LINE, and FUNCTION are of
+ the caller. */
void
-tree_check_failed (const tree node, enum tree_code code, const char *file,
- int line, const char *function)
-{
+tree_check_failed (const tree node, const char *file,
+ int line, const char *function, ...)
+{
+ va_list args;
+ char *buffer;
+ unsigned length = 0;
+ int code;
+
+ va_start (args, function);
+ while ((code = va_arg (args, int)))
+ length += 4 + strlen (tree_code_name[code]);
+ va_end (args);
+ va_start (args, function);
+ buffer = alloca (length);
+ length = 0;
+ while ((code = va_arg (args, int)))
+ {
+ if (length)
+ {
+ strcpy (buffer + length, " or ");
+ length += 4;
+ }
+ strcpy (buffer + length, tree_code_name[code]);
+ length += strlen (tree_code_name[code]);
+ }
+ va_end (args);
+
internal_error ("tree check: expected %s, have %s in %s, at %s:%d",
- tree_code_name[code], tree_code_name[TREE_CODE (node)],
+ buffer, tree_code_name[TREE_CODE (node)],
function, trim_filename (file), line);
}
-/* Similar to above except that we allowed the code to be one of two
- different codes. */
+/* Complain that the tree code of NODE does match the expected 0
+ terminated list of trailing codes. FILE, LINE, and FUNCTION are of
+ the caller. */
void
-tree_check2_failed (const tree node, enum tree_code code1,
- enum tree_code code2, const char *file,
- int line, const char *function)
-{
- internal_error ("tree check: expected %s or %s, have %s in %s, at %s:%d",
- tree_code_name[code1], tree_code_name[code2],
- tree_code_name[TREE_CODE (node)],
- function, trim_filename (file), line);
-}
-
-/* Likewise for three different codes. */
-
-void
-tree_check3_failed (const tree node, enum tree_code code1,
- enum tree_code code2, enum tree_code code3,
- const char *file, int line, const char *function)
-{
- internal_error ("tree check: expected %s, %s or %s; have %s in %s, at %s:%d",
- tree_code_name[code1], tree_code_name[code2],
- tree_code_name[code3], tree_code_name[TREE_CODE (node)],
+tree_not_check_failed (const tree node, const char *file,
+ int line, const char *function, ...)
+{
+ va_list args;
+ char *buffer;
+ unsigned length = 0;
+ int code;
+
+ va_start (args, function);
+ while ((code = va_arg (args, int)))
+ length += 4 + strlen (tree_code_name[code]);
+ va_end (args);
+ va_start (args, function);
+ buffer = alloca (length);
+ length = 0;
+ while ((code = va_arg (args, int)))
+ {
+ if (length)
+ {
+ strcpy (buffer + length, " or ");
+ length += 4;
+ }
+ strcpy (buffer + length, tree_code_name[code]);
+ length += strlen (tree_code_name[code]);
+ }
+ va_end (args);
+
+ internal_error ("tree check: expected none of %s, have %s in %s, at %s:%d",
+ buffer, tree_code_name[TREE_CODE (node)],
function, trim_filename (file), line);
}
-/* ... and for four different codes. */
-
-void
-tree_check4_failed (const tree node, enum tree_code code1,
- enum tree_code code2, enum tree_code code3,
- enum tree_code code4, const char *file, int line,
- const char *function)
-{
- internal_error
- ("tree check: expected %s, %s, %s or %s; have %s in %s, at %s:%d",
- tree_code_name[code1], tree_code_name[code2], tree_code_name[code3],
- tree_code_name[code4], tree_code_name[TREE_CODE (node)], function,
- trim_filename (file), line);
-}
-
-/* ... and for five different codes. */
-
-void
-tree_check5_failed (const tree node, enum tree_code code1,
- enum tree_code code2, enum tree_code code3,
- enum tree_code code4, enum tree_code code5,
- const char *file, int line, const char *function)
-{
- internal_error
- ("tree check: expected %s, %s, %s, %s or %s; have %s in %s, at %s:%d",
- tree_code_name[code1], tree_code_name[code2], tree_code_name[code3],
- tree_code_name[code4], tree_code_name[code5],
- tree_code_name[TREE_CODE (node)], function, trim_filename (file), line);
-}
-
/* Similar to tree_check_failed, except that we check for a class of tree
code, given in CL. */
void
build_common_tree_nodes (int signed_char)
{
+ /* This function is called after command line parsing is complete,
+ but before any DECL nodes should have been created. Therefore,
+ now is the appropriate time to adjust next_decl_uid so that the
+ range 0 .. num_in_fnames-1 is reserved for TRANSLATION_UNIT_DECLs. */
+ if (next_decl_uid)
+ abort ();
+ next_decl_uid = num_in_fnames;
+
error_mark_node = make_node (ERROR_MARK);
TREE_TYPE (error_mark_node) = error_mark_node;
OSDN Git Service
