[10/10] C++ support for sizeless types

This patch adds support for sizeless types to C++, along the lines
described in the covering RFC.  As with the C patch, it's actually a
squash of a series of patches that I've attached as a tarball, with each
patch building up the support piece-by-piece.  The individual patches
have covering notes giving a quick explanation.

Most of the patch is replacing the test for whether a class has been
fully defined (for COMPLETE_TYPE_P) or whether the definition has
been started (COMPLETE_OR_OPEN_TYPE_P) in cases where member lookup
is all that matters.

The patch adds comments explaining why some tests of COMPLETE_TYPE_P
are either correct as-is or why it doesn't matter whether they're
replaced or not.  These were mostly for keeping track while doing
the work; I don't know whether it would make sense to commit them.

I realise this isn't likely to be acceptable in its current state,
not least because it would create a maintenance burden as the language
evolves.  The question is more: what changes would be needed to
make it acceptable?

One option would be to make COMPLETE_TYPE_P mean "the type is fully
defined" and use something else for "the type is fully defined and
has a defined size, alignment and layout".  The problem is that we'll
then err on the side of accepting things for sizeless types rather than
rejecting them, whereas the idea was to make the handling for complete
types conservatively correct.  In other words, the language meaning of
complete type would still be "has sufficient information to determine
the size" while COMPLETE_TYPE_P would mean something else.

Another option would be to remove COMPLETE_TYPE_P altogether and
use a new macro for "is fully defined and has a measurable size".
E.g. we could have:

    TYPE_DEFINITION_STARTED_P (etc.)
    --> what's now COMPLETE_OR_OPEN_TYPE_P

    TYPE_DEFINED_P (or TYPE_FULLY_DEFINED_P, etc.)
    --> what's now COMPLETE_TYPE_P when the size, alignment and
    layout don't matter

    TYPE_SIZE_KNOWN_P (or TYPE_SIZE_DEFINED_P, TYPE_SIZE_COMPLETE_P, etc.)
    --> what's now COMPLETE_TYPE_P when the size, alignment or
    layout does matter.

2018-10-15  Richard Sandiford  <richard.sandiford@arm.com>

gcc/c-family/
	* c-common.h (definite_or_array_type_p): New function.

