/* 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, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010,
- 2011 Free Software Foundation, Inc.
+ 2011, 2012 Free Software Foundation, Inc.
This file is part of GCC.
{
case INTEGER_TYPE: case ENUMERAL_TYPE: case BOOLEAN_TYPE:
case POINTER_TYPE: case REFERENCE_TYPE:
- case OFFSET_TYPE:
+ case OFFSET_TYPE: case NULLPTR_TYPE:
return build_int_cst (type, 0);
case REAL_TYPE:
case METHOD_TYPE:
case FUNCTION_TYPE:
case VECTOR_TYPE:
+ case NULLPTR_TYPE:
return false;
case INTEGER_TYPE:
member = TYPE_FIELDS (type);
while (member)
{
- if (TREE_CODE (member) == FIELD_DECL)
+ if (TREE_CODE (member) == FIELD_DECL
+ || TREE_CODE (member) == TYPE_DECL)
{
if (prev)
TREE_CHAIN (prev) = member;
free_lang_data_in_one_sizepos (&TYPE_SIZE (type));
free_lang_data_in_one_sizepos (&TYPE_SIZE_UNIT (type));
- if (debug_info_level < DINFO_LEVEL_TERSE
- || (TYPE_CONTEXT (type)
- && TREE_CODE (TYPE_CONTEXT (type)) != FUNCTION_DECL
- && TREE_CODE (TYPE_CONTEXT (type)) != NAMESPACE_DECL))
- TYPE_CONTEXT (type) = NULL_TREE;
-
- if (debug_info_level < DINFO_LEVEL_TERSE)
- TYPE_STUB_DECL (type) = NULL_TREE;
+ if (TYPE_CONTEXT (type)
+ && TREE_CODE (TYPE_CONTEXT (type)) == BLOCK)
+ {
+ tree ctx = TYPE_CONTEXT (type);
+ do
+ {
+ ctx = BLOCK_SUPERCONTEXT (ctx);
+ }
+ while (ctx && TREE_CODE (ctx) == BLOCK);
+ TYPE_CONTEXT (type) = ctx;
+ }
}
free_lang_data_in_one_sizepos (&DECL_SIZE (decl));
free_lang_data_in_one_sizepos (&DECL_SIZE_UNIT (decl));
if (TREE_CODE (decl) == FIELD_DECL)
- free_lang_data_in_one_sizepos (&DECL_FIELD_OFFSET (decl));
+ {
+ free_lang_data_in_one_sizepos (&DECL_FIELD_OFFSET (decl));
+ if (TREE_CODE (DECL_CONTEXT (decl)) == QUAL_UNION_TYPE)
+ DECL_QUALIFIER (decl) = NULL_TREE;
+ }
if (TREE_CODE (decl) == FUNCTION_DECL)
{
{
fld_worklist_push (DECL_ARGUMENT_FLD (t), fld);
fld_worklist_push (DECL_VINDEX (t), fld);
+ fld_worklist_push (DECL_ORIGINAL_TYPE (t), fld);
}
else if (TREE_CODE (t) == FIELD_DECL)
{
fld_worklist_push (DECL_FIELD_OFFSET (t), fld);
fld_worklist_push (DECL_BIT_FIELD_TYPE (t), fld);
- fld_worklist_push (DECL_QUALIFIER (t), fld);
fld_worklist_push (DECL_FIELD_BIT_OFFSET (t), fld);
fld_worklist_push (DECL_FCONTEXT (t), fld);
}
fld_worklist_push (TYPE_MAIN_VARIANT (t), fld);
/* Do not walk TYPE_NEXT_VARIANT. We do not stream it and thus
do not and want not to reach unused variants this way. */
- fld_worklist_push (TYPE_CONTEXT (t), fld);
+ if (TYPE_CONTEXT (t))
+ {
+ tree ctx = TYPE_CONTEXT (t);
+ /* We adjust BLOCK TYPE_CONTEXTs to the innermost non-BLOCK one.
+ So push that instead. */
+ while (ctx && TREE_CODE (ctx) == BLOCK)
+ ctx = BLOCK_SUPERCONTEXT (ctx);
+ fld_worklist_push (ctx, fld);
+ }
/* Do not walk TYPE_CANONICAL. We do not stream it and thus do not
and want not to reach unused types this way. */
tem = TYPE_FIELDS (t);
while (tem)
{
- if (TREE_CODE (tem) == FIELD_DECL)
+ if (TREE_CODE (tem) == FIELD_DECL
+ || TREE_CODE (tem) == TYPE_DECL)
fld_worklist_push (tem, fld);
tem = TREE_CHAIN (tem);
}
}
- fld_worklist_push (TREE_CHAIN (t), fld);
+ fld_worklist_push (TYPE_STUB_DECL (t), fld);
*ws = 0;
}
else if (TREE_CODE (t) == BLOCK)
{
gimple stmt = gsi_stmt (si);
+ if (is_gimple_call (stmt))
+ find_decls_types (gimple_call_fntype (stmt), fld);
+
for (i = 0; i < gimple_num_ops (stmt); i++)
{
tree arg = gimple_op (stmt, i);
case COMPLEX_TYPE:
case POINTER_TYPE:
case REFERENCE_TYPE:
+ case NULLPTR_TYPE:
return 1;
case VECTOR_TYPE:
return TREE_INT_CST_LOW (t);
}
+/* Return the HOST_WIDE_INT least significant bits of T, a sizetype
+ kind INTEGER_CST. This makes sure to properly sign-extend the
+ constant. */
+
+HOST_WIDE_INT
+size_low_cst (const_tree t)
+{
+ double_int d = tree_to_double_int (t);
+ return double_int_sext (d, TYPE_PRECISION (TREE_TYPE (t))).low;
+}
+
/* Return the most significant (sign) bit of T. */
int
return t;
}
-/* Build variant of function type ORIG_TYPE skipping ARGS_TO_SKIP. */
+/* Build variant of function type ORIG_TYPE skipping ARGS_TO_SKIP and the
+ return value if SKIP_RETURN is true. */
-tree
-build_function_type_skip_args (tree orig_type, bitmap args_to_skip)
+static tree
+build_function_type_skip_args (tree orig_type, bitmap args_to_skip,
+ bool skip_return)
{
tree new_type = NULL;
tree args, new_args = NULL, t;
for (args = TYPE_ARG_TYPES (orig_type); args && args != void_list_node;
args = TREE_CHAIN (args), i++)
- if (!bitmap_bit_p (args_to_skip, i))
+ if (!args_to_skip || !bitmap_bit_p (args_to_skip, i))
new_args = tree_cons (NULL_TREE, TREE_VALUE (args), new_args);
new_reversed = nreverse (new_args);
When we are asked to remove it, we need to build new FUNCTION_TYPE
instead. */
if (TREE_CODE (orig_type) != METHOD_TYPE
+ || !args_to_skip
|| !bitmap_bit_p (args_to_skip, 0))
{
new_type = build_distinct_type_copy (orig_type);
TYPE_CONTEXT (new_type) = TYPE_CONTEXT (orig_type);
}
+ if (skip_return)
+ TREE_TYPE (new_type) = void_type_node;
+
/* This is a new type, not a copy of an old type. Need to reassociate
variants. We can handle everything except the main variant lazily. */
t = TYPE_MAIN_VARIANT (orig_type);
- if (orig_type != t)
+ if (t != orig_type)
{
+ t = build_function_type_skip_args (t, args_to_skip, skip_return);
TYPE_MAIN_VARIANT (new_type) = t;
TYPE_NEXT_VARIANT (new_type) = TYPE_NEXT_VARIANT (t);
TYPE_NEXT_VARIANT (t) = new_type;
TYPE_MAIN_VARIANT (new_type) = new_type;
TYPE_NEXT_VARIANT (new_type) = NULL;
}
+
return new_type;
}
-/* Build variant of function type ORIG_TYPE skipping ARGS_TO_SKIP.
+/* Build variant of function decl ORIG_DECL skipping ARGS_TO_SKIP and the
+ return value if SKIP_RETURN is true.
Arguments from DECL_ARGUMENTS list can't be removed now, since they are
linked by TREE_CHAIN directly. The caller is responsible for eliminating
them when they are being duplicated (i.e. copy_arguments_for_versioning). */
tree
-build_function_decl_skip_args (tree orig_decl, bitmap args_to_skip)
+build_function_decl_skip_args (tree orig_decl, bitmap args_to_skip,
+ bool skip_return)
{
tree new_decl = copy_node (orig_decl);
tree new_type;
new_type = TREE_TYPE (orig_decl);
- if (prototype_p (new_type))
- new_type = build_function_type_skip_args (new_type, args_to_skip);
+ if (prototype_p (new_type)
+ || (skip_return && !VOID_TYPE_P (TREE_TYPE (new_type))))
+ new_type
+ = build_function_type_skip_args (new_type, args_to_skip, skip_return);
TREE_TYPE (new_decl) = new_type;
/* For declarations setting DECL_VINDEX (i.e. methods)
we expect first argument to be THIS pointer. */
- if (bitmap_bit_p (args_to_skip, 0))
+ if (args_to_skip && bitmap_bit_p (args_to_skip, 0))
DECL_VINDEX (new_decl) = NULL_TREE;
/* When signature changes, we need to clear builtin info. */
- if (DECL_BUILT_IN (new_decl) && !bitmap_empty_p (args_to_skip))
+ if (DECL_BUILT_IN (new_decl)
+ && args_to_skip
+ && !bitmap_empty_p (args_to_skip))
{
DECL_BUILT_IN_CLASS (new_decl) = NOT_BUILT_IN;
DECL_FUNCTION_CODE (new_decl) = (enum built_in_function) 0;
tree t;
/* Test if T is either variable (if FN is zero) or an expression containing
- a variable in FN. */
+ a variable in FN. If TYPE isn't gimplified, return true also if
+ gimplify_one_sizepos would gimplify the expression into a local
+ variable. */
#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))) \
+ if (_t != NULL_TREE \
+ && _t != error_mark_node \
+ && TREE_CODE (_t) != INTEGER_CST \
+ && TREE_CODE (_t) != PLACEHOLDER_EXPR \
+ && (!fn \
+ || (!TYPE_SIZES_GIMPLIFIED (type) \
+ && !is_gimple_sizepos (_t)) \
+ || walk_tree (&_t, find_var_from_fn, fn, NULL))) \
return true; } while (0)
if (type == error_mark_node)
build_common_builtin_nodes (void)
{
tree tmp, ftype;
+ int ecf_flags;
if (!builtin_decl_explicit_p (BUILT_IN_MEMCPY)
|| !builtin_decl_explicit_p (BUILT_IN_MEMMOVE))
local_define_builtin ("__builtin_init_trampoline", ftype,
BUILT_IN_INIT_TRAMPOLINE,
"__builtin_init_trampoline", ECF_NOTHROW | ECF_LEAF);
+ local_define_builtin ("__builtin_init_heap_trampoline", ftype,
+ BUILT_IN_INIT_HEAP_TRAMPOLINE,
+ "__builtin_init_heap_trampoline",
+ ECF_NOTHROW | ECF_LEAF);
ftype = build_function_type_list (ptr_type_node, ptr_type_node, NULL_TREE);
local_define_builtin ("__builtin_adjust_trampoline", ftype,
its value in the landing pad. */
ftype = build_function_type_list (ptr_type_node,
integer_type_node, NULL_TREE);
+ ecf_flags = ECF_PURE | ECF_NOTHROW | ECF_LEAF;
+ /* Only use TM_PURE if we we have TM language support. */
+ if (builtin_decl_explicit_p (BUILT_IN_TM_LOAD_1))
+ ecf_flags |= ECF_TM_PURE;
local_define_builtin ("__builtin_eh_pointer", ftype, BUILT_IN_EH_POINTER,
- "__builtin_eh_pointer",
- ECF_PURE | ECF_NOTHROW | ECF_LEAF | ECF_TM_PURE);
+ "__builtin_eh_pointer", ecf_flags);
tmp = lang_hooks.types.type_for_mode (targetm.eh_return_filter_mode (), 0);
ftype = build_function_type_list (tmp, integer_type_node, NULL_TREE);
OSDN Git Service
