* tree.h (COMPLETE_TYPE_P): New macro.
(COMPLETE_OR_VOID_TYPE_P): New macro.
(COMPLETE_OR_UNBOUND_ARRAY_TYPE_P): New macro.
* stor-layout.c (layout_type, case VOID_TYPE): Don't set TYPE_SIZE.
* c-aux-info.c (gen_type): Use them.
* c-common.c (c_expand_expr_stmt): Likewise.
* c-decl.c (poplevel, pushdecl, start_decl, finish_decl,
grokdeclarator, grokparms, finish_struct, start_function,
store_parm_decls, combine_parm_decls): Likewise.
* c-parse.y (cast_expr): Likewise.
* c-typeck.c (require_complete_type, c_sizeof, c_sizeof_nowarn,
c_size_in_bytes, c_alignof, build_component_ref,
build_indirect_ref, build_array_ref, convert_arguments,
build_binary_op, pointer_diff, build_unary_op, digest_init: Likewise.
* calls.c (initialize_argument_information): Likewise.
* convert.c (convert_to_integer): Likewise.
* dbxout.c (dbxout_typedefs, dbxout_type, dbxout_symbol): Likewise.
* dwarfout.c (location_or_const_value_attribute,
output_enumeration_type_die, output_structure_type_die,
output_union_type_die, output_type): Likewise.
* expr.c (safe_from_p, expand_expr): Likewise.
* function.c (assign_parms): Likewise.
* sdbout.c (sdbout_symbol, sdbout_one_type): Likewise.
* tree.c (build_array_type, build_function_type,
build_method_type, build_offset_type, build_complex_type): Likewise.
* c-parse.c, c-parse.h: Regenerated.
gcc/cp
* typeck.c (require_complete_type, complete_type,
complete_type_or_else, c_sizeof, c_sizeof_nowarn,
build_array_ref, convert_arguments, pointer_diff,
build_x_unary_op, build_unary_op, build_c_cast,
build_modify_expr): Use COMPLETE_TYPE_P etc.
* call.c (is_complete, convert_like_real,
build_new_method_call): Likewise.
* class.c (build_vbase_pointer_fields, check_bases,
build_base_field, finish_struct_1, pushclass): Likewise.
* cvt.c (cp_convert_to_pointer, convert_to_void): Likewise.
* decl.c (maybe_process_template_type_declaration, pushtag,
pushdecl, redeclaration_error_message, start_decl, start_decl_1,
layout_var_decl, check_initializer, cp_finish_decl,
grokdeclarator, require_complete_types_for_parms,
grok_op_properties, xref_tag, xref_basetypes,
check_function_type): Likewise.
* decl2.c (check_classfn, reparse_absdcl_as_casts): Likewise.
* friend.c (do_friend): Likewise.
* init.c (build_offset_ref): Likewise.
* parse.y (structsp): Likewise.
* pt.c (maybe_process_partial_specialization,
tsubst_friend_function, instantiate_class_template, tsubst,
do_type_instantiation, instantiate_pending_templates): Likewise.
* repo.c (repo_get_id): Likewise.
* rtti.c (build_typeid, get_typeid, build_dynamic_cast_1,
synthesize_tinfo_var, emit_support_tinfos): Likewise.
* search.c (lookup_fnfields_1, lookup_conversions): Likewise.
* semantics.c (begin_class_definition): Likewise.
* tree.c (build_cplus_method_type): Likewise.
* typeck2.c (digest_init, build_functional_cast,
add_exception_specifier): Likewise.
* parse.h, parse.c: Regenerated.
git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@32671
138bc75d-0d04-0410-961f-
82ee72b054a4
+2000-03-21 Nathan Sidwell <nathan@codesourcery.com>
+
+ * tree.h (COMPLETE_TYPE_P): New macro.
+ (COMPLETE_OR_VOID_TYPE_P): New macro.
+ (COMPLETE_OR_UNBOUND_ARRAY_TYPE_P): New macro.
+ * stor-layout.c (layout_type, case VOID_TYPE): Don't set TYPE_SIZE.
+ * c-aux-info.c (gen_type): Use them.
+ * c-common.c (c_expand_expr_stmt): Likewise.
+ * c-decl.c (poplevel, pushdecl, start_decl, finish_decl,
+ grokdeclarator, grokparms, finish_struct, start_function,
+ store_parm_decls, combine_parm_decls): Likewise.
+ * c-parse.y (cast_expr): Likewise.
+ * c-typeck.c (require_complete_type, c_sizeof, c_sizeof_nowarn,
+ c_size_in_bytes, c_alignof, build_component_ref,
+ build_indirect_ref, build_array_ref, convert_arguments,
+ build_binary_op, pointer_diff, build_unary_op, digest_init: Likewise.
+ * calls.c (initialize_argument_information): Likewise.
+ * convert.c (convert_to_integer): Likewise.
+ * dbxout.c (dbxout_typedefs, dbxout_type, dbxout_symbol): Likewise.
+ * dwarfout.c (location_or_const_value_attribute,
+ output_enumeration_type_die, output_structure_type_die,
+ output_union_type_die, output_type): Likewise.
+ * expr.c (safe_from_p, expand_expr): Likewise.
+ * function.c (assign_parms): Likewise.
+ * sdbout.c (sdbout_symbol, sdbout_one_type): Likewise.
+ * tree.c (build_array_type, build_function_type,
+ build_method_type, build_offset_type, build_complex_type): Likewise.
+ * c-parse.c, c-parse.h: Regenerated.
+
2000-03-21 Michael Hayes <m.hayes@elec.canterbury.ac.nz>
* config/c4x/rtems.h: Include config/rtems.h.
copy_rtx_and_substitute, subst_constants, restore_constants):
Likewise.
- * jump.c (mark_jump_label, invert_exp, redirect_e\0\0\0xp,
+ * jump.c (mark_jump_label, invert_exp, redirect_exp,
rtx_renumbered_equal_p, rtx_equal_for_thread_p): Likewise.
* local-alloc.c (contains_replace_regs, memref_referenced_p):
(unroll_loop): Access regno_pointer_* variables through
current_function.
- * tree.h (struct tree_decl): Add elt f to saved_ins\0\0\0ns member.
+ * tree.h (struct tree_decl): Add elt f to saved_insns member.
(DECL_SAVED_INSNS): use it.
(expand_dummy_function_end): Declare.
(init_function_for_compilation): Declare.
Wed Jul 28 11:20:19 1999 Richard Henderson <rth@cygnus.com>
- * mn102\0\0\000.c (mn10200_va_arg): New.
+ * mn10200.c (mn10200_va_arg): New.
* mn10200.h (EXPAND_BUILTIN_VA_ARG): New.
Wed Jul 28 11:19:06 1999 Richard Henderson <rth@cygnus.com>
return ret_val;
case ARRAY_TYPE:
- if (TYPE_SIZE (t) == 0 || TREE_CODE (TYPE_SIZE (t)) != INTEGER_CST)
+ if (!COMPLETE_TYPE_P (t) || TREE_CODE (TYPE_SIZE (t)) != INTEGER_CST)
ret_val = gen_type (concat (ret_val, "[]", NULL_PTR),
TREE_TYPE (t), style);
else if (int_size_in_bytes (t) == 0)
expr = default_conversion (expr);
if (TREE_TYPE (expr) != error_mark_node
- && TYPE_SIZE (TREE_TYPE (expr)) == 0
+ && !COMPLETE_TYPE_P (TREE_TYPE (expr))
&& TREE_CODE (TREE_TYPE (expr)) != ARRAY_TYPE)
error ("expression statement has incomplete type");
#if 0
/* Warn about incomplete structure types in this level. */
for (link = tags; link; link = TREE_CHAIN (link))
- if (TYPE_SIZE (TREE_VALUE (link)) == 0)
+ if (!COMPLETE_TYPE_P (TREE_VALUE (link)))
{
tree type = TREE_VALUE (link);
tree type_name = TYPE_NAME (type);
}
/* Keep count of variables in this level with incomplete type. */
- if (TYPE_SIZE (TREE_TYPE (x)) == 0)
+ if (!COMPLETE_TYPE_P (TREE_TYPE (x)))
++b->n_incomplete;
}
default:
/* Don't allow initializations for incomplete types
except for arrays which might be completed by the initialization. */
- if (TYPE_SIZE (TREE_TYPE (decl)) != 0)
+ if (COMPLETE_TYPE_P (TREE_TYPE (decl)))
{
/* A complete type is ok if size is fixed. */
IDENTIFIER_POINTER (DECL_NAME (decl)));
initialized = 0;
}
- else if (TYPE_SIZE (TREE_TYPE (TREE_TYPE (decl))) == 0)
+ else if (!COMPLETE_TYPE_P (TREE_TYPE (TREE_TYPE (decl))))
{
error ("elements of array `%s' have incomplete type",
IDENTIFIER_POINTER (DECL_NAME (decl)));
(which may or may not happen). */
&& DECL_RTL (tem) == 0)
{
- if (TYPE_SIZE (TREE_TYPE (tem)) != 0)
+ if (COMPLETE_TYPE_P (TREE_TYPE (tem)))
expand_decl (tem);
else if (TREE_CODE (TREE_TYPE (tem)) == ARRAY_TYPE
&& DECL_INITIAL (tem) != 0)
if (TREE_CODE (decl) == VAR_DECL)
{
- if (DECL_SIZE (decl) == 0 && TYPE_SIZE (TREE_TYPE (decl)) != 0)
+ if (DECL_SIZE (decl) == 0 && COMPLETE_TYPE_P (TREE_TYPE (decl)))
layout_decl (decl, 0);
if (DECL_SIZE (decl) == 0
union incomplete (*foo)[4]; */
/* Complain about arrays of incomplete types, except in typedefs. */
- if (TYPE_SIZE (type) == 0
+ if (!COMPLETE_TYPE_P (type)
/* Avoid multiple warnings for nested array types. */
&& TREE_CODE (type) != ARRAY_TYPE
&& !(specbits & (1 << (int) RID_TYPEDEF))
/* Did array size calculations overflow? */
if (TREE_CODE (type) == ARRAY_TYPE
- && TYPE_SIZE (type)
+ && COMPLETE_TYPE_P (type)
&& TREE_OVERFLOW (TYPE_SIZE (type)))
error ("size of array `%s' is too large", name);
error ("field `%s' declared as a function", name);
type = build_pointer_type (type);
}
- else if (TREE_CODE (type) != ERROR_MARK && TYPE_SIZE (type) == 0)
+ else if (TREE_CODE (type) != ERROR_MARK
+ && !COMPLETE_OR_UNBOUND_ARRAY_TYPE_P (type))
{
error ("field `%s' has incomplete type", name);
type = error_mark_node;
{
/* Barf if the parameter itself has an incomplete type. */
tree type = TREE_VALUE (typelt);
- if (TYPE_SIZE (type) == 0)
+ if (!COMPLETE_TYPE_P (type))
{
if (funcdef_flag && DECL_NAME (parm) != 0)
error ("parameter `%s' has incomplete type",
|| TREE_CODE (type) == REFERENCE_TYPE)
type = TREE_TYPE (type);
type = TYPE_MAIN_VARIANT (type);
- if (TYPE_SIZE (type) == 0)
+ if (!COMPLETE_TYPE_P (type))
{
if (DECL_NAME (parm) != 0)
warning ("parameter `%s' points to incomplete type",
expand_decl (decl);
--current_binding_level->n_incomplete;
}
- else if (TYPE_SIZE (TREE_TYPE (decl)) == 0
+ else if (!COMPLETE_TYPE_P (TREE_TYPE (decl))
&& TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE)
{
tree element = TREE_TYPE (decl);
announce_function (decl1);
- if (TYPE_SIZE (TREE_TYPE (TREE_TYPE (decl1))) == 0)
+ if (!COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (TREE_TYPE (decl1))))
{
error ("return-type is an incomplete type");
/* Make it return void instead. */
else
{
/* Complain about args with incomplete types. */
- if (TYPE_SIZE (TREE_TYPE (parm)) == 0)
+ if (!COMPLETE_TYPE_P (TREE_TYPE (parm)))
{
error_with_decl (parm, "parameter `%s' has incomplete type");
TREE_TYPE (parm) = error_mark_node;
TREE_CHAIN (parm) = 0;
/* Complain about args with incomplete types. */
- if (TYPE_SIZE (TREE_TYPE (parm)) == 0)
+ if (!COMPLETE_TYPE_P (TREE_TYPE (parm)))
{
error_with_decl (parm, "parameter `%s' has incomplete type");
TREE_TYPE (parm) = error_mark_node;
/* A Bison parser, made from c-parse.y
- by GNU Bison version 1.27
- */
+ by GNU Bison version 1.28 */
#define YYBISON 1 /* Identify Bison output. */
48, 49, 50, 51, 52, 53, 54, 55, 56, 57
};
/* -*-C-*- Note some compilers choke on comments on `#line' lines. */
-#line 3 "/usr/share/bison.simple"
-/* This file comes from bison-1.27. */
+#line 3 "/usr/lib/bison.simple"
+/* This file comes from bison-1.28. */
/* Skeleton output parser for bison,
Copyright (C) 1984, 1989, 1990 Free Software Foundation, Inc.
#endif
#endif
\f
-#line 216 "/usr/share/bison.simple"
+#line 217 "/usr/lib/bison.simple"
/* The user can define YYPARSE_PARAM as the name of an argument to be passed
into yyparse. The argument should have type void *.
else
name = "";
yyval.ttype = result;
- if (TREE_CODE (type) == ARRAY_TYPE && TYPE_SIZE (type) == 0)
+ if (TREE_CODE (type) == ARRAY_TYPE && !COMPLETE_TYPE_P (type))
{
int failure = complete_array_type (type, yyval.ttype, 1);
if (failure)
break;}
}
/* the action file gets copied in in place of this dollarsign */
-#line 542 "/usr/share/bison.simple"
+#line 543 "/usr/lib/bison.simple"
\f
yyvsp -= yylen;
yyssp -= yylen;
else
name = "";
$$ = result;
- if (TREE_CODE (type) == ARRAY_TYPE && TYPE_SIZE (type) == 0)
+ if (TREE_CODE (type) == ARRAY_TYPE && !COMPLETE_TYPE_P (type))
{
int failure = complete_array_type (type, $$, 1);
if (failure)
return error_mark_node;
/* First, detect a valid value with a complete type. */
- if (TYPE_SIZE (type) != 0
- && type != void_type_node)
+ if (COMPLETE_TYPE_P (type))
return value;
incomplete_type_error (value, type);
if (code == ERROR_MARK)
return size_one_node;
- if (TYPE_SIZE (type) == 0)
+ if (!COMPLETE_TYPE_P (type))
{
error ("sizeof applied to an incomplete type");
return size_zero_node;
if (code == FUNCTION_TYPE || code == VOID_TYPE || code == ERROR_MARK)
return size_one_node;
- if (TYPE_SIZE (type) == 0)
+ if (!COMPLETE_TYPE_P (type))
return size_zero_node;
/* Convert in case a char is more than one unit. */
if (code == FUNCTION_TYPE || code == VOID_TYPE || code == ERROR_MARK)
return size_one_node;
- if (TYPE_SIZE (type) == 0)
+ if (!COMPLETE_OR_VOID_TYPE_P (type))
{
error ("arithmetic on pointer to an incomplete type");
return size_one_node;
if (code == VOID_TYPE || code == ERROR_MARK)
return size_one_node;
- if (TYPE_SIZE (type) == 0)
+ if (!COMPLETE_TYPE_P (type))
{
error ("__alignof__ applied to an incomplete type");
return size_zero_node;
{
tree indirect = 0;
- if (TYPE_SIZE (type) == 0)
+ if (!COMPLETE_TYPE_P (type))
{
incomplete_type_error (NULL_TREE, type);
return error_mark_node;
register tree ref = build1 (INDIRECT_REF,
TYPE_MAIN_VARIANT (t), pointer);
- if (TYPE_SIZE (t) == 0 && TREE_CODE (t) != ARRAY_TYPE)
+ if (!COMPLETE_TYPE_P (t) && TREE_CODE (t) != ARRAY_TYPE)
{
error ("dereferencing pointer to incomplete type");
return error_mark_node;
address arithmetic on its address.
Likewise an array of elements of variable size. */
if (TREE_CODE (index) != INTEGER_CST
- || (TYPE_SIZE (TREE_TYPE (TREE_TYPE (array))) != 0
+ || (COMPLETE_TYPE_P (TREE_TYPE (TREE_TYPE (array)))
&& TREE_CODE (TYPE_SIZE (TREE_TYPE (TREE_TYPE (array)))) != INTEGER_CST))
{
if (mark_addressable (array) == 0)
/* Formal parm type is specified by a function prototype. */
tree parmval;
- if (TYPE_SIZE (type) == 0)
+ if (!COMPLETE_TYPE_P (type))
{
error ("type of formal parameter %d is incomplete", parmnum + 1);
parmval = val;
if (comp_target_types (type0, type1))
{
result_type = common_type (type0, type1);
- if ((TYPE_SIZE (TREE_TYPE (type0)) != 0)
- != (TYPE_SIZE (TREE_TYPE (type1)) != 0))
+ if (!COMPLETE_TYPE_P (TREE_TYPE (type0))
+ != !COMPLETE_TYPE_P (TREE_TYPE (type1)))
pedwarn ("comparison of complete and incomplete pointers");
else if (pedantic
&& TREE_CODE (TREE_TYPE (type0)) == FUNCTION_TYPE)
op0 = build_binary_op (MINUS_EXPR, convert (restype, op0),
convert (restype, op1), 0);
/* This generates an error if op1 is pointer to incomplete type. */
- if (TYPE_SIZE (TREE_TYPE (TREE_TYPE (op1))) == 0)
+ if (!COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (TREE_TYPE (op1))))
error ("arithmetic on pointer to an incomplete type");
/* This generates an error if op0 is pointer to incomplete type. */
{
/* If pointer target is an undefined struct,
we just cannot know how to do the arithmetic. */
- if (TYPE_SIZE (TREE_TYPE (result_type)) == 0)
+ if (!COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (result_type)))
error ("%s of pointer to unknown structure",
code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR
? "increment" : "decrement");
/* Come here only for records and arrays. */
- if (TYPE_SIZE (type) && TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
+ if (COMPLETE_TYPE_P (type) && TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
{
error_init ("variable-sized object may not be initialized");
return error_mark_node;
args[i].tree_value = TREE_VALUE (p);
/* Replace erroneous argument with constant zero. */
- if (type == error_mark_node || TYPE_SIZE (type) == 0)
+ if (type == error_mark_node || !COMPLETE_TYPE_P (type))
args[i].tree_value = integer_zero_node, type = integer_type_node;
/* If TYPE is a transparent union, pass things the way we would
function being called. */
rtx copy;
- if (TYPE_SIZE (type) == 0
+ if (!COMPLETE_TYPE_P (type)
|| TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST
|| (flag_stack_check && ! STACK_CHECK_BUILTIN
&& (0 < compare_tree_int (TYPE_SIZE_UNIT (type),
/* An INTEGER_TYPE cannot be incomplete, but an ENUMERAL_TYPE can
be. Consider `enum E = { a, b = (enum E) 3 };'. */
- if (!TYPE_SIZE (type))
+ if (!COMPLETE_TYPE_P (type))
{
error ("conversion to incomplete type");
return error_mark_node;
2000-03-21 Nathan Sidwell <nathan@codesourcery.com>
+ * typeck.c (require_complete_type, complete_type,
+ complete_type_or_else, c_sizeof, c_sizeof_nowarn,
+ build_array_ref, convert_arguments, pointer_diff,
+ build_x_unary_op, build_unary_op, build_c_cast,
+ build_modify_expr): Use COMPLETE_TYPE_P etc.
+ * call.c (is_complete, convert_like_real,
+ build_new_method_call): Likewise.
+ * class.c (build_vbase_pointer_fields, check_bases,
+ build_base_field, finish_struct_1, pushclass): Likewise.
+ * cvt.c (cp_convert_to_pointer, convert_to_void): Likewise.
+ * decl.c (maybe_process_template_type_declaration, pushtag,
+ pushdecl, redeclaration_error_message, start_decl, start_decl_1,
+ layout_var_decl, check_initializer, cp_finish_decl,
+ grokdeclarator, require_complete_types_for_parms,
+ grok_op_properties, xref_tag, xref_basetypes,
+ check_function_type): Likewise.
+ * decl2.c (check_classfn, reparse_absdcl_as_casts): Likewise.
+ * friend.c (do_friend): Likewise.
+ * init.c (build_offset_ref): Likewise.
+ * parse.y (structsp): Likewise.
+ * pt.c (maybe_process_partial_specialization,
+ tsubst_friend_function, instantiate_class_template, tsubst,
+ do_type_instantiation, instantiate_pending_templates): Likewise.
+ * repo.c (repo_get_id): Likewise.
+ * rtti.c (build_typeid, get_typeid, build_dynamic_cast_1,
+ synthesize_tinfo_var, emit_support_tinfos): Likewise.
+ * search.c (lookup_fnfields_1, lookup_conversions): Likewise.
+ * semantics.c (begin_class_definition): Likewise.
+ * tree.c (build_cplus_method_type): Likewise.
+ * typeck2.c (digest_init, build_functional_cast,
+ add_exception_specifier): Likewise.
+ * parse.h, parse.c: Regenerated.
+
+2000-03-21 Nathan Sidwell <nathan@codesourcery.com>
+
* inc/cxxabi.h: New header file. Define new-abi entry points.
(__pointer_type_info::target): Rename member to ...
(__pointer_type_info::type): ... here.
is_complete (t)
tree t;
{
- return TYPE_SIZE (complete_type (t)) != NULL_TREE;
+ return COMPLETE_TYPE_P (complete_type (t));
}
/* Returns non-zero if TYPE is a promoted arithmetic type. */
conversion because the type might be an incomplete
array type, which is OK if some constructor for the
destination type takes a pointer argument. */
- if (TYPE_SIZE (TREE_TYPE (expr)) == 0)
+ if (!COMPLETE_TYPE_P (TREE_TYPE (expr)))
{
if (same_type_p (TREE_TYPE (expr), TREE_TYPE (convs)))
incomplete_type_error (expr, TREE_TYPE (expr));
/* XXX will LOOKUP_SPECULATIVELY be needed when this is done? */
if (flags & LOOKUP_SPECULATIVELY)
return NULL_TREE;
- if (TYPE_SIZE (basetype) == 0)
+ if (!COMPLETE_TYPE_P (basetype))
incomplete_type_error (instance_ptr, basetype);
else
cp_error ("no matching function for call to `%T::%D (%A)%V'",
register tree base_binfo = TREE_VEC_ELT (binfos, i);
register tree basetype = BINFO_TYPE (base_binfo);
- if (TYPE_SIZE (basetype) == 0)
+ if (!COMPLETE_TYPE_P (basetype))
/* This error is now reported in xref_tag, thus giving better
location information. */
continue;
/* If the type of basetype is incomplete, then we already
complained about that fact (and we should have fixed it up as
well). */
- if (TYPE_SIZE (basetype) == 0)
+ if (!COMPLETE_TYPE_P (basetype))
{
int j;
/* The base type is of incomplete type. It is
tree basetype = BINFO_TYPE (binfo);
tree decl;
- if (TYPE_SIZE (basetype) == 0)
+ if (!COMPLETE_TYPE_P (basetype))
/* This error is now reported in xref_tag, thus giving better
location information. */
return;
tree vfield;
int empty = 1;
- if (TYPE_SIZE (t))
+ if (COMPLETE_TYPE_P (t))
{
if (IS_AGGR_TYPE (t))
cp_error ("redefinition of `%#T'", t);
if (previous_class_type != NULL_TREE
&& (type != previous_class_type
- || TYPE_SIZE (previous_class_type) == NULL_TREE)
+ || !COMPLETE_TYPE_P (previous_class_type))
&& current_class_depth == 1)
{
/* Forcibly remove any old class remnants. */
if (IS_AGGR_TYPE (intype))
{
intype = complete_type (intype);
- if (TYPE_SIZE (intype) == NULL_TREE)
+ if (!COMPLETE_TYPE_P (intype))
{
cp_error ("can't convert from incomplete type `%T' to `%T'",
intype, type);
int is_reference = TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0)))
== REFERENCE_TYPE;
int is_volatile = TYPE_VOLATILE (type);
- int is_complete = TYPE_SIZE (complete_type (type)) != NULL_TREE;
+ int is_complete = COMPLETE_TYPE_P (complete_type (type));
if (is_volatile && !is_complete)
cp_warning ("object of incomplete type `%T' will not be accessed in %s",
{
/* External variables might be incomplete. */
tree type = TREE_TYPE (expr);
- int is_complete = TYPE_SIZE (complete_type (type)) != NULL_TREE;
+ int is_complete = COMPLETE_TYPE_P (complete_type (type));
if (TYPE_VOLATILE (type) && !is_complete)
cp_warning ("object `%E' of incomplete type `%T' will not be accessed in %s",
binding level, but is instead the pseudo-global level. */
b->level_chain->tags =
tree_cons (name, type, b->level_chain->tags);
- if (TYPE_SIZE (current_class_type) == NULL_TREE)
+ if (!COMPLETE_TYPE_P (current_class_type))
CLASSTYPE_TAGS (current_class_type) = b->level_chain->tags;
}
}
}
if (b->parm_flag == 2)
{
- if (TYPE_SIZE (current_class_type) == NULL_TREE)
+ if (!COMPLETE_TYPE_P (current_class_type))
CLASSTYPE_TAGS (current_class_type) = b->tags;
}
}
/* Keep count of variables in this level with incomplete type. */
if (TREE_CODE (x) == VAR_DECL
&& TREE_TYPE (x) != error_mark_node
- && ((TYPE_SIZE (TREE_TYPE (x)) == NULL_TREE
+ && ((!COMPLETE_TYPE_P (TREE_TYPE (x))
&& PROMOTES_TO_AGGR_TYPE (TREE_TYPE (x), ARRAY_TYPE))
/* RTTI TD entries are created while defining the type_info. */
|| (TYPE_LANG_SPECIFIC (TREE_TYPE (x))
&& DECL_INITIAL (DECL_TEMPLATE_RESULT (newdecl))
&& DECL_INITIAL (DECL_TEMPLATE_RESULT (olddecl)))
|| (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL
- && TYPE_SIZE (TREE_TYPE (newdecl))
- && TYPE_SIZE (TREE_TYPE (olddecl))))
+ && COMPLETE_TYPE_P (TREE_TYPE (newdecl))
+ && COMPLETE_TYPE_P (TREE_TYPE (olddecl))))
return "redefinition of `%#D'";
return 0;
}
/* Set attributes here so if duplicate decl, will have proper attributes. */
cplus_decl_attributes (decl, attributes, prefix_attributes);
- if (context && TYPE_SIZE (complete_type (context)) != NULL_TREE)
+ if (context && COMPLETE_TYPE_P (complete_type (context)))
{
push_nested_class (context, 2);
{
/* Don't allow initializations for incomplete types except for
arrays which might be completed by the initialization. */
- if (TYPE_SIZE (complete_type (type)) != NULL_TREE)
+ if (COMPLETE_TYPE_P (complete_type (type)))
; /* A complete type is ok. */
else if (TREE_CODE (type) != ARRAY_TYPE)
{
initialized = 0;
type = TREE_TYPE (decl) = error_mark_node;
}
- else if (TYPE_SIZE (complete_type (TREE_TYPE (type))) == NULL_TREE)
+ else if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (type))))
{
if (DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl))
cp_error ("elements of array `%#D' have incomplete type", decl);
&& ! DECL_EXTERNAL (decl))
{
if ((! processing_template_decl || ! uses_template_parms (type))
- && TYPE_SIZE (complete_type (type)) == NULL_TREE)
+ && !COMPLETE_TYPE_P (complete_type (type)))
{
cp_error ("aggregate `%#D' has incomplete type and cannot be initialized",
decl);
`extern X x' for some incomplete type `X'.) */
if (!DECL_EXTERNAL (decl))
complete_type (type);
- if (!DECL_SIZE (decl) && TYPE_SIZE (type))
+ if (!DECL_SIZE (decl) && COMPLETE_TYPE_P (type))
layout_decl (decl, 0);
if (!DECL_EXTERNAL (decl) && DECL_SIZE (decl) == NULL_TREE)
if (type == error_mark_node)
/* We will have already complained. */
init = NULL_TREE;
- else if (TYPE_SIZE (type) && !TREE_CONSTANT (TYPE_SIZE (type)))
+ else if (COMPLETE_TYPE_P (type) && !TREE_CONSTANT (TYPE_SIZE (type)))
{
cp_error ("variable-sized object `%D' may not be initialized", decl);
init = NULL_TREE;
}
else if (TREE_CODE (type) == ARRAY_TYPE
- && !TYPE_SIZE (TREE_TYPE (type)))
+ && !COMPLETE_TYPE_P (TREE_TYPE (type)))
{
cp_error ("elements of array `%#D' have incomplete type", decl);
init = NULL_TREE;
}
- else if (!TYPE_SIZE (type))
+ else if (!COMPLETE_TYPE_P (type))
{
cp_error ("`%D' has incomplete type", decl);
TREE_TYPE (decl) = error_mark_node;
check_for_uninitialized_const_var (decl);
- if (TYPE_SIZE (type) != NULL_TREE
- && TYPE_NEEDS_CONSTRUCTING (type))
+ if (COMPLETE_TYPE_P (type) && TYPE_NEEDS_CONSTRUCTING (type))
init = obscure_complex_init (decl, NULL_TREE);
}
type, and that type has not been defined yet, delay emitting
the debug information for it, as we will emit it later. */
if (TYPE_MAIN_DECL (TREE_TYPE (decl)) == decl
- && TYPE_SIZE (TREE_TYPE (decl)) == NULL_TREE)
+ && !COMPLETE_TYPE_P (TREE_TYPE (decl)))
TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
rest_of_decl_compilation (decl, NULL_PTR,
/* If size hasn't been set, we're still defining it,
and therefore inside the class body; don't pop
the binding level.. */
- && TYPE_SIZE (context) != NULL_TREE
+ && COMPLETE_TYPE_P (context)
&& context == current_class_type)
pop_nested_class ();
}
}
}
else if (RIDBIT_SETP (RID_TYPEDEF, specbits)
- || TYPE_SIZE (complete_type (ctype)) != NULL_TREE)
+ || COMPLETE_TYPE_P (complete_type (ctype)))
{
/* Have to move this code elsewhere in this function.
this code is used for i.e., typedef int A::M; M *pm;
return NULL_TREE;
}
else if (!staticp && ! processing_template_decl
- && TYPE_SIZE (complete_type (type)) == NULL_TREE
+ && !COMPLETE_TYPE_P (complete_type (type))
&& (TREE_CODE (type) != ARRAY_TYPE || initialized == 0))
{
if (declarator)
if (type == error_mark_node)
continue;
- if (TYPE_SIZE (type) == NULL_TREE)
+ if (!COMPLETE_TYPE_P (type))
{
if (DECL_NAME (parms))
error ("parameter `%s' has incomplete type",
what = "the same type";
/* Don't force t to be complete here. */
else if (IS_AGGR_TYPE (t)
- && TYPE_SIZE (t)
+ && COMPLETE_TYPE_P (t)
&& DERIVED_FROM_P (t, current_class_type))
what = "a base class";
/* Until the type is defined, tentatively accept whatever
structure tag the user hands us. */
- if (TYPE_SIZE (ref) == NULL_TREE
+ if (!COMPLETE_TYPE_P (ref)
&& ref != current_class_type
/* Have to check this, in case we have contradictory tag info. */
&& IS_AGGR_TYPE_CODE (TREE_CODE (ref)))
/* This code replaces similar code in layout_basetypes.
We put the complete_type first for implicit `typename'. */
- if (TYPE_SIZE (basetype) == NULL_TREE
+ if (!COMPLETE_TYPE_P (basetype)
&& ! (current_template_parms && uses_template_parms (basetype)))
{
cp_error ("base class `%T' has incomplete type", basetype);
tree decl;
{
tree fntype = TREE_TYPE (decl);
+ tree return_type = complete_type (TREE_TYPE (fntype));
/* In a function definition, arg types must be complete. */
require_complete_types_for_parms (current_function_parms);
- if (TYPE_SIZE (complete_type (TREE_TYPE (fntype))) == NULL_TREE)
+ if (!COMPLETE_OR_VOID_TYPE_P (return_type))
{
cp_error ("return type `%#T' is incomplete", TREE_TYPE (fntype));
else
{
methods = 0;
- if (TYPE_SIZE (ctype) == 0)
+ if (!COMPLETE_TYPE_P (ctype))
incomplete_type_error (function, ctype);
else
cp_error ("no `%#D' member function declared in class `%T'",
spurious errors (unless the CTYPE is not yet defined, in which
case we'll only confuse ourselves when the function is declared
properly within the class. */
- if (TYPE_SIZE (ctype))
+ if (COMPLETE_TYPE_P (ctype))
add_method (ctype, methods, function);
return NULL_TREE;
}
decl = TREE_OPERAND (decl, 0);
expr = digest_init (type, expr, (tree *) 0);
- if (TREE_CODE (type) == ARRAY_TYPE && TYPE_SIZE (type) == 0)
+ if (TREE_CODE (type) == ARRAY_TYPE && !COMPLETE_TYPE_P (type))
{
int failure = complete_array_type (type, expr, 1);
if (failure)
/* A nested class may declare a member of an enclosing class
to be a friend, so we do lookup here even if CTYPE is in
the process of being defined. */
- else if (TYPE_SIZE (ctype) != 0 || TYPE_BEING_DEFINED (ctype))
+ else if (COMPLETE_TYPE_P (ctype) || TYPE_BEING_DEFINED (ctype))
{
decl = check_classfn (ctype, decl);
name = ctor_identifier;
#endif
- if (TYPE_SIZE (complete_type (type)) == 0
+ if (!COMPLETE_TYPE_P (complete_type (type))
&& !TYPE_BEING_DEFINED (type))
{
cp_error ("incomplete type `%T' does not have member `%D'", type,
/* A Bison parser, made from parse.y
- by GNU Bison version 1.27
- */
+ by GNU Bison version 1.28 */
#define YYBISON 1 /* Identify Bison output. */
78, 79, 80, 81, 82, 83, 84, 85
};
/* -*-C-*- Note some compilers choke on comments on `#line' lines. */
-#line 3 "/usr/share/bison.simple"
-/* This file comes from bison-1.27. */
+#line 3 "/usr/lib/bison.simple"
+/* This file comes from bison-1.28. */
/* Skeleton output parser for bison,
Copyright (C) 1984, 1989, 1990 Free Software Foundation, Inc.
#endif
#endif
\f
-#line 216 "/usr/share/bison.simple"
+#line 217 "/usr/lib/bison.simple"
/* The user can define YYPARSE_PARAM as the name of an argument to be passed
into yyparse. The argument should have type void *.
/* struct B: public A; is not accepted by the standard grammar. */
if (CLASS_TYPE_P (yyval.ftype.t)
&& TYPE_BINFO_BASETYPES (yyval.ftype.t)
- && !TYPE_SIZE (yyval.ftype.t)
+ && !COMPLETE_TYPE_P (yyval.ftype.t)
&& ! TYPE_BEING_DEFINED (yyval.ftype.t))
cp_error ("base clause without member specification for `%#T'",
yyval.ftype.t);
break;}
}
/* the action file gets copied in in place of this dollarsign */
-#line 542 "/usr/share/bison.simple"
+#line 543 "/usr/lib/bison.simple"
\f
yyvsp -= yylen;
yyssp -= yylen;
/* struct B: public A; is not accepted by the standard grammar. */
if (CLASS_TYPE_P ($$.t)
&& TYPE_BINFO_BASETYPES ($$.t)
- && !TYPE_SIZE ($$.t)
+ && !COMPLETE_TYPE_P ($$.t)
&& ! TYPE_BEING_DEFINED ($$.t))
cp_error ("base clause without member specification for `%#T'",
$$.t);
if (IS_AGGR_TYPE (type) && CLASSTYPE_USE_TEMPLATE (type))
{
if (CLASSTYPE_IMPLICIT_INSTANTIATION (type)
- && TYPE_SIZE (type) == NULL_TREE)
+ && !COMPLETE_TYPE_P (type))
{
if (current_namespace
!= decl_namespace_context (CLASSTYPE_TI_TEMPLATE (type)))
new_friend = old_decl;
}
}
- else if (TYPE_SIZE (DECL_CONTEXT (new_friend)))
+ else if (COMPLETE_TYPE_P (DECL_CONTEXT (new_friend)))
{
/* Check to see that the declaration is really present, and,
possibly obtain an improved declaration. */
if (type == error_mark_node)
return error_mark_node;
- if (TYPE_BEING_DEFINED (type) || TYPE_SIZE (type))
+ if (TYPE_BEING_DEFINED (type) || COMPLETE_TYPE_P (type))
return type;
/* Figure out which template is being instantiated. */
/* If the template we're instantiating is incomplete, then clearly
there's nothing we can do. */
- if (TYPE_SIZE (pattern) == NULL_TREE)
+ if (!COMPLETE_TYPE_P (pattern))
return type;
/* If this is a partial instantiation, don't tsubst anything. We will
point, so here CTX really should have complete type, unless
it's a partial instantiation. */
ctx = complete_type (ctx);
- if (!TYPE_SIZE (ctx))
+ if (!COMPLETE_TYPE_P (ctx))
{
if (complain)
incomplete_type_error (NULL_TREE, ctx);
if (flag_external_templates)
return;
- if (TYPE_SIZE (t) == NULL_TREE)
+ if (!COMPLETE_TYPE_P (t))
{
cp_error ("explicit instantiation of `%#T' before definition of template",
t);
{
tree fn;
- if (!TYPE_SIZE (instantiation))
+ if (!COMPLETE_TYPE_P (instantiation))
{
instantiate_class_template (instantiation);
if (CLASSTYPE_TEMPLATE_INSTANTIATION (instantiation))
fn = TREE_CHAIN (fn))
if (! DECL_ARTIFICIAL (fn))
instantiate_decl (fn);
- if (TYPE_SIZE (instantiation))
+ if (COMPLETE_TYPE_P (instantiation))
{
instantiated_something = 1;
reconsider = 1;
}
}
- if (TYPE_SIZE (instantiation))
+ if (COMPLETE_TYPE_P (instantiation))
/* If INSTANTIATION has been instantiated, then we don't
need to consider it again in the future. */
*t = TREE_CHAIN (*t);
/* If we're not done setting up the class, we may not have set up
the vtable, so going ahead would give the wrong answer.
See g++.pt/instantiate4.C. */
- if (TYPE_SIZE (t) == NULL_TREE || TYPE_BEING_DEFINED (t))
+ if (!COMPLETE_TYPE_P (t) || TYPE_BEING_DEFINED (t))
my_friendly_abort (981113);
t = TYPE_BINFO_VTABLE (t);
return error_mark_node;
}
- if (TYPE_SIZE (type_info_type_node) == NULL_TREE)
+ if (!COMPLETE_TYPE_P (type_info_type_node))
{
error ("must #include <typeinfo> before using typeid");
return error_mark_node;
if (type == error_mark_node)
return error_mark_node;
- if (TYPE_SIZE (type_info_type_node) == NULL_TREE)
+ if (!COMPLETE_TYPE_P (type_info_type_node))
{
error ("must #include <typeinfo> before using typeid");
return error_mark_node;
errstr = "target is not pointer or reference to class";
goto fail;
}
- if (TYPE_SIZE (complete_type (TREE_TYPE (type))) == NULL_TREE)
+ if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (type))))
{
errstr = "target is not pointer or reference to complete type";
goto fail;
errstr = "source is not a pointer to class";
goto fail;
}
- if (TYPE_SIZE (complete_type (TREE_TYPE (exprtype))) == NULL_TREE)
+ if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (exprtype))))
{
errstr = "source is a pointer to incomplete type";
goto fail;
errstr = "source is not of class type";
goto fail;
}
- if (TYPE_SIZE (complete_type (TREE_TYPE (exprtype))) == NULL_TREE)
+ if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (exprtype))))
{
errstr = "source is of incomplete class type";
goto fail;
break;
case UNION_TYPE:
case RECORD_TYPE:
- if (!TYPE_SIZE (target_type))
+ if (!COMPLETE_TYPE_P (target_type))
{
/* FIXME: incomplete type. Awaiting specification. */
return NULL_TREE;
bltn_type = xref_tag (class_type_node,
get_identifier ("__fundamental_type_info"), 1);
pop_nested_namespace (abi_node);
- if (!TYPE_SIZE (bltn_type))
+ if (!COMPLETE_TYPE_P (bltn_type))
return;
dtor = TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (bltn_type), 1);
if (DECL_EXTERNAL (dtor))
/* If the type is complete and we're past the conversion ops,
switch to binary search. */
if (! DECL_CONV_FN_P (tmp)
- && TYPE_SIZE (type))
+ && COMPLETE_TYPE_P (type))
{
int lo = i + 1, hi = len;
tree t;
tree conversions = NULL_TREE;
- if (TYPE_SIZE (type))
+ if (COMPLETE_TYPE_P (type))
bfs_walk (TYPE_BINFO (type), add_conversions, 0, &conversions);
for (t = conversions; t; t = TREE_CHAIN (t))
}
/* If this type was already complete, and we see another definition,
that's an error. */
- else if (TYPE_SIZE (t))
+ else if (COMPLETE_TYPE_P (t))
duplicate_tag_error (t);
/* Update the location of the decl. */
t = type_hash_canon (hashcode, t);
- if (TYPE_SIZE (t) == 0)
+ if (!COMPLETE_TYPE_P (t))
layout_type (t);
return t;
type = TREE_TYPE (value);
/* First, detect a valid value with a complete type. */
- if (TYPE_SIZE (type) && !integer_zerop (TYPE_SIZE (type)))
+ if (COMPLETE_TYPE_P (type))
return value;
/* If we see X::Y, we build an OFFSET_TYPE which has
at some point. */
return error_mark_node;
- if (type == error_mark_node || TYPE_SIZE (type) != NULL_TREE)
+ if (type == error_mark_node || COMPLETE_TYPE_P (type))
;
else if (TREE_CODE (type) == ARRAY_TYPE && TYPE_DOMAIN (type))
{
tree t = complete_type (TREE_TYPE (type));
- if (TYPE_SIZE (t) != NULL_TREE && ! processing_template_decl)
+ if (COMPLETE_TYPE_P (t) && ! processing_template_decl)
layout_type (type);
TYPE_NEEDS_CONSTRUCTING (type)
= TYPE_NEEDS_CONSTRUCTING (TYPE_MAIN_VARIANT (t));
if (type == error_mark_node)
/* We already issued an error. */
return NULL_TREE;
- else if (!TYPE_SIZE (type) || integer_zerop (TYPE_SIZE (type)))
+ else if (!COMPLETE_TYPE_P (type))
{
incomplete_type_error (value, type);
return NULL_TREE;
return size_zero_node;
}
- if (TYPE_SIZE (complete_type (type)) == 0)
+ if (!COMPLETE_TYPE_P (complete_type (type)))
{
cp_error ("`sizeof' applied to incomplete type `%T'", type);
return size_zero_node;
if (code == REFERENCE_TYPE)
type = TREE_TYPE (type);
- if (TYPE_SIZE (type) == 0)
+ if (!COMPLETE_TYPE_P (type))
return size_zero_node;
/* Convert in case a char is more than one unit. */
address arithmetic on its address.
Likewise an array of elements of variable size. */
if (TREE_CODE (idx) != INTEGER_CST
- || (TYPE_SIZE (TREE_TYPE (TREE_TYPE (array))) != 0
+ || (COMPLETE_TYPE_P (TREE_TYPE (TREE_TYPE (array)))
&& (TREE_CODE (TYPE_SIZE (TREE_TYPE (TREE_TYPE (array))))
!= INTEGER_CST)))
{
/* Formal parm type is specified by a function prototype. */
tree parmval;
- if (TYPE_SIZE (complete_type (type)) == 0)
+ if (!COMPLETE_TYPE_P (complete_type (type)))
{
error ("parameter type of called function is incomplete");
parmval = val;
cp_convert (restype, op1));
/* This generates an error if op1 is a pointer to an incomplete type. */
- if (TYPE_SIZE (TREE_TYPE (TREE_TYPE (op1))) == 0)
+ if (!COMPLETE_TYPE_P (TREE_TYPE (TREE_TYPE (op1))))
error ("invalid use of a pointer to an incomplete type in pointer arithmetic");
op1 = ((TREE_CODE (target_type) == VOID_TYPE
if (code == ADDR_EXPR
&& TREE_CODE (xarg) != TEMPLATE_ID_EXPR
&& ((IS_AGGR_TYPE_CODE (TREE_CODE (TREE_TYPE (xarg)))
- && TYPE_SIZE (TREE_TYPE (xarg)) == NULL_TREE)
+ && !COMPLETE_TYPE_P (TREE_TYPE (xarg)))
|| (TREE_CODE (xarg) == OFFSET_REF)))
/* don't look for a function */;
else
if (TREE_CODE (argtype) == POINTER_TYPE)
{
enum tree_code tmp = TREE_CODE (TREE_TYPE (argtype));
- if (TYPE_SIZE (complete_type (TREE_TYPE (argtype))) == 0)
+ tree type = complete_type (TREE_TYPE (argtype));
+
+ if (!COMPLETE_OR_VOID_TYPE_P (type))
cp_error ("cannot %s a pointer to incomplete type `%T'",
((code == PREINCREMENT_EXPR
|| code == POSTINCREMENT_EXPR)
&& TREE_CODE (otype) == POINTER_TYPE
&& TREE_CODE (TREE_TYPE (otype)) != VOID_TYPE
&& TREE_CODE (TREE_TYPE (otype)) != FUNCTION_TYPE
- && TYPE_SIZE (TREE_TYPE (otype))
- && TYPE_SIZE (TREE_TYPE (type))
+ && COMPLETE_TYPE_P (TREE_TYPE (otype))
+ && COMPLETE_TYPE_P (TREE_TYPE (type))
&& TYPE_ALIGN (TREE_TYPE (type)) > TYPE_ALIGN (TREE_TYPE (otype)))
cp_warning ("cast from `%T' to `%T' increases required alignment of target type",
otype, type);
{
tree tmp = convert_from_reference (lhs);
lhstype = TREE_TYPE (tmp);
- if (TYPE_SIZE (lhstype) == 0)
+ if (!COMPLETE_TYPE_P (lhstype))
{
incomplete_type_error (lhs, lhstype);
return error_mark_node;
if (TREE_CODE (TREE_TYPE (newrhs)) == REFERENCE_TYPE)
{
tree tmp = convert_from_reference (newrhs);
- if (TYPE_SIZE (TREE_TYPE (tmp)) == 0)
+ if (!COMPLETE_TYPE_P (TREE_TYPE (tmp)))
{
incomplete_type_error (newrhs, TREE_TYPE (tmp));
return error_mark_node;
/* Come here only for records and arrays (and unions with constructors). */
- if (TYPE_SIZE (type) && ! TREE_CONSTANT (TYPE_SIZE (type)))
+ if (COMPLETE_TYPE_P (type) && ! TREE_CONSTANT (TYPE_SIZE (type)))
{
cp_error ("variable-sized object of type `%T' may not be initialized",
type);
then the slot being initialized will be filled in. */
- if (TYPE_SIZE (complete_type (type)) == NULL_TREE)
- {
- cp_error ("type `%T' is not yet defined", type);
- return error_mark_node;
- }
+ if (!complete_type_or_else (type, NULL_TREE))
+ return error_mark_node;
if (abstract_virtuals_error (NULL_TREE, type))
return error_mark_node;
else if (TREE_CODE (core) == TEMPLATE_TYPE_PARM)
ok = 1;
else
- ok = TYPE_SIZE (complete_type (core)) != NULL_TREE;
+ ok = COMPLETE_TYPE_P (complete_type (core));
if (ok)
{
tree type = TREE_TYPE (syms);
if (TYPE_NAME (type)
&& TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
- && TYPE_SIZE (type) != NULL_TREE
+ && COMPLETE_TYPE_P (type)
&& ! TREE_ASM_WRITTEN (TYPE_NAME (type)))
dbxout_symbol (TYPE_NAME (type), 0);
}
and either that's all we want or that's the best we could do,
don't repeat the cross reference.
Sun dbx crashes if we do. */
- if (! full || TYPE_SIZE (type) == 0
+ if (! full || !COMPLETE_TYPE_P (type)
/* No way in DBX fmt to describe a variable size. */
|| TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
return;
&& ! (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
&& DECL_IGNORED_P (TYPE_NAME (type)))
&& !full)
- || TYPE_SIZE (type) == 0
+ || !COMPLETE_TYPE_P (type)
/* No way in DBX fmt to describe a variable size. */
|| TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
{
&& ! (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
&& DECL_IGNORED_P (TYPE_NAME (type)))
&& !full)
- || TYPE_SIZE (type) == 0
+ || !COMPLETE_TYPE_P (type)
/* No way in DBX fmt to describe a variable size. */
|| TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
{
&& ! (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
&& DECL_IGNORED_P (TYPE_NAME (type)))
&& !full)
- || TYPE_SIZE (type) == 0)
+ || !COMPLETE_TYPE_P (type))
{
fprintf (asmfile, "xe");
CHARS (3);
if (tag_needed && TYPE_NAME (type) != 0
&& (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE
|| (DECL_NAME (TYPE_NAME (type)) != 0))
- && TYPE_SIZE (type) != 0
+ && COMPLETE_TYPE_P (type)
&& !TREE_ASM_WRITTEN (TYPE_NAME (type)))
{
/* For a TYPE_DECL with no name, but the type has a name,
rtl = DECL_INCOMING_RTL (decl);
else if (! BYTES_BIG_ENDIAN)
if (TREE_CODE (declared_type) == INTEGER_TYPE)
+ /* NMS WTF? */
if (TYPE_SIZE (declared_type) <= TYPE_SIZE (passed_type))
rtl = DECL_INCOMING_RTL (decl);
}
given enum type is incomplete, do not generate the AT_byte_size
attribute or the AT_element_list attribute. */
- if (TYPE_SIZE (type))
+ if (COMPLETE_TYPE_P (type))
{
byte_size_attribute (type);
element_list_attribute (TYPE_FIELDS (type));
of members (since we don't have any idea what they might be for an
incomplete type). */
- if (TYPE_SIZE (type))
+ if (COMPLETE_TYPE_P (type))
{
dienum_push ();
byte_size_attribute (type);
of members (since we don't have any idea what they might be for an
incomplete type). */
- if (TYPE_SIZE (type))
+ if (COMPLETE_TYPE_P (type))
{
dienum_push ();
byte_size_attribute (type);
can safely generate correct Dwarf descriptions for these file-
scope tagged types. */
- if (TYPE_SIZE (type) == 0
+ if (!COMPLETE_TYPE_P (type)
&& (TYPE_CONTEXT (type) == NULL
|| AGGREGATE_TYPE_P (TYPE_CONTEXT (type))
|| TREE_CODE (TYPE_CONTEXT (type)) == NAMESPACE_DECL)
appropriate (containing) type.
*/
- if (TYPE_SIZE (type))
+ if (COMPLETE_TYPE_P (type))
{
/* First output info about the base classes. */
if (TYPE_BINFO (type) && TYPE_BINFO_BASETYPES (type))
So we assume here that something at a higher level has prevented a
clash. This is somewhat bogus, but the best we can do. Only
do this when X is BLKmode and when we are at the top level. */
- || (top_p && TREE_TYPE (exp) != 0 && TYPE_SIZE (TREE_TYPE (exp)) != 0
+ || (top_p && TREE_TYPE (exp) != 0 && COMPLETE_TYPE_P (TREE_TYPE (exp))
&& TREE_CODE (TYPE_SIZE (TREE_TYPE (exp))) != INTEGER_CST
&& (TREE_CODE (TREE_TYPE (exp)) != ARRAY_TYPE
|| TYPE_ARRAY_MAX_SIZE (TREE_TYPE (exp)) == NULL_TREE
case VAR_DECL:
/* If a static var's type was incomplete when the decl was written,
but the type is complete now, lay out the decl now. */
- if (DECL_SIZE (exp) == 0 && TYPE_SIZE (TREE_TYPE (exp)) != 0
+ if (DECL_SIZE (exp) == 0 && COMPLETE_TYPE_P (TREE_TYPE (exp))
&& (TREE_STATIC (exp) || DECL_EXTERNAL (exp)))
{
push_obstacks_nochange ();
push_to_sequence (conversion_insns);
- if (TYPE_SIZE (type) == 0
+ if (!COMPLETE_TYPE_P (type)
|| TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
/* This is a variable sized object. */
copy = gen_rtx_MEM (BLKmode,
|| TREE_CODE (type) == UNION_TYPE
|| TREE_CODE (type) == QUAL_UNION_TYPE)
{
- if (TYPE_SIZE (type) != 0 /* not a forward reference */
+ if (COMPLETE_TYPE_P (type) /* not a forward reference */
&& KNOWN_TYPE_TAG (type) == 0) /* not yet declared */
sdbout_one_type (type);
}
return;
/* Output nothing if type is not yet defined. */
- if (TYPE_SIZE (type) == 0)
+ if (!COMPLETE_TYPE_P (type))
return;
TREE_ASM_WRITTEN (type) = 1;
break;
case VOID_TYPE:
- TYPE_SIZE (type) = bitsize_int (0);
+ /* VOID_TYPE is an incompletable type, it has no size */
TYPE_SIZE_UNIT (type) = size_zero_node;
TYPE_ALIGN (type) = 1;
TYPE_MODE (type) = VOIDmode;
hashcode = TYPE_HASH (elt_type) + TYPE_HASH (index_type);
t = type_hash_canon (hashcode, t);
- if (TYPE_SIZE (t) == 0)
+ if (!COMPLETE_TYPE_P (t))
layout_type (t);
return t;
}
hashcode = TYPE_HASH (value_type) + type_hash_list (arg_types);
t = type_hash_canon (hashcode, t);
- if (TYPE_SIZE (t) == 0)
+ if (!COMPLETE_TYPE_P (t))
layout_type (t);
return t;
}
hashcode = TYPE_HASH (basetype) + TYPE_HASH (type);
t = type_hash_canon (hashcode, t);
- if (TYPE_SIZE (t) == 0)
+ if (!COMPLETE_TYPE_P (t))
layout_type (t);
return t;
hashcode = TYPE_HASH (basetype) + TYPE_HASH (type);
t = type_hash_canon (hashcode, t);
- if (TYPE_SIZE (t) == 0)
+ if (!COMPLETE_TYPE_P (t))
layout_type (t);
return t;
hashcode = TYPE_HASH (component_type);
t = type_hash_canon (hashcode, t);
- if (TYPE_SIZE (t) == 0)
+ if (!COMPLETE_TYPE_P (t))
layout_type (t);
/* If we are writing Dwarf2 output we need to create a name,
#define POINTER_TYPE_P(TYPE) \
(TREE_CODE (TYPE) == POINTER_TYPE || TREE_CODE (TYPE) == REFERENCE_TYPE)
+/* Nonzero if this type is a complete type. */
+#define COMPLETE_TYPE_P(NODE) (TYPE_SIZE (NODE) != NULL_TREE)
+
+/* Nonzero if this type is complete or is cv void. */
+#define COMPLETE_OR_VOID_TYPE_P(NODE) \
+ (COMPLETE_TYPE_P (NODE) || TREE_CODE (NODE) == VOID_TYPE)
+
+/* Nonzero if this type is complete or is an array with unspecified bound. */
+#define COMPLETE_OR_UNBOUND_ARRAY_TYPE_P(NODE) \
+ (COMPLETE_TYPE_P (TREE_CODE (NODE) == ARRAY_TYPE ? TREE_TYPE (NODE) : NODE))
+
/* Nonzero if TYPE represents a type. */
#define TYPE_P(TYPE) (TREE_CODE_CLASS (TREE_CODE (TYPE)) == 't')
OSDN Git Service