gcc/cp/
	* cp-tree.h (COMPLETE_OR_OPEN_TYPE_P): Replace with...
	(DEFINITE_OR_OPEN_TYPE_P): ...this new macro.
	(sizeless_struct_type): New tag_types enum.
	(require_complete_type_sfinae): Add a default false parameter.
	(complete_type_or_else): Likewise.
	(complete_type_or_maybe_complain): Likewise.
	(require_definite_type_sfinae): New function.
	(definite_type_or_maybe_complain): Likewise.
	(definite_type_or_else): Likewise.
	* call.c (reference_binding): Require definite types rather
	than complete types when processing the target type of a
	reference binding.
	(implicit_conversion): Likewise when processing the target
	type of an implicit conversion.
	(convert_arg_to_ellipsis): Likewise when processing a value
	that is being passed through "...".
	(build_x_va_arg): Likewise when processing the second argument
	to va_arg.
	(maybe_warn_class_memaccess): Likewise when processing a
	member access.
	(build_cxx_call): Likewise when processing the function in
	a function call.
	(build_special_member_call): Likewise when looking up a
	special member.
	(complain_about_no_candidates_for_method_call): Likewise
	when reporting that a type has no suitable member functions.
	(add_builtin_candidate, build_op_delete_call)
	(convert_like_real): Add comments.
	* class.c (build_base_path, check_bases): Likewise.
	(check_field_decls, build_base_field): Likewise.
	(add_method): Require definite types rather than complete types
	when adding a new member to a class.
	(type_has_virtual_destructor): Relax the assert so that it
	accepts sizeless definite types as well as complete types.
	(type_build_dtor_call): Handle destructors in sizeless definite
	types in the same way as destructors in complete classes.
	(finish_struct_1): Report a redeclaration error for classes
	that are already definite as well as already complete.
	Record that sizeless types are not literal types.
	(is_really_empty_class): Use the cached result for definite
	classes as well as complete classes.
	* constexpr.c (literal_type_p): Relax the assert so that it
	accepts sizeless definite types as well as complete types.
	(ensure_literal_type_for_constexpr_object): Check for indefinite
	rather than incomplete types when short-circuiting the test
	for literal types.
	(cxx_eval_constant_expression): Add comments.
	(potential_constant_expression_1): Likewise.
	* cp-gimplify.c (cxx_omp_finish_clause): Likewise.
	(cp_fold): Check for definite rather than complete types when
	handling the offsetof-like idiom.
	* cvt.c (cp_convert_to_pointer): Require definite types rather than
	complete types when processing the source of a pointer conversion.
	(convert_to_void): Check for indefinite types rather than incomplete
	types when issuing the warning abut converting to void.
	(build_expr_type_conversion): Add a comment.
	* decl.c (redeclaration_error_message): Check for definite types
	rather than complete types when deciding whether to issue a
	redeclaration error.
	(make_typename_type): Require definite types rather than complete
	types when resolving a typename.
	(cp_finish_decomp): Likewise when processing the source of a
	structured binding.
	(require_complete_types_for_parms): Likewise when processing
	the types of formal parameters.
	(check_function_type): Likewise when processing the return type
	in a function definition.
	(fixup_anonymous_aggr): Reject anonymous sizeless structures
	in sized aggregates.
	(start_decl): Check for definite types rather than complete types
	when processing a decl that belongs to an already-defined class.
	(start_decl_1): Require initialized and aggregate definitions
	to have definite rather than complete type.  Reject sizeless decls
	with static or thread-local storage duration.
	(layout_var_decl): Check for definite types rather than complete types
	when deciding whether to lay out a decl.
	(check_array_initializer, get_tuple_size): Add comments.
	(check_static_variable_definition, grok_op_properties): Likewise.
	(check_initializer): Require the initialized type to have definite
	rather than complete type.
	(cp_finish_decl): Check for indefinite types rather than incomplete
	types when deciding whether to suppress debug information.
	(grokdeclarator): Likewise when processing qualified function names.
	Reject virtual methods inside a sizeless struct.  Accept sizeless
	definite members in sizeless structs, but not in normal sized
	aggregates.
	(tag_name, xref_tag_1): Handle sizeless_struct_type.
	(xref_basetypes): Reject base classes for sizeless structs.
	(finish_enum_value_list): Check for definite types rather than
	complete types when processing qualified enum names.
	(begin_destructor_body): Likewise when deciding whether to build
	a destructor body.
	(maybe_register_incomplete_var): Likewise when deciding whether
	to queue a variable for later processing.
	* decl2.c (check_classfn): Check for definite types rather than
	complete types when deciding how to report a name lookup failure.
	(cp_omp_mappable_type): Add a comment.
	* error.c (class_key_or_enum_as_string): Return "__sizeless_struct"
	for sizeless structs.
	(qualified_name_lookup_error): Check for definite types rather than
	complete types when deciding how to report a name lookup failure.
	* except.c (complete_ptr_ref_or_void_ptr_p): Add comments.
	* expr.c (cplus_expand_constant): Check for definite types rather than
	complete types when deciding whether to punt on PTRMEM_CSTs.
	* friend.c (do_friend): Require definite types rather than complete
	types when processing the class name in a member friend declaration.
	* init.c (build_value_init_noctor): Likewise when processing
	a vector initializer.
	(build_offset_ref): Likewise when processing the class name
	in a member reference.  Reject attempts to create pointers
	to member variables of sizeless structures.
	(emit_mem_initializers): Check for definite types rather than
	complete types when deciding whether to emit code for initializers.
	(build_new): Add a comment.
	(build_vec_delete_1): Reject attempts to delete sizeless objects.
	(build_delete): Likewise.
	* lambda.c (lambda_function): Check for definite types rather than
	complete types when trying to detect debug_tree calls.
	(lambda_expr_this_capture): Likewise when handling "this" in a NSDMI.
	(add_capture): Tighten assert so that it requires the capture
	to be indefinite as well as incomplete.
	* name-lookup.c (search_anon_aggr): Accept definite types as
	well as complete types.
	(get_class_binding_direct, get_class_binding, find_member_slot)
	(add_member_slot): Extend handling of name lookup and member
	registration for complete types to sizeless types.
	(maybe_process_template_type_declaration, do_pushtag): Check for
	indefinite types rather than incomplete types when deciding
	whether to queue a template instantiation.
	* parser.c (cp_keyword_starts_decl_specifier_p): Handle
	RID_SIZELESS_STRUCT.
	(cp_parser_type_specifier): Likewise.
	(cp_parser_token_is_class_key): Likewise.
	(cp_parser_diagnose_invalid_type_name): Check for definite types
	rather than complete types when deciding how to report a name
	lookup failure.
	(cp_parser_nested_name_specifier_opt): Extend shortcut for
	complete types to definite types.
	(cp_parser_postfix_dot_deref_expression): Require definite types
	rather than complete types when processing "." and "->" expressions.
	(cp_parser_perform_range_for_lookup): Likewise when processing
	range-based for loops.
	(cp_parser_class_head): Check whether the existing type is definite
	rather than complete when deciding whether to issue a redefinition
	error.
	(cp_parser_check_class_key): Extend checks for invalid tags to
	include __sizeless_struct.
	* pt.c (maybe_new_partial_specialization): Check for indefinite types
	rather than incomplete types when deciding whether to exit early.
	(maybe_process_partial_specialization): Likewise when deciding
	whether something is an explicit specialization.
	(process_partial_specialization): Tighten assert so that it requires
	the instantiation to be indefinite as well as incomplete.  Check for
	definite types rather than complete types when checking whether
	earlier uses are ambiguated or invalidated by the specialization.
	(lookup_template_class_1): Copy TYPE_SIZELESS_P to the instantiation.
	(tsubst_friend_function): Require definite types rather than complete
	types when processing the class name in a member friend declaration.
	(tsubst): Likewise when processing the class name in a typename.
	(do_type_instantiation): Likewise for the type of a template
	when processing an instantiation of it.
	(can_complete_type_without_circularity): Check for definite types
	rather than complete types when deciding whether to exit early.
	(instantiate_class_template_1): Likewise, and also when deciding
	whether to defer the instantiation till later.  Allow instantations
	of sizeless structure templates to have sizeless members.
	(instantiate_pending_templates): Check for definite types rather than
	complete types when deciding whether to process or defer a queued
	instantiation.
	* rtti.c (get_tinfo_decl_dynamic, typeid_ok_p, get_typeid)
	(build_dynamic_cast_1, tinfo_base_init): Add comments.
	* search.c (lookup_base): Extend base lookup in complete types to
	definite types.
	* semantics.c (finish_underlying_type, calculate_direct_bases)
	(calculate_bases, finish_offsetof, finish_omp_clauses)
	(finish_omp_threadprivate): Add comments.
	(check_trait_type): Require definite types rather than complete
	types when processing a type trait query.
	(finish_trait_expr): Likewise for the second type in __is_base_of.
	(apply_deduced_return_type): Likewise when processing an auto
	return type.
	* tree.c (build_cplus_new): Likewise when processing a constructor
	call.
	(build_cplus_array_type): Add a comment.
	(strip_typedefs): Check for definite types rather than complete
	types when deciding whether to skip the attribute handling.
	(type_has_nontrivial_copy_init): Accept definite types as
	well as complete types.
	(record_has_unique_obj_representations): Handle poly_int offsets.
	* typeck.c (require_complete_type_sfinae): Add a sizeless_p
	parameter.
	(complete_type_or_maybe_complain): Likewise.
	(complete_type_or_else): Likewise.
	(complete_type): Check for definite types rather than complete
	types when deciding whether to bail out early.
	(cxx_sizeof_or_alignof_type, cxx_sizeof_nowarn): Add comments.
	(cp_build_array_ref, pointer_diff): Likewise.
	(build_reinterpret_cast_1, ptr_reasonably_similar): Likewise.
	(decay_conversion): Require definite types rather than complete
	types when processing the source of the conversion.
	(build_class_member_access_expr): Likewise when processing a
	member access.
	(finish_class_member_access_expr): Likewise.
	(convert_arguments): Likewise when processing the types of
	formal and actual parameters in a function call.
	(cp_build_modify_expr): Likewise when processing the lhs
	of an assignment.
	(convert_for_assignment): Likewise when processing the rhs
	of an assignment.
	(get_member_function_from_ptrfunc): Check for definite types
	rather than complete types when optimizing the handling of
	non-virtual methods.
	(build_x_unary_op): Likewise when deciding whether to circumvent
	the use of operator&.
	(cp_apply_type_quals_to_decl): Likewise when deciding whether
	to remove const qualification.
	* typeck2.c (complete_type_check_abstract): Accept definite types as
	well as complete types.
	(abstract_virtuals_error_sfinae): Check for indefinite types
	rather than incomplete types when deciding whether to postpone
	the check for whether a type has abstract virtual functions.
	(digest_init_r): Require definite types rather than complete
	types when processing the type being initialized.
	(build_functional_cast): Likewise when processing a constructor call.
	(build_m_component_ref, add_exception_specifier): Add a comment.
	(require_complete_eh_spec_types): Likewise.

