/* Functions related to building classes and their related objects.
Copyright (C) 1987, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
- 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008
+ 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009
Free Software Foundation, Inc.
Contributed by Michael Tiemann (tiemann@cygnus.com)
if (!vtbl)
vtbl = build_vfield_ref (instance, basetype);
- assemble_external (vtbl);
aref = build_array_ref (vtbl, idx, input_location);
TREE_CONSTANT (aref) |= TREE_CONSTANT (vtbl) && TREE_CONSTANT (idx);
BINFO_VIRTUALS (type_binfo) = BINFO_VIRTUALS (primary);
}
}
-\f
-/* Set memoizing fields and bits of T (and its variants) for later
- use. */
-static void
-finish_struct_bits (tree t)
+/* Update the variant types of T. */
+
+void
+fixup_type_variants (tree t)
{
tree variants;
- /* Fix up variants (if any). */
+ if (!t)
+ return;
+
for (variants = TYPE_NEXT_VARIANT (t);
variants;
variants = TYPE_NEXT_VARIANT (variants))
/* All variants of a class have the same attributes. */
TYPE_ATTRIBUTES (variants) = TYPE_ATTRIBUTES (t);
}
+}
+
+\f
+/* Set memoizing fields and bits of T (and its variants) for later
+ use. */
+
+static void
+finish_struct_bits (tree t)
+{
+ /* Fix up variants (if any). */
+ fixup_type_variants (t);
if (BINFO_N_BASE_BINFOS (TYPE_BINFO (t)) && TYPE_POLYMORPHIC_P (t))
/* For a class w/o baseclasses, 'finish_struct' has set
x);
cant_pack = 1;
}
- else if (TYPE_ALIGN (TREE_TYPE (x)) > BITS_PER_UNIT)
+ else if (DECL_C_BIT_FIELD (x)
+ || TYPE_ALIGN (TREE_TYPE (x)) > BITS_PER_UNIT)
DECL_PACKED (x) = 1;
}
{
tree fns;
+ if (!CLASS_TYPE_P (t))
+ return false;
+
if (!TYPE_HAS_USER_CONSTRUCTOR (t))
return false;
{
if (DECL_CONSTRUCTOR_P (fn))
{
- if (skip_artificial_parms_for (fn, DECL_ARGUMENTS (fn))
- == NULL_TREE)
+ if (FUNCTION_FIRST_USER_PARMTYPE (fn) == void_list_node)
return true;
- else if (copy_fn_p (fn) > 0)
+ else if (copy_fn_p (fn) > 0
+ && (TREE_CHAIN (FUNCTION_FIRST_USER_PARMTYPE (fn))
+ == void_list_node))
return true;
else
return false;
}
else if (DECL_DESTRUCTOR_P (fn))
return true;
- else if (DECL_ASSIGNMENT_OPERATOR_P (fn))
+ else if (DECL_ASSIGNMENT_OPERATOR_P (fn)
+ && DECL_OVERLOADED_OPERATOR_P (fn) == NOP_EXPR)
return copy_fn_p (fn);
else
return false;
{
int i;
+ if (!CLASS_TYPE_P (t))
+ return false;
+
/* We start looking from 1 because entry 0 is from global scope,
and has no type. */
for (i = current_class_depth; i > 0; --i)
}
else if (TREE_CHAIN (matches))
{
- /* There were too many matches. */
+ /* There were too many matches. First check if they're all
+ the same function. */
+ tree match;
- if (flags & tf_error)
+ fn = TREE_PURPOSE (matches);
+ for (match = TREE_CHAIN (matches); match; match = TREE_CHAIN (match))
+ if (!decls_match (fn, TREE_PURPOSE (matches)))
+ break;
+
+ if (match)
{
- tree match;
+ if (flags & tf_error)
+ {
+ error ("converting overloaded function %qD to type %q#T is ambiguous",
+ DECL_NAME (OVL_FUNCTION (overload)),
+ target_type);
- error ("converting overloaded function %qD to type %q#T is ambiguous",
- DECL_NAME (OVL_FUNCTION (overload)),
- target_type);
+ /* Since print_candidates expects the functions in the
+ TREE_VALUE slot, we flip them here. */
+ for (match = matches; match; match = TREE_CHAIN (match))
+ TREE_VALUE (match) = TREE_PURPOSE (match);
- /* Since print_candidates expects the functions in the
- TREE_VALUE slot, we flip them here. */
- for (match = matches; match; match = TREE_CHAIN (match))
- TREE_VALUE (match) = TREE_PURPOSE (match);
+ print_candidates (matches);
+ }
- print_candidates (matches);
+ return error_mark_node;
}
-
- return error_mark_node;
}
/* Good, exactly one match. Now, convert it to the correct type. */
if (type == error_mark_node)
return 0;
- if (! MAYBE_CLASS_TYPE_P (type))
+ if (! CLASS_TYPE_P (type))
return 0;
/* In G++ 3.2, whether or not a class was empty was determined by
return false;
}
+/* Returns true if TYPE contains no actual data, just various
+ possible combinations of empty classes. */
+
+bool
+is_really_empty_class (tree type)
+{
+ if (is_empty_class (type))
+ return true;
+ if (CLASS_TYPE_P (type))
+ {
+ tree field;
+ tree binfo;
+ tree base_binfo;
+ int i;
+
+ for (binfo = TYPE_BINFO (type), i = 0;
+ BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i)
+ if (!is_really_empty_class (BINFO_TYPE (base_binfo)))
+ return false;
+ for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
+ if (TREE_CODE (field) == FIELD_DECL
+ && !DECL_ARTIFICIAL (field)
+ && !is_really_empty_class (TREE_TYPE (field)))
+ return false;
+ return true;
+ }
+ else if (TREE_CODE (type) == ARRAY_TYPE)
+ return is_really_empty_class (TREE_TYPE (type));
+ return false;
+}
+
/* Note that NAME was looked up while the current class was being
defined and that the result of that lookup was DECL. */