gcc/testsuite/
	* g++.dg/ext/sizeless-1.C: New test.
	* g++.dg/ext/sizeless-2.C: Likewise.
	* g++.dg/ext/sizeless-3.C: Likewise.
	* g++.dg/ext/sizeless-4.C: Likewise.
	* g++.dg/ext/sizeless-5.C: Likewise.
	* g++.dg/ext/sizeless-6.C: Likewise.
	* g++.dg/ext/sizeless-7.C: Likewise.

Message ID	8736t7i8bf.fsf@arm.com
State	New
Headers	show Return-Path: <gcc-patches-return-487576-incoming=patchwork.ozlabs.org@gcc.gnu.org> DomainKey-Signature: a=rsa-sha1; c=nofws; d=gcc.gnu.org; h=list-id :list-unsubscribe:list-archive:list-post:list-help:sender:from :to:cc:subject:references:date:in-reply-to:message-id :mime-version:content-type; q=dns; s=default; b=bdwspMm9t4dX0q3A rpdEPy/wjvAkfHkZy3dyTJaNs58B0rixgHKt8fsczsj26tAshNsNI0PI9YKSXJlo 6+khqkt2j/TO5TKg09lsVyQB3u8B4y6+WIR4vb+7XD+xWx4EJ6AO2a/fDgVFKoqu E1/1I5WO+GpDkApXT4Qie5k6IX0= Mailing-List: contact gcc-patches-help@gcc.gnu.org; run by ezmlm Precedence: bulk Sender: gcc-patches-owner@gcc.gnu.org From: Richard Sandiford <richard.sandiford@arm.com> To: gcc-patches@gcc.gnu.org Mail-Followup-To: gcc-patches@gcc.gnu.org, joseph@codesourcery.com, jason@redhat.com, nathan@acm.org, nd@arm.com, richard.sandiford@arm.com Cc: joseph@codesourcery.com, jason@redhat.com, nathan@acm.org, nd@arm.com Subject: [10/10] C++ support for sizeless types References: <87d0sbjn97.fsf@arm.com> Date: Mon, 15 Oct 2018 15:38:28 +0100 In-Reply-To: <87d0sbjn97.fsf@arm.com> (Richard Sandiford's message of "Mon, 15 Oct 2018 15:30:28 +0100") Message-ID: <8736t7i8bf.fsf@arm.com> User-Agent: Gnus/5.13 (Gnus v5.13) Emacs/26.1 (gnu/linux) MIME-Version: 1.0 Content-Type: multipart/mixed; boundary="=-=-=" Received-SPF: None (protection.outlook.com: arm.com does not designate permitted sender hosts)
Series	Splitting the C and C++ concept of "complete type" \| expand [00/10,RFC] Splitting the C and C++ concept of "complete type" [01/10] Expand COMPLETE_TYPE_P in obvious checks for null [02/10] Replace most uses of COMPLETE_TYPE_P outside the frontends [03/10] Move COMPLETE_OR_VOID_TYPE_P to the C and C++ frontends [04/10] Move COMPLETE_OR_UNBOUND_ARRAY_TYPE_P to the C and C++ frontends [05/10] Move complete_or_array_type_p to the C and C++ frontends [06/10] Move COMPLETE_TYPE_P to the C and C++ frontends [07/10] Use COMPLETE_TYPE_P instead of TYPE_SIZE [08/10] Add a TYPE_SIZELESS_P property to types [09/10] C support for sizeless types [10/10] C++ support for sizeless types

[10/10] C++ support for sizeless types

Commit Message

Patch