* [PATCH 7/8] infcall: handle pass-by-reference arguments appropriately
2019-04-23 14:32 [PATCH 0/8] Fix inferior call for C++ pass-by-reference arguments Tankut Baris Aktemur
` (4 preceding siblings ...)
2019-04-23 14:32 ` [PATCH 1/8] gdb: recognize new DWARF attributes: defaulted, deleted, calling conv Tankut Baris Aktemur
@ 2019-04-23 14:32 ` Tankut Baris Aktemur
2019-04-23 14:33 ` [PATCH 5/8] infcall: move assertions in 'call_function_by_hand_dummy' to an earlier spot Tankut Baris Aktemur
` (3 subsequent siblings)
9 siblings, 0 replies; 19+ messages in thread
From: Tankut Baris Aktemur @ 2019-04-23 14:32 UTC (permalink / raw)
To: gdb-patches
If an aggregate argument is implicitly pass-by-reference, allocate
a temporary object on the stack, initialize it via the copy constructor
(if exists) or trivially by memcpy'ing. Pass the reference of the
temporary to the callee function. After the callee returns, invoke
the destructor of the temporary.
gdb/ChangeLog:
* infcall.c (call_function_by_hand_dummy): Update.
(struct destructor_info): New struct.
(call_destructors): New auxiliary function.
---
gdb/infcall.c | 103 ++++++++++++++++++++++++++++++++++++++++++++++++--
1 file changed, 100 insertions(+), 3 deletions(-)
diff --git a/gdb/infcall.c b/gdb/infcall.c
index bd88076dc7f..fdbf09045ff 100644
--- a/gdb/infcall.c
+++ b/gdb/infcall.c
@@ -42,6 +42,7 @@
#include "thread-fsm.h"
#include <algorithm>
#include "common/scope-exit.h"
+#include <list>
/* If we can't find a function's name from its address,
we print this instead. */
@@ -693,6 +694,33 @@ reserve_stack_space (const type *values_type, CORE_ADDR &sp)
return addr;
}
+/* The data structure which keeps a destructor function and
+ its implicit 'this' parameter. */
+
+struct destructor_info
+{
+ destructor_info (struct value *function, struct value *self)
+ : function (function), self (self) { }
+
+ struct value *function;
+ struct value *self;
+};
+
+
+/* Auxiliary function that takes a list of destructor functions
+ with their 'this' parameters, and invokes the functions. */
+
+static void
+call_destructors (const std::list<destructor_info> &dtors_to_invoke,
+ struct type *default_return_type)
+{
+ for (auto vals : dtors_to_invoke)
+ {
+ call_function_by_hand (vals.function, default_return_type,
+ gdb::make_array_view (&(vals.self), 1));
+ }
+}
+
/* See infcall.h. */
struct value *
@@ -968,6 +996,12 @@ call_function_by_hand_dummy (struct value *function,
internal_error (__FILE__, __LINE__, _("bad switch"));
}
+ /* Coerce the arguments and handle pass-by-reference.
+ We want to remember the destruction required for pass-by-ref values.
+ For these, store the dtor function and the 'this' argument
+ in DTORS_TO_INVOKE. */
+ std::list<destructor_info> dtors_to_invoke;
+
for (int i = args.size () - 1; i >= 0; i--)
{
int prototyped;
@@ -1005,9 +1039,68 @@ call_function_by_hand_dummy (struct value *function,
args[i] = value_arg_coerce (gdbarch, args[i],
param_type, prototyped);
- if (param_type != NULL
- && !(language_pass_by_reference (param_type).trivially_copyable))
- args[i] = value_addr (args[i]);
+ if (param_type == NULL)
+ continue;
+
+ auto info = language_pass_by_reference (param_type);
+ if (!info.copy_constructible)
+ error (_("expression cannot be evaluated because the type '%s' "
+ "is not copy constructible"), TYPE_NAME (param_type));
+
+ if (!info.destructible)
+ error (_("expression cannot be evaluated because the type '%s' "
+ "is not destructible"), TYPE_NAME (param_type));
+
+ if (info.trivially_copyable)
+ continue;
+
+ /* This is a pass-by-ref value. Check for error cases before
+ pushing the temporary to the stack. */
+
+ if (!info.trivially_copy_constructible && info.cctor_name == NULL)
+ error (_("evaluation of this expression requires a copy constructor"
+ " for the type '%s'."), TYPE_NAME (param_type));
+
+ if (!info.trivially_destructible && info.dtor_name == NULL)
+ error (_("evaluation of this expression requires a destructor"
+ " for the type '%s'."), TYPE_NAME (param_type));
+
+ /* Make a copy of the argument on the stack. If the argument is
+ trivially copy ctor'able, copy bit by bit. Otherwise, call
+ the copy ctor to initialize the clone. */
+ CORE_ADDR addr = reserve_stack_space (param_type, sp);
+ struct value *clone
+ = value_from_contents_and_address (param_type, NULL, addr);
+ push_thread_stack_temporary (call_thread.get (), clone);
+ struct value *clone_ptr
+ = value_from_pointer (lookup_pointer_type (param_type), addr);
+
+ if (info.trivially_copy_constructible)
+ {
+ int length = TYPE_LENGTH (param_type);
+ write_memory (addr, value_contents (args[i]), length);
+ }
+ else
+ {
+ struct value *copy_ctor
+ = find_function_in_inferior (info.cctor_name, 0);
+ struct value *cctor_args[2] = { clone_ptr, args[i] };
+ call_function_by_hand (copy_ctor, default_return_type,
+ gdb::make_array_view (cctor_args, 2));
+ }
+
+ /* If the argument has a destructor, remember it so that we
+ invoke it after the infcall is complete. */
+ if (!info.trivially_destructible)
+ {
+ struct value *dtor
+ = find_function_in_inferior (info.dtor_name, 0);
+ /* Insert the dtor to the front of the list to call them
+ in reverse order later. */
+ dtors_to_invoke.emplace_front (dtor, clone_ptr);
+ }
+
+ args[i] = clone_ptr;
}
/* Reserve space for the return structure to be written on the
@@ -1174,6 +1267,10 @@ call_function_by_hand_dummy (struct value *function,
maybe_remove_breakpoints ();
gdb_assert (retval != NULL);
+
+ /* Destruct the pass-by-ref argument clones. */
+ call_destructors (dtors_to_invoke, default_return_type);
+
return retval;
}
--
2.21.0
^ permalink raw reply [flat|nested] 19+ messages in thread
* [PATCH 1/8] gdb: recognize new DWARF attributes: defaulted, deleted, calling conv.
2019-04-23 14:32 [PATCH 0/8] Fix inferior call for C++ pass-by-reference arguments Tankut Baris Aktemur
` (3 preceding siblings ...)
2019-04-23 14:32 ` [PATCH 4/8] infcall: refactor 'call_function_by_hand_dummy' Tankut Baris Aktemur
@ 2019-04-23 14:32 ` Tankut Baris Aktemur
2019-04-23 21:40 ` Andrew Burgess
2019-04-23 14:32 ` [PATCH 7/8] infcall: handle pass-by-reference arguments appropriately Tankut Baris Aktemur
` (4 subsequent siblings)
9 siblings, 1 reply; 19+ messages in thread
From: Tankut Baris Aktemur @ 2019-04-23 14:32 UTC (permalink / raw)
To: gdb-patches
Extend GDB's internal representation of types to include the
DW_AT_calling_convention, DW_AT_defaulted, and DW_AT_deleted attributes
that were introduced in DWARF5.
gdb/ChangeLog:
* dwarf2read.c (dwarf2_add_member_fn): Read the DW_AT_defaulted
and DW_AT_deleted attributes of a function.
(read_structure_type): Read the DW_AT_calling_convention attribute
of a type.
* gdbtypes.h (struct fn_field)<defaulted>: New field to store the
DW_AT_defaulted attribute.
(struct fn_field)<is_deleted>: New field to store the DW_AT_deleted
attribute.
(struct cplus_struct_type)<calling_convention>: New field to store
the DW_AT_calling_convention attribute.
(TYPE_FN_FIELD_DEFAULTED): New macro.
(TYPE_FN_FIELD_DELETED): New macro.
(TYPE_CPLUS_CALLING_CONVENTION): New macro.
* gdbtypes.c: (dump_fn_fieldlists): Update for the changes made
to the .h file.
(print_cplus_stuff): Likewise.
---
gdb/dwarf2read.c | 20 ++++++++++++++++++++
gdb/gdbtypes.c | 7 +++++++
gdb/gdbtypes.h | 19 ++++++++++++++++++-
3 files changed, 45 insertions(+), 1 deletion(-)
diff --git a/gdb/dwarf2read.c b/gdb/dwarf2read.c
index 829b07f01ac..435f234f2c9 100644
--- a/gdb/dwarf2read.c
+++ b/gdb/dwarf2read.c
@@ -15539,6 +15539,16 @@ dwarf2_add_member_fn (struct field_info *fip, struct die_info *die,
if (attr && DW_UNSND (attr) != 0)
fnp->is_artificial = 1;
+ /* Check for defaulted methods. */
+ attr = dwarf2_attr (die, DW_AT_defaulted, cu);
+ if (attr)
+ fnp->defaulted = DW_UNSND (attr);
+
+ /* Check for deleted methods. */
+ attr = dwarf2_attr (die, DW_AT_deleted, cu);
+ if (attr && DW_UNSND (attr) != 0)
+ fnp->is_deleted = 1;
+
fnp->is_constructor = dwarf2_is_constructor (die, cu);
/* Get index in virtual function table if it is a virtual member
@@ -15859,6 +15869,16 @@ read_structure_type (struct die_info *die, struct dwarf2_cu *cu)
if (cu->language == language_cplus && die->tag == DW_TAG_class_type)
TYPE_DECLARED_CLASS (type) = 1;
+ /* Store the calling convention in the type if it's available in
+ the die. Otherwise the calling convention remains set to
+ the default value DW_CC_normal. */
+ attr = dwarf2_attr (die, DW_AT_calling_convention, cu);
+ if (attr)
+ {
+ ALLOCATE_CPLUS_STRUCT_TYPE (type);
+ TYPE_CPLUS_CALLING_CONVENTION (type) = DW_UNSND (attr);
+ }
+
attr = dwarf2_attr (die, DW_AT_byte_size, cu);
if (attr)
{
diff --git a/gdb/gdbtypes.c b/gdb/gdbtypes.c
index b3424d81be4..b32f13189a9 100644
--- a/gdb/gdbtypes.c
+++ b/gdb/gdbtypes.c
@@ -4389,6 +4389,10 @@ dump_fn_fieldlists (struct type *type, int spaces)
TYPE_FN_FIELD_PROTECTED (f, overload_idx));
printfi_filtered (spaces + 8, "is_stub %d\n",
TYPE_FN_FIELD_STUB (f, overload_idx));
+ printfi_filtered (spaces + 8, "defaulted %d\n",
+ TYPE_FN_FIELD_DEFAULTED (f, overload_idx));
+ printfi_filtered (spaces + 8, "is_deleted %d\n",
+ TYPE_FN_FIELD_DELETED (f, overload_idx));
printfi_filtered (spaces + 8, "voffset %u\n",
TYPE_FN_FIELD_VOFFSET (f, overload_idx));
}
@@ -4452,6 +4456,9 @@ print_cplus_stuff (struct type *type, int spaces)
{
dump_fn_fieldlists (type, spaces);
}
+
+ printfi_filtered (spaces, "calling_convention %d\n",
+ TYPE_CPLUS_CALLING_CONVENTION (type));
}
/* Print the contents of the TYPE's type_specific union, assuming that
diff --git a/gdb/gdbtypes.h b/gdb/gdbtypes.h
index 147a2de355e..3c7846a0e18 100644
--- a/gdb/gdbtypes.h
+++ b/gdb/gdbtypes.h
@@ -915,6 +915,10 @@ struct fn_field
struct type *fcontext;
+ /* * DW_AT_defaulted attribute. */
+
+ unsigned int defaulted;
+
/* Attributes. */
unsigned int is_const:1;
@@ -932,9 +936,13 @@ struct fn_field
unsigned int is_constructor : 1;
+ /* * True if this function is deleted, false otherwise. */
+
+ unsigned int is_deleted : 1;
+
/* * Unused. */
- unsigned int dummy:9;
+ unsigned int dummy:8;
/* * Index into that baseclass's virtual function table, minus 2;
else if static: VOFFSET_STATIC; else: 0. */
@@ -1076,6 +1084,11 @@ struct cplus_struct_type
classes. */
struct symbol **template_arguments;
+
+ /* * The calling convention for this type, fetched from the
+ DW_AT_calling_convention attribute. */
+
+ unsigned calling_convention : 8;
};
/* * Struct used to store conversion rankings. */
@@ -1405,6 +1418,8 @@ extern void set_type_vptr_basetype (struct type *, struct type *);
? (struct cplus_struct_type*)&cplus_struct_default \
: TYPE_RAW_CPLUS_SPECIFIC(thistype))
#define TYPE_RAW_CPLUS_SPECIFIC(thistype) TYPE_MAIN_TYPE(thistype)->type_specific.cplus_stuff
+#define TYPE_CPLUS_CALLING_CONVENTION(thistype) \
+ TYPE_MAIN_TYPE(thistype)->type_specific.cplus_stuff->calling_convention
#define TYPE_FLOATFORMAT(thistype) TYPE_MAIN_TYPE(thistype)->type_specific.floatformat
#define TYPE_GNAT_SPECIFIC(thistype) TYPE_MAIN_TYPE(thistype)->type_specific.gnat_stuff
#define TYPE_DESCRIPTIVE_TYPE(thistype) TYPE_GNAT_SPECIFIC(thistype)->descriptive_type
@@ -1521,6 +1536,8 @@ extern void set_type_vptr_basetype (struct type *, struct type *);
#define TYPE_FN_FIELD_VOFFSET(thisfn, n) ((thisfn)[n].voffset-2)
#define TYPE_FN_FIELD_VIRTUAL_P(thisfn, n) ((thisfn)[n].voffset > 1)
#define TYPE_FN_FIELD_STATIC_P(thisfn, n) ((thisfn)[n].voffset == VOFFSET_STATIC)
+#define TYPE_FN_FIELD_DEFAULTED(thisfn, n) ((thisfn)[n].defaulted)
+#define TYPE_FN_FIELD_DELETED(thisfn, n) ((thisfn)[n].is_deleted)
/* Accessors for typedefs defined by a class. */
#define TYPE_TYPEDEF_FIELD_ARRAY(thistype) \
--
2.21.0
^ permalink raw reply [flat|nested] 19+ messages in thread
* [PATCH 2/8] infcall, c++: allow more info to be computed for pass-by-reference values
2019-04-23 14:32 [PATCH 0/8] Fix inferior call for C++ pass-by-reference arguments Tankut Baris Aktemur
@ 2019-04-23 14:32 ` Tankut Baris Aktemur
2019-05-22 20:17 ` Andrew Burgess
2019-04-23 14:32 ` [PATCH 3/8] infcall, c++: collect more pass-by-reference information Tankut Baris Aktemur
` (8 subsequent siblings)
9 siblings, 1 reply; 19+ messages in thread
From: Tankut Baris Aktemur @ 2019-04-23 14:32 UTC (permalink / raw)
To: gdb-patches
In C++, call-by-value arguments that cannot be trivially copied are
implicitly passed by reference. When making an infcall, GDB needs to
find out if an argument is pass-by-reference or not, so that the correct
semantics can be followed. This patch enriches the information computed
by the language ops for pass-by-reference arguments. Instead of a plain
binary result, the computed information now includes whether the
argument is
- copy constructible
- destructible
- trivially copyable
- trivially copy constructible
- trivially destructible
and also
- the full name of the copy constructor
- the full name of the destructor
in preparation for GDB's infcall mechanism to call the copy ctor and
the destructor of a pass-by-ref argument appropriately. This
information is stored in a struct named 'language_pass_by_ref_info'.
gdb/ChangeLog:
* language.h (struct language_pass_by_ref_info): New struct.
(struct language_defn)<la_pass_by_reference>: Change the signature
to return a language_pass_by_ref_info instead of an int.
(language_pass_by_reference): Ditto.
(default_pass_by_reference): Ditto.
Adjust the users listed below.
* arch-utils.c (default_return_in_first_hidden_param_p):
Update.
* cp-abi.c (cp_pass_by_reference): Update.
* cp-abi.h (struct cp_abi_ops)<pass_by_reference>: Update.
* gnu-v3-abi.c (gnuv3_pass_by_reference): Update.
* infcall.c (call_function_by_hand_dummy): Update.
* language.c (language_pass_by_reference): Update.
(default_pass_by_reference): Update.
* tic6x-tdep.c (tic6x_return_value): Update.
---
gdb/arch-utils.c | 2 +-
gdb/cp-abi.c | 6 ++++--
gdb/cp-abi.h | 10 +++++----
gdb/gnu-v3-abi.c | 49 ++++++++++++++++++++++++++++++------------
gdb/infcall.c | 3 ++-
gdb/language.c | 27 +++++++++++++++++-------
gdb/language.h | 55 +++++++++++++++++++++++++++++++++++++++---------
gdb/tic6x-tdep.c | 2 +-
8 files changed, 114 insertions(+), 40 deletions(-)
diff --git a/gdb/arch-utils.c b/gdb/arch-utils.c
index 43f5834b383..5ccabde45e3 100644
--- a/gdb/arch-utils.c
+++ b/gdb/arch-utils.c
@@ -858,7 +858,7 @@ default_return_in_first_hidden_param_p (struct gdbarch *gdbarch,
/* Usually, the return value's address is stored the in the "first hidden"
parameter if the return value should be passed by reference, as
specified in ABI. */
- return language_pass_by_reference (type);
+ return !(language_pass_by_reference (type).trivially_copyable);
}
int default_insn_is_call (struct gdbarch *gdbarch, CORE_ADDR addr)
diff --git a/gdb/cp-abi.c b/gdb/cp-abi.c
index bbb74d42638..6503b4c160b 100644
--- a/gdb/cp-abi.c
+++ b/gdb/cp-abi.c
@@ -220,11 +220,13 @@ cplus_typename_from_type_info (struct value *value)
return (*current_cp_abi.get_typename_from_type_info) (value);
}
-int
+/* See cp-abi.h. */
+
+struct language_pass_by_ref_info
cp_pass_by_reference (struct type *type)
{
if ((current_cp_abi.pass_by_reference) == NULL)
- return 0;
+ return default_pass_by_reference (type);
return (*current_cp_abi.pass_by_reference) (type);
}
diff --git a/gdb/cp-abi.h b/gdb/cp-abi.h
index 3cbf19cd511..0afba77aeb1 100644
--- a/gdb/cp-abi.h
+++ b/gdb/cp-abi.h
@@ -207,9 +207,11 @@ extern std::string cplus_typename_from_type_info (struct value *value);
CORE_ADDR cplus_skip_trampoline (struct frame_info *frame,
CORE_ADDR stop_pc);
-/* Return non-zero if an argument of type TYPE should be passed by
- reference instead of value. */
-extern int cp_pass_by_reference (struct type *type);
+/* Fill in INFO with information about whether TYPE should be
+ passed (and returned) by reference at the language level. */
+
+extern struct language_pass_by_ref_info cp_pass_by_reference
+ (struct type *type);
struct cp_abi_ops
{
@@ -246,7 +248,7 @@ struct cp_abi_ops
struct type *(*get_type_from_type_info) (struct value *value);
std::string (*get_typename_from_type_info) (struct value *value);
CORE_ADDR (*skip_trampoline) (struct frame_info *, CORE_ADDR);
- int (*pass_by_reference) (struct type *type);
+ struct language_pass_by_ref_info (*pass_by_reference) (struct type *type);
};
diff --git a/gdb/gnu-v3-abi.c b/gdb/gnu-v3-abi.c
index 6407c9beb82..b39e5a5c585 100644
--- a/gdb/gnu-v3-abi.c
+++ b/gdb/gnu-v3-abi.c
@@ -1228,7 +1228,7 @@ gnuv3_skip_trampoline (struct frame_info *frame, CORE_ADDR stop_pc)
return real_stop_pc;
}
-/* Return nonzero if a type should be passed by reference.
+/* Return pass-by-reference information for the given TYPE.
The rule in the v3 ABI document comes from section 3.1.1. If the
type has a non-trivial copy constructor or destructor, then the
@@ -1246,22 +1246,33 @@ gnuv3_skip_trampoline (struct frame_info *frame, CORE_ADDR stop_pc)
We don't do anything with the constructors or destructors,
but we have to get the argument passing right anyway. */
-static int
+
+static struct language_pass_by_ref_info
gnuv3_pass_by_reference (struct type *type)
{
int fieldnum, fieldelem;
type = check_typedef (type);
+ /* Start with the default values. */
+ struct language_pass_by_ref_info info
+ = default_pass_by_reference (type);
+
+ /* FIXME: Currently, this implementation only fills in the
+ 'trivially-copyable' field. */
+
/* We're only interested in things that can have methods. */
if (TYPE_CODE (type) != TYPE_CODE_STRUCT
&& TYPE_CODE (type) != TYPE_CODE_UNION)
- return 0;
+ return info;
/* A dynamic class has a non-trivial copy constructor.
See c++98 section 12.8 Copying class objects [class.copy]. */
if (gnuv3_dynamic_class (type))
- return 1;
+ {
+ info.trivially_copyable = false;
+ return info;
+ }
for (fieldnum = 0; fieldnum < TYPE_NFN_FIELDS (type); fieldnum++)
for (fieldelem = 0; fieldelem < TYPE_FN_FIELDLIST_LENGTH (type, fieldnum);
@@ -1278,7 +1289,10 @@ gnuv3_pass_by_reference (struct type *type)
/* If we've found a destructor, we must pass this by reference. */
if (name[0] == '~')
- return 1;
+ {
+ info.trivially_copyable = false;
+ return info;
+ }
/* If the mangled name of this method doesn't indicate that it
is a constructor, we're not interested.
@@ -1300,11 +1314,13 @@ gnuv3_pass_by_reference (struct type *type)
if (TYPE_CODE (arg_type) == TYPE_CODE_REF)
{
- struct type *arg_target_type;
-
- arg_target_type = check_typedef (TYPE_TARGET_TYPE (arg_type));
+ struct type *arg_target_type
+ = check_typedef (TYPE_TARGET_TYPE (arg_type));
if (class_types_same_p (arg_target_type, type))
- return 1;
+ {
+ info.trivially_copyable = false;
+ return info;
+ }
}
}
}
@@ -1317,11 +1333,18 @@ gnuv3_pass_by_reference (struct type *type)
about recursive loops here, since we are only looking at members
of complete class type. Also ignore any static members. */
for (fieldnum = 0; fieldnum < TYPE_NFIELDS (type); fieldnum++)
- if (! field_is_static (&TYPE_FIELD (type, fieldnum))
- && gnuv3_pass_by_reference (TYPE_FIELD_TYPE (type, fieldnum)))
- return 1;
+ if (!field_is_static (&TYPE_FIELD (type, fieldnum)))
+ {
+ struct language_pass_by_ref_info field_info
+ = gnuv3_pass_by_reference (TYPE_FIELD_TYPE (type, fieldnum));
+ if (!field_info.trivially_copyable)
+ {
+ info.trivially_copyable = false;
+ return info;
+ }
+ }
- return 0;
+ return info;
}
static void
diff --git a/gdb/infcall.c b/gdb/infcall.c
index c102b301e00..058871c369b 100644
--- a/gdb/infcall.c
+++ b/gdb/infcall.c
@@ -970,7 +970,8 @@ call_function_by_hand_dummy (struct value *function,
args[i] = value_arg_coerce (gdbarch, args[i],
param_type, prototyped, &sp);
- if (param_type != NULL && language_pass_by_reference (param_type))
+ if (param_type != NULL
+ && !(language_pass_by_reference (param_type).trivially_copyable))
args[i] = value_addr (args[i]);
}
diff --git a/gdb/language.c b/gdb/language.c
index 954e4c200f0..09ed44e1803 100644
--- a/gdb/language.c
+++ b/gdb/language.c
@@ -650,21 +650,32 @@ language_class_name_from_physname (const struct language_defn *lang,
return NULL;
}
-/* Return non-zero if TYPE should be passed (and returned) by
- reference at the language level. */
-int
+/* Return information about whether TYPE should be passed
+ (and returned) by reference at the language level. */
+
+struct language_pass_by_ref_info
language_pass_by_reference (struct type *type)
{
return current_language->la_pass_by_reference (type);
}
-/* Return zero; by default, types are passed by value at the language
- level. The target ABI may pass or return some structs by reference
- independent of this. */
-int
+/* Return INFO whose 'trivially_copyable' is set to true; by default,
+ types are passed by value at the language level. The target ABI may
+ pass or return some structs by reference independent of this. */
+
+struct language_pass_by_ref_info
default_pass_by_reference (struct type *type)
{
- return 0;
+ struct language_pass_by_ref_info info;
+ info.copy_constructible = true;
+ info.destructible = true;
+ info.trivially_copyable = true;
+ info.trivially_copy_constructible = true;
+ info.trivially_destructible = true;
+ info.cctor_name = NULL;
+ info.dtor_name = NULL;
+
+ return info;
}
/* Return the default string containing the list of characters
diff --git a/gdb/language.h b/gdb/language.h
index 3e0bc9d0d46..40d63dfe8a2 100644
--- a/gdb/language.h
+++ b/gdb/language.h
@@ -128,6 +128,40 @@ struct language_arch_info
struct type *bool_type_default;
};
+/* Pass-by-reference information for a call-by-value argument. */
+
+struct language_pass_by_ref_info
+{
+ /* Name of the copy ctor function. Expected to be fully-qualified. */
+
+ const char *cctor_name;
+
+ /* Name of the destructor function. Expected to be fully-qualified. */
+
+ const char *dtor_name;
+
+ /* Is the type of the argument in question copy-constructible? */
+
+ bool copy_constructible;
+
+ /* Is the type of the argument in question destructible? */
+
+ bool destructible;
+
+ /* Is the argument in question trivially copyable?
+ That is, is it pass-by-value? */
+
+ bool trivially_copyable;
+
+ /* Is the argument in question trivially copy constructible? */
+
+ bool trivially_copy_constructible;
+
+ /* Is the argument in question trivially destructible? */
+
+ bool trivially_destructible;
+};
+
/* Structure tying together assorted information about a language. */
struct language_defn
@@ -356,9 +390,10 @@ struct language_defn
struct ui_file *stream,
const struct value_print_options *options);
- /* Return non-zero if TYPE should be passed (and returned) by
- reference at the language level. */
- int (*la_pass_by_reference) (struct type *type);
+ /* Return information about whether TYPE should be passed
+ (and returned) by reference at the language level. */
+ struct language_pass_by_ref_info (*la_pass_by_reference)
+ (struct type *type);
/* Obtain a string from the inferior, storing it in a newly allocated
buffer in BUFFER, which should be freed by the caller. If the
@@ -612,14 +647,14 @@ extern void default_print_array_index (struct value *index_value,
struct ui_file *stream,
const struct value_print_options *options);
-/* Return non-zero if TYPE should be passed (and returned) by
- reference at the language level. */
-int language_pass_by_reference (struct type *type);
+/* Return information about whether TYPE should be passed
+ (and returned) by reference at the language level. */
+struct language_pass_by_ref_info language_pass_by_reference (struct type *type);
-/* Return zero; by default, types are passed by value at the language
- level. The target ABI may pass or return some structs by reference
- independent of this. */
-int default_pass_by_reference (struct type *type);
+/* Return INFO whose 'trivially_copyable' is set to true; by default,
+ types are passed by value at the language level. The target ABI may
+ pass or return some structs by reference independent of this. */
+struct language_pass_by_ref_info default_pass_by_reference (struct type *type);
/* The default implementation of la_print_typedef. */
void default_print_typedef (struct type *type, struct symbol *new_symbol,
diff --git a/gdb/tic6x-tdep.c b/gdb/tic6x-tdep.c
index 61dc676de3b..73149f492f5 100644
--- a/gdb/tic6x-tdep.c
+++ b/gdb/tic6x-tdep.c
@@ -793,7 +793,7 @@ tic6x_return_value (struct gdbarch *gdbarch, struct value *function,
if (type != NULL)
{
type = check_typedef (type);
- if (language_pass_by_reference (type))
+ if (!(language_pass_by_reference (type).trivially_copyable))
return RETURN_VALUE_STRUCT_CONVENTION;
}
}
--
2.21.0
^ permalink raw reply [flat|nested] 19+ messages in thread
* [PATCH 6/8] infcall: remove unused parameter in 'value_arg_coerce'
2019-04-23 14:32 [PATCH 0/8] Fix inferior call for C++ pass-by-reference arguments Tankut Baris Aktemur
2019-04-23 14:32 ` [PATCH 2/8] infcall, c++: allow more info to be computed for pass-by-reference values Tankut Baris Aktemur
2019-04-23 14:32 ` [PATCH 3/8] infcall, c++: collect more pass-by-reference information Tankut Baris Aktemur
@ 2019-04-23 14:32 ` Tankut Baris Aktemur
2019-04-23 14:32 ` [PATCH 4/8] infcall: refactor 'call_function_by_hand_dummy' Tankut Baris Aktemur
` (6 subsequent siblings)
9 siblings, 0 replies; 19+ messages in thread
From: Tankut Baris Aktemur @ 2019-04-23 14:32 UTC (permalink / raw)
To: gdb-patches
Remove the unused SP parameter from the auxiliary function
'value_arg_coerce'.
gdb/ChangeLog:
* infcall.c (value_arg_coerce): Remove an unused parameter.
(call_function_by_hand_dummy): Update.
---
gdb/infcall.c | 8 +++-----
1 file changed, 3 insertions(+), 5 deletions(-)
diff --git a/gdb/infcall.c b/gdb/infcall.c
index e562790bd0d..bd88076dc7f 100644
--- a/gdb/infcall.c
+++ b/gdb/infcall.c
@@ -134,13 +134,11 @@ show_unwind_on_terminating_exception_p (struct ui_file *file, int from_tty,
for arguments to be passed to C, Ada or Fortran functions.
If PARAM_TYPE is non-NULL, it is the expected parameter type.
- IS_PROTOTYPED is non-zero if the function declaration is prototyped.
- SP is the stack pointer were additional data can be pushed (updating
- its value as needed). */
+ IS_PROTOTYPED is non-zero if the function declaration is prototyped. */
static struct value *
value_arg_coerce (struct gdbarch *gdbarch, struct value *arg,
- struct type *param_type, int is_prototyped, CORE_ADDR *sp)
+ struct type *param_type, int is_prototyped)
{
const struct builtin_type *builtin = builtin_type (gdbarch);
struct type *arg_type = check_typedef (value_type (arg));
@@ -1005,7 +1003,7 @@ call_function_by_hand_dummy (struct value *function,
param_type = NULL;
args[i] = value_arg_coerce (gdbarch, args[i],
- param_type, prototyped, &sp);
+ param_type, prototyped);
if (param_type != NULL
&& !(language_pass_by_reference (param_type).trivially_copyable))
--
2.21.0
^ permalink raw reply [flat|nested] 19+ messages in thread
* [PATCH 3/8] infcall, c++: collect more pass-by-reference information
2019-04-23 14:32 [PATCH 0/8] Fix inferior call for C++ pass-by-reference arguments Tankut Baris Aktemur
2019-04-23 14:32 ` [PATCH 2/8] infcall, c++: allow more info to be computed for pass-by-reference values Tankut Baris Aktemur
@ 2019-04-23 14:32 ` Tankut Baris Aktemur
2019-05-22 20:34 ` Andrew Burgess
2019-04-23 14:32 ` [PATCH 6/8] infcall: remove unused parameter in 'value_arg_coerce' Tankut Baris Aktemur
` (7 subsequent siblings)
9 siblings, 1 reply; 19+ messages in thread
From: Tankut Baris Aktemur @ 2019-04-23 14:32 UTC (permalink / raw)
To: gdb-patches
Walk through a given type to collect information about whether the type
is copy constructible, destructible, trivially copyable, trivially copy
constructible, trivially destructible. The previous algorithm returned
only a boolean result about whether the type is trivially copyable.
This patch computes more info. Additionally, it utilizes DWARF attributes
that were previously not taken into account; namely,
DW_AT_deleted, DW_AT_defaulted, and DW_AT_calling_convention.
gdb/ChangeLog:
* gnu-v3-abi.c (enum definition_style): New.
(get_def_style): New.
(is_user_provided_def): New.
(is_implicit_def): New.
(is_copy_or_move_constructor_type): New.
(is_copy_constructor_type): New.
(is_move_constructor_type): New.
(gnuv3_pass_by_reference): Update.
---
gdb/gnu-v3-abi.c | 259 +++++++++++++++++++++++++++++++++++++----------
1 file changed, 208 insertions(+), 51 deletions(-)
diff --git a/gdb/gnu-v3-abi.c b/gdb/gnu-v3-abi.c
index b39e5a5c585..9069305626f 100644
--- a/gdb/gnu-v3-abi.c
+++ b/gdb/gnu-v3-abi.c
@@ -23,6 +23,7 @@
#include "cp-abi.h"
#include "cp-support.h"
#include "demangle.h"
+#include "dwarf2.h"
#include "objfiles.h"
#include "valprint.h"
#include "c-lang.h"
@@ -1228,6 +1229,122 @@ gnuv3_skip_trampoline (struct frame_info *frame, CORE_ADDR stop_pc)
return real_stop_pc;
}
+/* A member function is in one these states. */
+
+enum definition_style
+{
+ DOES_NOT_EXIST_IN_SOURCE,
+ DEFAULTED_INSIDE,
+ DEFAULTED_OUTSIDE,
+ DELETED,
+ EXPLICIT,
+};
+
+/* Return how the given field is defined. */
+
+static definition_style
+get_def_style (struct fn_field *fn, int fieldelem)
+{
+ if (TYPE_FN_FIELD_DELETED (fn, fieldelem))
+ return DELETED;
+
+ if (TYPE_FN_FIELD_ARTIFICIAL (fn, fieldelem))
+ return DOES_NOT_EXIST_IN_SOURCE;
+
+ switch (TYPE_FN_FIELD_DEFAULTED (fn, fieldelem))
+ {
+ case DW_DEFAULTED_no:
+ return EXPLICIT;
+ case DW_DEFAULTED_in_class:
+ return DEFAULTED_INSIDE;
+ case DW_DEFAULTED_out_of_class:
+ return DEFAULTED_OUTSIDE;
+ default:
+ break;
+ }
+
+ return EXPLICIT;
+}
+
+/* Helper functions to determine whether the given definition style
+ denotes that the definition is user-provided or implicit.
+ Being defaulted outside the class decl counts as an explicit
+ user-definition, while being defaulted inside is implicit. */
+
+static bool
+is_user_provided_def (definition_style def)
+{
+ return def == EXPLICIT || def == DEFAULTED_OUTSIDE;
+}
+
+static bool
+is_implicit_def (definition_style def)
+{
+ return def == DOES_NOT_EXIST_IN_SOURCE || def == DEFAULTED_INSIDE;
+}
+
+/* Helper function to decide if METHOD_TYPE is a copy/move
+ constructor type for CLASS_TYPE. EXPECTED is the expected
+ type code for the "right-hand-side" argument.
+ This function is supposed to be used by the IS_COPY_CONSTRUCTOR_TYPE
+ and IS_MOVE_CONSTRUCTOR_TYPE functions below. Normally, you should
+ not need to call this directly. */
+
+static bool
+is_copy_or_move_constructor_type (struct type *class_type,
+ struct type *method_type,
+ type_code expected)
+{
+ /* The method should take at least two arguments... */
+ if (TYPE_NFIELDS (method_type) < 2)
+ return false;
+
+ /* ...and the second argument should be the same as the class
+ type, with the expected type code... */
+ struct type *arg_type = TYPE_FIELD_TYPE (method_type, 1);
+
+ if (TYPE_CODE (arg_type) != expected)
+ return false;
+
+ struct type *target = check_typedef (TYPE_TARGET_TYPE (arg_type));
+ if (!(class_types_same_p (target, class_type)))
+ return false;
+
+ /* ...and the rest of the arguments should have default values. */
+ for (int i = 2; i < TYPE_NFIELDS (method_type); i++)
+ {
+ arg_type = TYPE_FIELD_TYPE (method_type, i);
+ /* FIXME taktemur/2019-04-23: As of this date, neither
+ clang++-7.0.0 nor g++-8.2.0 produce a DW_AT_default_value
+ attribute. GDB is also not set to read this attribute, yet.
+ Hence, we immediately return false if there are more than
+ 2 parameters. */
+ return false;
+ }
+
+ return true;
+}
+
+/* Return true if METHOD_TYPE is a copy ctor type for CLASS_TYPE. */
+
+static bool
+is_copy_constructor_type (struct type *class_type,
+ struct type *method_type)
+{
+ return is_copy_or_move_constructor_type (class_type, method_type,
+ TYPE_CODE_REF);
+}
+
+/* Return true if METHOD_TYPE is a move ctor type for CLASS_TYPE. */
+
+static bool
+is_move_constructor_type (struct type *class_type,
+ struct type *method_type)
+{
+ return is_copy_or_move_constructor_type (class_type, method_type,
+ TYPE_CODE_RVALUE_REF);
+}
+
/* Return pass-by-reference information for the given TYPE.
The rule in the v3 ABI document comes from section 3.1.1. If the
@@ -1236,16 +1353,15 @@ gnuv3_skip_trampoline (struct frame_info *frame, CORE_ADDR stop_pc)
is one or perform the copy itself otherwise), pass the address of
the copy, and then destroy the temporary (if necessary).
- For return values with non-trivial copy constructors or
+ For return values with non-trivial copy/move constructors or
destructors, space will be allocated in the caller, and a pointer
will be passed as the first argument (preceding "this").
We don't have a bulletproof mechanism for determining whether a
- constructor or destructor is trivial. For GCC and DWARF2 debug
- information, we can check the artificial flag.
-
- We don't do anything with the constructors or destructors,
- but we have to get the argument passing right anyway. */
+ constructor or destructor is trivial. For GCC and DWARF5 debug
+ information, we can check the calling_convention attribute,
+ the 'artificial' flag, the 'defaulted' attribute, and the
+ 'deleted' attribute. */
static struct language_pass_by_ref_info
gnuv3_pass_by_reference (struct type *type)
@@ -1258,22 +1374,39 @@ gnuv3_pass_by_reference (struct type *type)
struct language_pass_by_ref_info info
= default_pass_by_reference (type);
- /* FIXME: Currently, this implementation only fills in the
- 'trivially-copyable' field. */
+ bool has_cc_attr = false;
+ bool is_pass_by_value = false;
+ bool is_dynamic = false;
+ definition_style cctor_def = DOES_NOT_EXIST_IN_SOURCE;
+ definition_style dtor_def = DOES_NOT_EXIST_IN_SOURCE;
+ definition_style mctor_def = DOES_NOT_EXIST_IN_SOURCE;
/* We're only interested in things that can have methods. */
if (TYPE_CODE (type) != TYPE_CODE_STRUCT
&& TYPE_CODE (type) != TYPE_CODE_UNION)
return info;
+ /* The compiler may have emitted the calling convention attribute. */
+ if (TYPE_CPLUS_CALLING_CONVENTION (type) == DW_CC_pass_by_value)
+ {
+ has_cc_attr = true;
+ is_pass_by_value = true;
+ /* Do not return immediately. We have to find out if this type
+ is copy_constructible and destructible. */
+ }
+
+ if (TYPE_CPLUS_CALLING_CONVENTION (type) == DW_CC_pass_by_reference)
+ {
+ has_cc_attr = true;
+ is_pass_by_value = false;
+ }
+
/* A dynamic class has a non-trivial copy constructor.
See c++98 section 12.8 Copying class objects [class.copy]. */
if (gnuv3_dynamic_class (type))
- {
- info.trivially_copyable = false;
- return info;
- }
+ is_dynamic = true;
+ /* FIXME taktemur/2019-04-23: What if there are multiple cctors? */
for (fieldnum = 0; fieldnum < TYPE_NFN_FIELDS (type); fieldnum++)
for (fieldelem = 0; fieldelem < TYPE_FN_FIELDLIST_LENGTH (type, fieldnum);
fieldelem++)
@@ -1282,49 +1415,53 @@ gnuv3_pass_by_reference (struct type *type)
const char *name = TYPE_FN_FIELDLIST_NAME (type, fieldnum);
struct type *fieldtype = TYPE_FN_FIELD_TYPE (fn, fieldelem);
- /* If this function is marked as artificial, it is compiler-generated,
- and we assume it is trivial. */
- if (TYPE_FN_FIELD_ARTIFICIAL (fn, fieldelem))
- continue;
-
- /* If we've found a destructor, we must pass this by reference. */
if (name[0] == '~')
{
- info.trivially_copyable = false;
- return info;
+ /* We've found a destructor. */
+ dtor_def = get_def_style (fn, fieldelem);
+ info.dtor_name = TYPE_FN_FIELD_PHYSNAME (fn, fieldelem);
}
-
- /* If the mangled name of this method doesn't indicate that it
- is a constructor, we're not interested.
-
- FIXME drow/2007-09-23: We could do this using the name of
- the method and the name of the class instead of dealing
- with the mangled name. We don't have a convenient function
- to strip off both leading scope qualifiers and trailing
- template arguments yet. */
- if (!is_constructor_name (TYPE_FN_FIELD_PHYSNAME (fn, fieldelem))
- && !TYPE_FN_FIELD_CONSTRUCTOR (fn, fieldelem))
- continue;
-
- /* If this method takes two arguments, and the second argument is
- a reference to this class, then it is a copy constructor. */
- if (TYPE_NFIELDS (fieldtype) == 2)
+ else if (is_constructor_name (TYPE_FN_FIELD_PHYSNAME (fn, fieldelem))
+ || TYPE_FN_FIELD_CONSTRUCTOR (fn, fieldelem))
{
- struct type *arg_type = TYPE_FIELD_TYPE (fieldtype, 1);
-
- if (TYPE_CODE (arg_type) == TYPE_CODE_REF)
+ /* FIXME drow/2007-09-23: We could do this using the name of
+ the method and the name of the class instead of dealing
+ with the mangled name. We don't have a convenient function
+ to strip off both leading scope qualifiers and trailing
+ template arguments yet. */
+ if (is_copy_constructor_type (type, fieldtype))
{
- struct type *arg_target_type
- = check_typedef (TYPE_TARGET_TYPE (arg_type));
- if (class_types_same_p (arg_target_type, type))
- {
- info.trivially_copyable = false;
- return info;
- }
+ cctor_def = get_def_style (fn, fieldelem);
+ info.cctor_name = TYPE_FN_FIELD_PHYSNAME (fn, fieldelem);
}
+ else if (is_move_constructor_type (type, fieldtype))
+ mctor_def = get_def_style (fn, fieldelem);
}
}
+ bool cctor_implicitly_deleted
+ = mctor_def != DOES_NOT_EXIST_IN_SOURCE
+ && cctor_def == DOES_NOT_EXIST_IN_SOURCE;
+
+ bool cctor_explicitly_deleted = cctor_def == DELETED;
+
+ if (cctor_implicitly_deleted || cctor_explicitly_deleted)
+ info.copy_constructible = false;
+
+ if (dtor_def == DELETED)
+ info.destructible = false;
+
+ info.trivially_destructible = is_implicit_def (dtor_def);
+
+ info.trivially_copy_constructible
+ = is_implicit_def (cctor_def)
+ && !is_dynamic;
+
+ info.trivially_copyable
+ = info.trivially_copy_constructible
+ && info.trivially_destructible
+ && !is_user_provided_def (mctor_def);
+
/* Even if all the constructors and destructors were artificial, one
of them may have invoked a non-artificial constructor or
destructor in a base class. If any base class needs to be passed
@@ -1335,15 +1472,35 @@ gnuv3_pass_by_reference (struct type *type)
for (fieldnum = 0; fieldnum < TYPE_NFIELDS (type); fieldnum++)
if (!field_is_static (&TYPE_FIELD (type, fieldnum)))
{
+ struct type *field_type = TYPE_FIELD_TYPE (type, fieldnum);
+
+ /* For arrays, make the decision based on the element type. */
+ if (TYPE_CODE (field_type) == TYPE_CODE_ARRAY)
+ field_type = field_type->main_type->target_type;
+
struct language_pass_by_ref_info field_info
- = gnuv3_pass_by_reference (TYPE_FIELD_TYPE (type, fieldnum));
+ = gnuv3_pass_by_reference (field_type);
+
+ if (!field_info.copy_constructible)
+ info.copy_constructible = false;
+ if (!field_info.destructible)
+ info.destructible = false;
if (!field_info.trivially_copyable)
- {
- info.trivially_copyable = false;
- return info;
- }
+ info.trivially_copyable = false;
+ if (!field_info.trivially_copy_constructible)
+ info.trivially_copy_constructible = false;
+ if (!field_info.trivially_destructible)
+ info.trivially_destructible = false;
}
+ /* Consistency check. */
+ if (has_cc_attr && info.trivially_copyable != is_pass_by_value)
+ {
+ /* DWARF CC attribute is not the same as the inferred value;
+ using the DWARF attribute. */
+ info.trivially_copyable = is_pass_by_value;
+ }
+
return info;
}
--
2.21.0
^ permalink raw reply [flat|nested] 19+ messages in thread
* [PATCH 0/8] Fix inferior call for C++ pass-by-reference arguments
@ 2019-04-23 14:32 Tankut Baris Aktemur
2019-04-23 14:32 ` [PATCH 2/8] infcall, c++: allow more info to be computed for pass-by-reference values Tankut Baris Aktemur
` (9 more replies)
0 siblings, 10 replies; 19+ messages in thread
From: Tankut Baris Aktemur @ 2019-04-23 14:32 UTC (permalink / raw)
To: gdb-patches
Dear All,
This is a set of patches to fix GDB's conformance to C++ ABI when
invoking functions that have call-by-value arguments of aggregate
types that should be implicitly passed by reference.
To give some background information first, suppose we have a class 'K'
and a function 'cbv' that has a call-by-value parameter of type 'K'.
class K {
public:
K (const K &other) { ... }
~K (void) { ... }
...
};
int
cbv (K k)
{
... use k ...
}
int
main (void)
{
K q1;
...
cbv (q1);
...
}
When making a function call such as 'cbv(q1)', the caller needs to
create a (temporary) copy of the argument 'q1', say 'q2', and pass
'q2' to 'cbv' as the argument. After the function call returns, the
caller can discard 'q2'. However, because the type 'K' has a
user-defined constructor and destructor, the caller cannot simply copy
the contents of 'q1' to 'q2'; it has to initialize 'q2' via the copy
constructor. Similarly, 'q2' has to be destroyed by invoking the
user-defined destructor. For this reason, according to the C++ ABI,
the caller first allocates a space for 'q2', initializes it using the
copy constructor, and then passes the *address* of 'q2' to 'cbv'. The
caller uses the same address to destruct 'q2' after the function call
is complete. Although 'k' is declared as a call-by-value parameter,
it is implicitly *pass-by-reference*.
Had the type 'K' not have a user-defined copy constructor or a
destructor, the caller could have cloned 'q1' to 'q2' by a
straightforward memory copying operation. Such types are trivially
copyable. In that case, 'K' would be a *pass-by-value* type.
Present-day GDB has problems regarding pass-by-reference arguments
when making inferior calls. In particular:
- Relatively new DWARF attributes are not used for inferring whether
a type is pass-by-reference or not. This leads to incorrect
deductions and, in return, crashing inferior calls.
- For a pass-by-reference argument, a copy of the argument is not
made; the address of the argument itself is passed to the callee.
Hence, no copy-constructor call or a destructor call takes place,
as well.
The proposed patch aims to fix these problems. Tested on the X86_64
architecture with GCC 7.4.0 and 8.2.0. ChangeLog entries will be
included in the patch when/if the patch is accepted.
Best regards.
Tankut Baris Aktemur (8):
gdb: recognize new DWARF attributes: defaulted, deleted, calling conv.
infcall, c++: allow more info to be computed for pass-by-reference
values
infcall, c++: collect more pass-by-reference information
infcall: refactor 'call_function_by_hand_dummy'
infcall: move assertions in 'call_function_by_hand_dummy' to an
earlier spot
infcall: remove unused parameter in 'value_arg_coerce'
infcall: handle pass-by-reference arguments appropriately
testsuite, cp: increase the coverage of testing pass-by-ref arguments
gdb/arch-utils.c | 2 +-
gdb/cp-abi.c | 6 +-
gdb/cp-abi.h | 10 +-
gdb/dwarf2read.c | 20 +
gdb/gdbtypes.c | 7 +
gdb/gdbtypes.h | 19 +-
gdb/gnu-v3-abi.c | 268 +-
gdb/infcall.c | 213 +-
gdb/language.c | 27 +-
gdb/language.h | 55 +-
gdb/testsuite/gdb.cp/pass-by-ref-2.cc | 179 +
gdb/testsuite/gdb.cp/pass-by-ref-2.exp | 85 +
gdb/testsuite/gdb.cp/pass-by-ref.cc | 7368 +++++++++++++++++++++++-
gdb/testsuite/gdb.cp/pass-by-ref.exp | 412 +-
gdb/tic6x-tdep.c | 2 +-
15 files changed, 8514 insertions(+), 159 deletions(-)
create mode 100644 gdb/testsuite/gdb.cp/pass-by-ref-2.cc
create mode 100644 gdb/testsuite/gdb.cp/pass-by-ref-2.exp
--
2.21.0
^ permalink raw reply [flat|nested] 19+ messages in thread
* [PATCH 4/8] infcall: refactor 'call_function_by_hand_dummy'
2019-04-23 14:32 [PATCH 0/8] Fix inferior call for C++ pass-by-reference arguments Tankut Baris Aktemur
` (2 preceding siblings ...)
2019-04-23 14:32 ` [PATCH 6/8] infcall: remove unused parameter in 'value_arg_coerce' Tankut Baris Aktemur
@ 2019-04-23 14:32 ` Tankut Baris Aktemur
2019-04-23 14:32 ` [PATCH 1/8] gdb: recognize new DWARF attributes: defaulted, deleted, calling conv Tankut Baris Aktemur
` (5 subsequent siblings)
9 siblings, 0 replies; 19+ messages in thread
From: Tankut Baris Aktemur @ 2019-04-23 14:32 UTC (permalink / raw)
To: gdb-patches
Extract out the code region that reserves stack space to a separate
function.
Fix the comment of 'call_function_by_hand_dummy' to remove reference
to the NARGS arguments that was removed in this commit:
e71585ffe2e1394858f0fcf809e86f1b324fe4e6
gdb/ChangeLog:
* infcall.c (call_function_by_hand_dummy): Refactor.
(reserve_stack_space): New.
---
gdb/infcall.c | 64 +++++++++++++++++++++++++++++++--------------------
1 file changed, 39 insertions(+), 25 deletions(-)
diff --git a/gdb/infcall.c b/gdb/infcall.c
index 058871c369b..fd0fef185d5 100644
--- a/gdb/infcall.c
+++ b/gdb/infcall.c
@@ -659,6 +659,42 @@ run_inferior_call (struct call_thread_fsm *sm,
return caught_error;
}
+/* Reserve space on the stack for a value of the given type.
+ Return the address of the allocated space.
+ Make certain that the value is correctly aligned.
+ The SP argument is modified. */
+
+static CORE_ADDR
+reserve_stack_space (const type *values_type, CORE_ADDR &sp)
+{
+ struct frame_info *frame = get_current_frame ();
+ struct gdbarch *gdbarch = get_frame_arch (frame);
+ CORE_ADDR addr = 0;
+
+ if (gdbarch_inner_than (gdbarch, 1, 2))
+ {
+ /* Stack grows downward. Align STRUCT_ADDR and SP after
+ making space. */
+ sp -= TYPE_LENGTH (values_type);
+ if (gdbarch_frame_align_p (gdbarch))
+ sp = gdbarch_frame_align (gdbarch, sp);
+ addr = sp;
+ }
+ else
+ {
+ /* Stack grows upward. Align the frame, allocate space, and
+ then again, re-align the frame??? */
+ if (gdbarch_frame_align_p (gdbarch))
+ sp = gdbarch_frame_align (gdbarch, sp);
+ addr = sp;
+ sp += TYPE_LENGTH (values_type);
+ if (gdbarch_frame_align_p (gdbarch))
+ sp = gdbarch_frame_align (gdbarch, sp);
+ }
+
+ return addr;
+}
+
/* See infcall.h. */
struct value *
@@ -680,7 +716,7 @@ call_function_by_hand (struct value *function,
making dummy frames be different from normal frames, consider that. */
/* Perform a function call in the inferior.
- ARGS is a vector of values of arguments (NARGS of them).
+ ARGS is a vector of values of arguments.
FUNCTION is a value, the function to be called.
Returns a value representing what the function returned.
May fail to return, if a breakpoint or signal is hit
@@ -976,8 +1012,7 @@ call_function_by_hand_dummy (struct value *function,
}
/* Reserve space for the return structure to be written on the
- stack, if necessary. Make certain that the value is correctly
- aligned.
+ stack, if necessary.
While evaluating expressions, we reserve space on the stack for
return values of class type even if the language ABI and the target
@@ -992,28 +1027,7 @@ call_function_by_hand_dummy (struct value *function,
if (return_method != return_method_normal
|| (stack_temporaries && class_or_union_p (values_type)))
- {
- if (gdbarch_inner_than (gdbarch, 1, 2))
- {
- /* Stack grows downward. Align STRUCT_ADDR and SP after
- making space for the return value. */
- sp -= TYPE_LENGTH (values_type);
- if (gdbarch_frame_align_p (gdbarch))
- sp = gdbarch_frame_align (gdbarch, sp);
- struct_addr = sp;
- }
- else
- {
- /* Stack grows upward. Align the frame, allocate space, and
- then again, re-align the frame??? */
- if (gdbarch_frame_align_p (gdbarch))
- sp = gdbarch_frame_align (gdbarch, sp);
- struct_addr = sp;
- sp += TYPE_LENGTH (values_type);
- if (gdbarch_frame_align_p (gdbarch))
- sp = gdbarch_frame_align (gdbarch, sp);
- }
- }
+ struct_addr = reserve_stack_space (values_type, sp);
std::vector<struct value *> new_args;
if (return_method == return_method_hidden_param)
--
2.21.0
^ permalink raw reply [flat|nested] 19+ messages in thread
* [PATCH 8/8] testsuite, cp: increase the coverage of testing pass-by-ref arguments
2019-04-23 14:32 [PATCH 0/8] Fix inferior call for C++ pass-by-reference arguments Tankut Baris Aktemur
` (6 preceding siblings ...)
2019-04-23 14:33 ` [PATCH 5/8] infcall: move assertions in 'call_function_by_hand_dummy' to an earlier spot Tankut Baris Aktemur
@ 2019-04-23 14:33 ` Tankut Baris Aktemur
2019-05-08 10:50 ` [PATCH 0/8] Fix inferior call for C++ pass-by-reference arguments Aktemur, Tankut Baris
2019-05-21 10:33 ` [PING][PATCH " Tankut Baris Aktemur
9 siblings, 0 replies; 19+ messages in thread
From: Tankut Baris Aktemur @ 2019-04-23 14:33 UTC (permalink / raw)
To: gdb-patches
Extend testcases for GDB's infcall of call-by-value functions that take
aggregate values as parameters. In particular, existing test has been
substantially extended with class definitions whose definitions of
copy constructor, destructor, and move constructor functions
are a combination of
(1) explicitly defined by the user,
(2) defaulted inside the class declaration,
(3) defaulted outside the class declaration,
(4) deleted
(5) not defined in the source.
For each combination, a small and a large class is generated
as well as a derived class and a container class. Additionally,
the following manually-written cases are provided:
- a dynamic class (i.e. class with a virtual method)
- classes that contain an array field
- a class whose copy ctor is inlined
- a class whose destructor is deleted
Test cases check whether GDB makes the right decision to pass an object
by value or implicitly by reference, whether really a copy of the
argument is passed, and whether the copy constructor and destructor
of the clone of the argument are invoked properly.
The input program pass-by-ref.cc is generated. By means of a flag
inside the test file, the program can be re-generated.
The input program pass-by-ref-2.cc is manually-written.
Tests have been verified on the X86_64 architecture with
GCC 7.4.0 and 8.2.0.
gdb/testsuite/ChangeLog:
* gdb.cp/pass-by-ref.cc: Extend with more cases (generated).
* gdb.cp/pass-by-ref.exp: Extend with more cases.
* gdb.cp/pass-by-ref-2.cc: New file.
* gdb.cp/pass-by-ref-2.exp: New file.
---
gdb/testsuite/gdb.cp/pass-by-ref-2.cc | 179 +
gdb/testsuite/gdb.cp/pass-by-ref-2.exp | 85 +
gdb/testsuite/gdb.cp/pass-by-ref.cc | 7368 +++++++++++++++++++++++-
gdb/testsuite/gdb.cp/pass-by-ref.exp | 412 +-
4 files changed, 8007 insertions(+), 37 deletions(-)
create mode 100644 gdb/testsuite/gdb.cp/pass-by-ref-2.cc
create mode 100644 gdb/testsuite/gdb.cp/pass-by-ref-2.exp
diff --git a/gdb/testsuite/gdb.cp/pass-by-ref-2.cc b/gdb/testsuite/gdb.cp/pass-by-ref-2.cc
new file mode 100644
index 00000000000..20b055ce08a
--- /dev/null
+++ b/gdb/testsuite/gdb.cp/pass-by-ref-2.cc
@@ -0,0 +1,179 @@
+/* This testcase is part of GDB, the GNU debugger.
+
+ Copyright 2019 Free Software Foundation, Inc.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>. */
+
+class ByVal {
+public:
+ ByVal (void);
+
+ int x;
+};
+
+ByVal::ByVal (void)
+{
+ x = 2;
+}
+
+class ByRef {
+public:
+ ByRef (void);
+
+ ByRef (const ByRef &rhs);
+
+ int x;
+};
+
+ByRef::ByRef (void)
+{
+ x = 2;
+}
+
+ByRef::ByRef (const ByRef &rhs)
+{
+ x = 3; /* ByRef-cctor */
+}
+
+class ArrayContainerByVal {
+public:
+ ByVal items[2];
+};
+
+int
+cbvArrayContainerByVal (ArrayContainerByVal arg)
+{
+ arg.items[0].x += 4; // intentionally modify
+ return arg.items[0].x;
+}
+
+class ArrayContainerByRef {
+public:
+ ByRef items[2];
+};
+
+int
+cbvArrayContainerByRef (ArrayContainerByRef arg)
+{
+ arg.items[0].x += 4; // intentionally modify
+ return arg.items[0].x;
+}
+
+class DynamicBase {
+public:
+ DynamicBase (void);
+
+ virtual int get (void);
+
+ int x;
+};
+
+DynamicBase::DynamicBase (void)
+{
+ x = 2;
+}
+
+int
+DynamicBase::get (void)
+{
+ return 42;
+}
+
+class Dynamic : public DynamicBase {
+public:
+ virtual int get (void);
+};
+
+int
+Dynamic::get (void)
+{
+ return 9999;
+}
+
+int
+cbvDynamic (DynamicBase arg)
+{
+ arg.x += 4; // intentionally modify
+ return arg.x + arg.get ();
+}
+
+class Inlined {
+public:
+ Inlined (void);
+
+ __attribute__((always_inline))
+ Inlined (const Inlined &rhs)
+ {
+ x = 3;
+ }
+
+ int x;
+};
+
+Inlined::Inlined (void)
+{
+ x = 2;
+}
+
+int
+cbvInlined (Inlined arg)
+{
+ arg.x += 4; // intentionally modify
+ return arg.x;
+}
+
+class DtorDel {
+public:
+ DtorDel (void);
+
+ ~DtorDel (void) = delete;
+
+ int x;
+};
+
+DtorDel::DtorDel (void)
+{
+ x = 2;
+}
+
+int
+cbvDtorDel (DtorDel arg)
+{
+ // Calling this method should be rejected
+ return arg.x;
+}
+
+ArrayContainerByVal arrayContainerByVal;
+ArrayContainerByRef arrayContainerByRef;
+Dynamic dynamic;
+Inlined inlined;
+// Cannot stack-allocate DtorDel
+DtorDel *dtorDel;
+
+int
+main (void)
+{
+ int v;
+ dtorDel = new DtorDel;
+ /* Explicitly call the cbv function to make sure the compiler
+ will not omit any code in the binary. */
+ v = cbvArrayContainerByVal (arrayContainerByVal);
+ v = cbvArrayContainerByRef (arrayContainerByRef);
+ v = cbvDynamic (dynamic);
+ v = cbvInlined (inlined);
+
+ /* stop here */
+
+ return 0;
+}
diff --git a/gdb/testsuite/gdb.cp/pass-by-ref-2.exp b/gdb/testsuite/gdb.cp/pass-by-ref-2.exp
new file mode 100644
index 00000000000..b02b0d9786a
--- /dev/null
+++ b/gdb/testsuite/gdb.cp/pass-by-ref-2.exp
@@ -0,0 +1,85 @@
+# Copyright 2019 Free Software Foundation, Inc.
+
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+# Check that GDB can call C++ functions whose parameters have
+# object type, and are either passed by value or implicitly by reference.
+#
+# This is a companion test to pass-by-ref.exp. In this test, the input
+# is manually-written. In pass-by-ref.exp, the test input is generated.
+#
+# We include tests for classes that
+# - contain arrays as fields,
+# - are dynamic (i.e. have virtual methods)
+# - have inlined copy ctor
+# - have deleted destructor
+
+if {[skip_cplus_tests]} {
+ untested "c++ test skipped"
+ continue
+}
+
+standard_testfile .cc
+
+set options {debug c++ additional_flags=-std=c++11}
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile $options]} {
+ return -1
+}
+
+if {![runto_main]} {
+ untested "failed to run to main"
+ return -1
+}
+
+set bp_location [gdb_get_line_number "stop here"]
+gdb_breakpoint $bp_location
+gdb_continue_to_breakpoint "end of main" ".*return .*;"
+
+gdb_test "print cbvArrayContainerByVal (arrayContainerByVal)" " = 6" \
+ "call cbvArrayContainerByVal"
+gdb_test "print arrayContainerByVal.items\[0\].x" " = 2" \
+ "cbv argument 'arrayContainerByVal' should not change"
+
+gdb_test "print cbvArrayContainerByRef (arrayContainerByRef)" " = 7" \
+ "call cbvArrayContainerByRef"
+gdb_test "print arrayContainerByRef.items\[0\].x" " = 2" \
+ "cbv argument 'arrayContainerByRef' should not change"
+
+gdb_test "print cbvDynamic (dynamic)" " = 48" \
+ "call cbvDynamic"
+gdb_test "print dynamic.x" " = 2" \
+ "cbv argument 'dynamic' should not change"
+
+set sig "\"Inlined\:\:Inlined\\(.*Inlined const\&\\)\""
+gdb_test "print cbvInlined (inlined)" \
+ "evaluation .* requires .* function $sig." \
+ "copy constructor not available"
+
+gdb_test "print cbvDtorDel (*dtorDel)" \
+ ".* cannot be evaluated .* 'DtorDel' is not destructible" \
+ "type not destructible"
+
+# Test that we get a breakpoint from the cctor during infcall and
+# we can examine arguments. This is a test that the dummy frame
+# of the copy constructor is set up correctly by the infcall mechanism.
+set bp_location [gdb_get_line_number "ByRef-cctor"]
+gdb_breakpoint $bp_location
+gdb_test "print cbvArrayContainerByRef (arrayContainerByRef)" \
+ ".*The program being debugged stopped.*" \
+ "call cbvArrayContainerByRef with BP"
+gdb_test "backtrace" [multi_line \
+ "#0 ByRef\:\:ByRef .* at .*$srcfile:$bp_location" \
+ "#1 .* ArrayContainerByRef::ArrayContainerByRef .*" \
+ "#2 <function called from gdb>" \
+ "#3 main.*"]
diff --git a/gdb/testsuite/gdb.cp/pass-by-ref.cc b/gdb/testsuite/gdb.cp/pass-by-ref.cc
index bbe450a0f71..efad178d574 100644
--- a/gdb/testsuite/gdb.cp/pass-by-ref.cc
+++ b/gdb/testsuite/gdb.cp/pass-by-ref.cc
@@ -15,65 +15,7373 @@
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>. */
-class Obj {
+/*** THIS FILE IS GENERATED BY THE TEST. ***/
+/* If you regenerate, auto-indent and delete-trailing-whitespace
+ before committing. */
+
+static int tracer = 0;
+
+/* The call-by-value function. */
+template <class T>
+int
+cbv (T arg)
+{
+ arg.data[0] += 4; // intentionally modify the arg
+ return arg.data[0];
+}
+
+template <class T>
+int
+cbv_container (T arg)
+{
+ arg.item.data[0] += 4; // intentionally modify
+ return arg.item.data[0];
+}
+
+
+/*** C++ class Small_absent_absent_absent ***/
+class Small_absent_absent_absent {
+public:
+ Small_absent_absent_absent (void);
+
+
+ int data[2];
+};
+
+Small_absent_absent_absent::Small_absent_absent_absent (void)
+{
+ data[0] = 2;
+ data[1] = 2;
+}
+
+
+
+Small_absent_absent_absent Small_absent_absent_absent_var; /* global var */
+
+template int cbv<Small_absent_absent_absent> (Small_absent_absent_absent arg);
+/*** C++ class Large_absent_absent_absent ***/
+class Large_absent_absent_absent {
+public:
+ Large_absent_absent_absent (void);
+
+
+ int data[150];
+};
+
+Large_absent_absent_absent::Large_absent_absent_absent (void)
+{
+ data[0] = 2;
+ data[149] = 2;
+}
+
+
+
+Large_absent_absent_absent Large_absent_absent_absent_var; /* global var */
+
+template int cbv<Large_absent_absent_absent> (Large_absent_absent_absent arg);
+/*** Class derived from Small_absent_absent_absent ***/
+class Derived_absent_absent_absent : public Small_absent_absent_absent {
+public:
+};
+
+Derived_absent_absent_absent Derived_absent_absent_absent_var; /* global var */
+
+template int cbv<Derived_absent_absent_absent> (Derived_absent_absent_absent arg);
+/*** Class that contains Small_absent_absent_absent ***/
+class Container_absent_absent_absent {
+public:
+ Small_absent_absent_absent item;
+};
+
+Container_absent_absent_absent Container_absent_absent_absent_var; /* global var */
+
+template int cbv_container<Container_absent_absent_absent> (Container_absent_absent_absent arg);
+/*** C++ class Small_absent_absent_explicit ***/
+class Small_absent_absent_explicit {
+public:
+ Small_absent_absent_explicit (void);
+ Small_absent_absent_explicit (Small_absent_absent_explicit &&rhs);
+
+
+ int data[2];
+};
+
+Small_absent_absent_explicit::Small_absent_absent_explicit (void)
+{
+ data[0] = 2;
+ data[1] = 2;
+}
+
+Small_absent_absent_explicit::Small_absent_absent_explicit (Small_absent_absent_explicit &&rhs)
+{
+ data[0] = 3;
+ data[1] = 3;
+ tracer = 5;
+}
+
+
+Small_absent_absent_explicit Small_absent_absent_explicit_var; /* global var */
+
+template int cbv<Small_absent_absent_explicit> (Small_absent_absent_explicit arg);
+/*** C++ class Large_absent_absent_explicit ***/
+class Large_absent_absent_explicit {
+public:
+ Large_absent_absent_explicit (void);
+ Large_absent_absent_explicit (Large_absent_absent_explicit &&rhs);
+
+
+ int data[150];
+};
+
+Large_absent_absent_explicit::Large_absent_absent_explicit (void)
+{
+ data[0] = 2;
+ data[149] = 2;
+}
+
+Large_absent_absent_explicit::Large_absent_absent_explicit (Large_absent_absent_explicit &&rhs)
+{
+ data[0] = 3;
+ data[149] = 3;
+ tracer = 5;
+}
+
+
+Large_absent_absent_explicit Large_absent_absent_explicit_var; /* global var */
+
+template int cbv<Large_absent_absent_explicit> (Large_absent_absent_explicit arg);
+/*** Class derived from Small_absent_absent_explicit ***/
+class Derived_absent_absent_explicit : public Small_absent_absent_explicit {
+public:
+};
+
+Derived_absent_absent_explicit Derived_absent_absent_explicit_var; /* global var */
+
+template int cbv<Derived_absent_absent_explicit> (Derived_absent_absent_explicit arg);
+/*** Class that contains Small_absent_absent_explicit ***/
+class Container_absent_absent_explicit {
+public:
+ Small_absent_absent_explicit item;
+};
+
+Container_absent_absent_explicit Container_absent_absent_explicit_var; /* global var */
+
+template int cbv_container<Container_absent_absent_explicit> (Container_absent_absent_explicit arg);
+/*** C++ class Small_absent_absent_defaultedIn ***/
+class Small_absent_absent_defaultedIn {
+public:
+ Small_absent_absent_defaultedIn (void);
+ Small_absent_absent_defaultedIn (Small_absent_absent_defaultedIn &&rhs) = default;
+
+
+ int data[2];
+};
+
+Small_absent_absent_defaultedIn::Small_absent_absent_defaultedIn (void)
+{
+ data[0] = 2;
+ data[1] = 2;
+}
+
+
+
+Small_absent_absent_defaultedIn Small_absent_absent_defaultedIn_var; /* global var */
+
+template int cbv<Small_absent_absent_defaultedIn> (Small_absent_absent_defaultedIn arg);
+/*** C++ class Large_absent_absent_defaultedIn ***/
+class Large_absent_absent_defaultedIn {
+public:
+ Large_absent_absent_defaultedIn (void);
+ Large_absent_absent_defaultedIn (Large_absent_absent_defaultedIn &&rhs) = default;
+
+
+ int data[150];
+};
+
+Large_absent_absent_defaultedIn::Large_absent_absent_defaultedIn (void)
+{
+ data[0] = 2;
+ data[149] = 2;
+}
+
+
+
+Large_absent_absent_defaultedIn Large_absent_absent_defaultedIn_var; /* global var */
+
+template int cbv<Large_absent_absent_defaultedIn> (Large_absent_absent_defaultedIn arg);
+/*** Class derived from Small_absent_absent_defaultedIn ***/
+class Derived_absent_absent_defaultedIn : public Small_absent_absent_defaultedIn {
+public:
+};
+
+Derived_absent_absent_defaultedIn Derived_absent_absent_defaultedIn_var; /* global var */
+
+template int cbv<Derived_absent_absent_defaultedIn> (Derived_absent_absent_defaultedIn arg);
+/*** Class that contains Small_absent_absent_defaultedIn ***/
+class Container_absent_absent_defaultedIn {
+public:
+ Small_absent_absent_defaultedIn item;
+};
+
+Container_absent_absent_defaultedIn Container_absent_absent_defaultedIn_var; /* global var */
+
+template int cbv_container<Container_absent_absent_defaultedIn> (Container_absent_absent_defaultedIn arg);
+/*** C++ class Small_absent_absent_defaultedOut ***/
+class Small_absent_absent_defaultedOut {
+public:
+ Small_absent_absent_defaultedOut (void);
+ Small_absent_absent_defaultedOut (Small_absent_absent_defaultedOut &&rhs);
+
+
+ int data[2];
+};
+
+Small_absent_absent_defaultedOut::Small_absent_absent_defaultedOut (void)
+{
+ data[0] = 2;
+ data[1] = 2;
+}
+
+Small_absent_absent_defaultedOut::Small_absent_absent_defaultedOut (Small_absent_absent_defaultedOut &&rhs) = default;
+
+
+Small_absent_absent_defaultedOut Small_absent_absent_defaultedOut_var; /* global var */
+
+template int cbv<Small_absent_absent_defaultedOut> (Small_absent_absent_defaultedOut arg);
+/*** C++ class Large_absent_absent_defaultedOut ***/
+class Large_absent_absent_defaultedOut {
+public:
+ Large_absent_absent_defaultedOut (void);
+ Large_absent_absent_defaultedOut (Large_absent_absent_defaultedOut &&rhs);
+
+
+ int data[150];
+};
+
+Large_absent_absent_defaultedOut::Large_absent_absent_defaultedOut (void)
+{
+ data[0] = 2;
+ data[149] = 2;
+}
+
+Large_absent_absent_defaultedOut::Large_absent_absent_defaultedOut (Large_absent_absent_defaultedOut &&rhs) = default;
+
+
+Large_absent_absent_defaultedOut Large_absent_absent_defaultedOut_var; /* global var */
+
+template int cbv<Large_absent_absent_defaultedOut> (Large_absent_absent_defaultedOut arg);
+/*** Class derived from Small_absent_absent_defaultedOut ***/
+class Derived_absent_absent_defaultedOut : public Small_absent_absent_defaultedOut {
+public:
+};
+
+Derived_absent_absent_defaultedOut Derived_absent_absent_defaultedOut_var; /* global var */
+
+template int cbv<Derived_absent_absent_defaultedOut> (Derived_absent_absent_defaultedOut arg);
+/*** Class that contains Small_absent_absent_defaultedOut ***/
+class Container_absent_absent_defaultedOut {
+public:
+ Small_absent_absent_defaultedOut item;
+};
+
+Container_absent_absent_defaultedOut Container_absent_absent_defaultedOut_var; /* global var */
+
+template int cbv_container<Container_absent_absent_defaultedOut> (Container_absent_absent_defaultedOut arg);
+/*** C++ class Small_absent_absent_deleted ***/
+class Small_absent_absent_deleted {
+public:
+ Small_absent_absent_deleted (void);
+ Small_absent_absent_deleted (Small_absent_absent_deleted &&rhs) = delete;
+
+
+ int data[2];
+};
+
+Small_absent_absent_deleted::Small_absent_absent_deleted (void)
+{
+ data[0] = 2;
+ data[1] = 2;
+}
+
+
+
+Small_absent_absent_deleted Small_absent_absent_deleted_var; /* global var */
+
+template int cbv<Small_absent_absent_deleted> (Small_absent_absent_deleted arg);
+/*** C++ class Large_absent_absent_deleted ***/
+class Large_absent_absent_deleted {
+public:
+ Large_absent_absent_deleted (void);
+ Large_absent_absent_deleted (Large_absent_absent_deleted &&rhs) = delete;
+
+
+ int data[150];
+};
+
+Large_absent_absent_deleted::Large_absent_absent_deleted (void)
+{
+ data[0] = 2;
+ data[149] = 2;
+}
+
+
+
+Large_absent_absent_deleted Large_absent_absent_deleted_var; /* global var */
+
+template int cbv<Large_absent_absent_deleted> (Large_absent_absent_deleted arg);
+/*** Class derived from Small_absent_absent_deleted ***/
+class Derived_absent_absent_deleted : public Small_absent_absent_deleted {
+public:
+};
+
+Derived_absent_absent_deleted Derived_absent_absent_deleted_var; /* global var */
+
+template int cbv<Derived_absent_absent_deleted> (Derived_absent_absent_deleted arg);
+/*** Class that contains Small_absent_absent_deleted ***/
+class Container_absent_absent_deleted {
+public:
+ Small_absent_absent_deleted item;
+};
+
+Container_absent_absent_deleted Container_absent_absent_deleted_var; /* global var */
+
+template int cbv_container<Container_absent_absent_deleted> (Container_absent_absent_deleted arg);
+/*** C++ class Small_absent_explicit_absent ***/
+class Small_absent_explicit_absent {
+public:
+ Small_absent_explicit_absent (void);
+ ~Small_absent_explicit_absent (void);
+
+
+ int data[2];
+};
+
+Small_absent_explicit_absent::Small_absent_explicit_absent (void)
+{
+ data[0] = 2;
+ data[1] = 2;
+}
+
+Small_absent_explicit_absent::~Small_absent_explicit_absent (void)
+{
+ data[0] = 3;
+ data[1] = 3;
+ tracer = 5;
+}
+
+
+Small_absent_explicit_absent Small_absent_explicit_absent_var; /* global var */
+
+template int cbv<Small_absent_explicit_absent> (Small_absent_explicit_absent arg);
+/*** C++ class Large_absent_explicit_absent ***/
+class Large_absent_explicit_absent {
+public:
+ Large_absent_explicit_absent (void);
+ ~Large_absent_explicit_absent (void);
+
+
+ int data[150];
+};
+
+Large_absent_explicit_absent::Large_absent_explicit_absent (void)
+{
+ data[0] = 2;
+ data[149] = 2;
+}
+
+Large_absent_explicit_absent::~Large_absent_explicit_absent (void)
+{
+ data[0] = 3;
+ data[149] = 3;
+ tracer = 5;
+}
+
+
+Large_absent_explicit_absent Large_absent_explicit_absent_var; /* global var */
+
+template int cbv<Large_absent_explicit_absent> (Large_absent_explicit_absent arg);
+/*** Class derived from Small_absent_explicit_absent ***/
+class Derived_absent_explicit_absent : public Small_absent_explicit_absent {
+public:
+};
+
+Derived_absent_explicit_absent Derived_absent_explicit_absent_var; /* global var */
+
+template int cbv<Derived_absent_explicit_absent> (Derived_absent_explicit_absent arg);
+/*** Class that contains Small_absent_explicit_absent ***/
+class Container_absent_explicit_absent {
+public:
+ Small_absent_explicit_absent item;
+};
+
+Container_absent_explicit_absent Container_absent_explicit_absent_var; /* global var */
+
+template int cbv_container<Container_absent_explicit_absent> (Container_absent_explicit_absent arg);
+/*** C++ class Small_absent_explicit_explicit ***/
+class Small_absent_explicit_explicit {
+public:
+ Small_absent_explicit_explicit (void);
+ ~Small_absent_explicit_explicit (void);
+ Small_absent_explicit_explicit (Small_absent_explicit_explicit &&rhs);
+
+
+ int data[2];
+};
+
+Small_absent_explicit_explicit::Small_absent_explicit_explicit (void)
+{
+ data[0] = 2;
+ data[1] = 2;
+}
+
+Small_absent_explicit_explicit::~Small_absent_explicit_explicit (void)
+{
+ data[0] = 3;
+ data[1] = 3;
+ tracer = 5;
+}
+Small_absent_explicit_explicit::Small_absent_explicit_explicit (Small_absent_explicit_explicit &&rhs)
+{
+ data[0] = 3;
+ data[1] = 3;
+ tracer = 5;
+}
+
+
+Small_absent_explicit_explicit Small_absent_explicit_explicit_var; /* global var */
+
+template int cbv<Small_absent_explicit_explicit> (Small_absent_explicit_explicit arg);
+/*** C++ class Large_absent_explicit_explicit ***/
+class Large_absent_explicit_explicit {
+public:
+ Large_absent_explicit_explicit (void);
+ ~Large_absent_explicit_explicit (void);
+ Large_absent_explicit_explicit (Large_absent_explicit_explicit &&rhs);
+
+
+ int data[150];
+};
+
+Large_absent_explicit_explicit::Large_absent_explicit_explicit (void)
+{
+ data[0] = 2;
+ data[149] = 2;
+}
+
+Large_absent_explicit_explicit::~Large_absent_explicit_explicit (void)
+{
+ data[0] = 3;
+ data[149] = 3;
+ tracer = 5;
+}
+Large_absent_explicit_explicit::Large_absent_explicit_explicit (Large_absent_explicit_explicit &&rhs)
+{
+ data[0] = 3;
+ data[149] = 3;
+ tracer = 5;
+}
+
+
+Large_absent_explicit_explicit Large_absent_explicit_explicit_var; /* global var */
+
+template int cbv<Large_absent_explicit_explicit> (Large_absent_explicit_explicit arg);
+/*** Class derived from Small_absent_explicit_explicit ***/
+class Derived_absent_explicit_explicit : public Small_absent_explicit_explicit {
+public:
+};
+
+Derived_absent_explicit_explicit Derived_absent_explicit_explicit_var; /* global var */
+
+template int cbv<Derived_absent_explicit_explicit> (Derived_absent_explicit_explicit arg);
+/*** Class that contains Small_absent_explicit_explicit ***/
+class Container_absent_explicit_explicit {
+public:
+ Small_absent_explicit_explicit item;
+};
+
+Container_absent_explicit_explicit Container_absent_explicit_explicit_var; /* global var */
+
+template int cbv_container<Container_absent_explicit_explicit> (Container_absent_explicit_explicit arg);
+/*** C++ class Small_absent_explicit_defaultedIn ***/
+class Small_absent_explicit_defaultedIn {
+public:
+ Small_absent_explicit_defaultedIn (void);
+ ~Small_absent_explicit_defaultedIn (void);
+ Small_absent_explicit_defaultedIn (Small_absent_explicit_defaultedIn &&rhs) = default;
+
+
+ int data[2];
+};
+
+Small_absent_explicit_defaultedIn::Small_absent_explicit_defaultedIn (void)
+{
+ data[0] = 2;
+ data[1] = 2;
+}
+
+Small_absent_explicit_defaultedIn::~Small_absent_explicit_defaultedIn (void)
+{
+ data[0] = 3;
+ data[1] = 3;
+ tracer = 5;
+}
+
+
+Small_absent_explicit_defaultedIn Small_absent_explicit_defaultedIn_var; /* global var */
+
+template int cbv<Small_absent_explicit_defaultedIn> (Small_absent_explicit_defaultedIn arg);
+/*** C++ class Large_absent_explicit_defaultedIn ***/
+class Large_absent_explicit_defaultedIn {
+public:
+ Large_absent_explicit_defaultedIn (void);
+ ~Large_absent_explicit_defaultedIn (void);
+ Large_absent_explicit_defaultedIn (Large_absent_explicit_defaultedIn &&rhs) = default;
+
+
+ int data[150];
+};
+
+Large_absent_explicit_defaultedIn::Large_absent_explicit_defaultedIn (void)
+{
+ data[0] = 2;
+ data[149] = 2;
+}
+
+Large_absent_explicit_defaultedIn::~Large_absent_explicit_defaultedIn (void)
+{
+ data[0] = 3;
+ data[149] = 3;
+ tracer = 5;
+}
+
+
+Large_absent_explicit_defaultedIn Large_absent_explicit_defaultedIn_var; /* global var */
+
+template int cbv<Large_absent_explicit_defaultedIn> (Large_absent_explicit_defaultedIn arg);
+/*** Class derived from Small_absent_explicit_defaultedIn ***/
+class Derived_absent_explicit_defaultedIn : public Small_absent_explicit_defaultedIn {
+public:
+};
+
+Derived_absent_explicit_defaultedIn Derived_absent_explicit_defaultedIn_var; /* global var */
+
+template int cbv<Derived_absent_explicit_defaultedIn> (Derived_absent_explicit_defaultedIn arg);
+/*** Class that contains Small_absent_explicit_defaultedIn ***/
+class Container_absent_explicit_defaultedIn {
+public:
+ Small_absent_explicit_defaultedIn item;
+};
+
+Container_absent_explicit_defaultedIn Container_absent_explicit_defaultedIn_var; /* global var */
+
+template int cbv_container<Container_absent_explicit_defaultedIn> (Container_absent_explicit_defaultedIn arg);
+/*** C++ class Small_absent_explicit_defaultedOut ***/
+class Small_absent_explicit_defaultedOut {
+public:
+ Small_absent_explicit_defaultedOut (void);
+ ~Small_absent_explicit_defaultedOut (void);
+ Small_absent_explicit_defaultedOut (Small_absent_explicit_defaultedOut &&rhs);
+
+
+ int data[2];
+};
+
+Small_absent_explicit_defaultedOut::Small_absent_explicit_defaultedOut (void)
+{
+ data[0] = 2;
+ data[1] = 2;
+}
+
+Small_absent_explicit_defaultedOut::~Small_absent_explicit_defaultedOut (void)
+{
+ data[0] = 3;
+ data[1] = 3;
+ tracer = 5;
+}
+Small_absent_explicit_defaultedOut::Small_absent_explicit_defaultedOut (Small_absent_explicit_defaultedOut &&rhs) = default;
+
+
+Small_absent_explicit_defaultedOut Small_absent_explicit_defaultedOut_var; /* global var */
+
+template int cbv<Small_absent_explicit_defaultedOut> (Small_absent_explicit_defaultedOut arg);
+/*** C++ class Large_absent_explicit_defaultedOut ***/
+class Large_absent_explicit_defaultedOut {
+public:
+ Large_absent_explicit_defaultedOut (void);
+ ~Large_absent_explicit_defaultedOut (void);
+ Large_absent_explicit_defaultedOut (Large_absent_explicit_defaultedOut &&rhs);
+
+
+ int data[150];
+};
+
+Large_absent_explicit_defaultedOut::Large_absent_explicit_defaultedOut (void)
+{
+ data[0] = 2;
+ data[149] = 2;
+}
+
+Large_absent_explicit_defaultedOut::~Large_absent_explicit_defaultedOut (void)
+{
+ data[0] = 3;
+ data[149] = 3;
+ tracer = 5;
+}
+Large_absent_explicit_defaultedOut::Large_absent_explicit_defaultedOut (Large_absent_explicit_defaultedOut &&rhs) = default;
+
+
+Large_absent_explicit_defaultedOut Large_absent_explicit_defaultedOut_var; /* global var */
+
+template int cbv<Large_absent_explicit_defaultedOut> (Large_absent_explicit_defaultedOut arg);
+/*** Class derived from Small_absent_explicit_defaultedOut ***/
+class Derived_absent_explicit_defaultedOut : public Small_absent_explicit_defaultedOut {
+public:
+};
+
+Derived_absent_explicit_defaultedOut Derived_absent_explicit_defaultedOut_var; /* global var */
+
+template int cbv<Derived_absent_explicit_defaultedOut> (Derived_absent_explicit_defaultedOut arg);
+/*** Class that contains Small_absent_explicit_defaultedOut ***/
+class Container_absent_explicit_defaultedOut {
+public:
+ Small_absent_explicit_defaultedOut item;
+};
+
+Container_absent_explicit_defaultedOut Container_absent_explicit_defaultedOut_var; /* global var */
+
+template int cbv_container<Container_absent_explicit_defaultedOut> (Container_absent_explicit_defaultedOut arg);
+/*** C++ class Small_absent_explicit_deleted ***/
+class Small_absent_explicit_deleted {
+public:
+ Small_absent_explicit_deleted (void);
+ ~Small_absent_explicit_deleted (void);
+ Small_absent_explicit_deleted (Small_absent_explicit_deleted &&rhs) = delete;
+
+
+ int data[2];
+};
+
+Small_absent_explicit_deleted::Small_absent_explicit_deleted (void)
+{
+ data[0] = 2;
+ data[1] = 2;
+}
+
+Small_absent_explicit_deleted::~Small_absent_explicit_deleted (void)
+{
+ data[0] = 3;
+ data[1] = 3;
+ tracer = 5;
+}
+
+
+Small_absent_explicit_deleted Small_absent_explicit_deleted_var; /* global var */
+
+template int cbv<Small_absent_explicit_deleted> (Small_absent_explicit_deleted arg);
+/*** C++ class Large_absent_explicit_deleted ***/
+class Large_absent_explicit_deleted {
+public:
+ Large_absent_explicit_deleted (void);
+ ~Large_absent_explicit_deleted (void);
+ Large_absent_explicit_deleted (Large_absent_explicit_deleted &&rhs) = delete;
+
+
+ int data[150];
+};
+
+Large_absent_explicit_deleted::Large_absent_explicit_deleted (void)
+{
+ data[0] = 2;
+ data[149] = 2;
+}
+
+Large_absent_explicit_deleted::~Large_absent_explicit_deleted (void)
+{
+ data[0] = 3;
+ data[149] = 3;
+ tracer = 5;
+}
+
+
+Large_absent_explicit_deleted Large_absent_explicit_deleted_var; /* global var */
+
+template int cbv<Large_absent_explicit_deleted> (Large_absent_explicit_deleted arg);
+/*** Class derived from Small_absent_explicit_deleted ***/
+class Derived_absent_explicit_deleted : public Small_absent_explicit_deleted {
+public:
+};
+
+Derived_absent_explicit_deleted Derived_absent_explicit_deleted_var; /* global var */
+
+template int cbv<Derived_absent_explicit_deleted> (Derived_absent_explicit_deleted arg);
+/*** Class that contains Small_absent_explicit_deleted ***/
+class Container_absent_explicit_deleted {
+public:
+ Small_absent_explicit_deleted item;
+};
+
+Container_absent_explicit_deleted Container_absent_explicit_deleted_var; /* global var */
+
+template int cbv_container<Container_absent_explicit_deleted> (Container_absent_explicit_deleted arg);
+/*** C++ class Small_absent_defaultedIn_absent ***/
+class Small_absent_defaultedIn_absent {
+public:
+ Small_absent_defaultedIn_absent (void);
+ ~Small_absent_defaultedIn_absent (void) = default;
+
+
+ int data[2];
+};
+
+Small_absent_defaultedIn_absent::Small_absent_defaultedIn_absent (void)
+{
+ data[0] = 2;
+ data[1] = 2;
+}
+
+
+
+Small_absent_defaultedIn_absent Small_absent_defaultedIn_absent_var; /* global var */
+
+template int cbv<Small_absent_defaultedIn_absent> (Small_absent_defaultedIn_absent arg);
+/*** C++ class Large_absent_defaultedIn_absent ***/
+class Large_absent_defaultedIn_absent {
+public:
+ Large_absent_defaultedIn_absent (void);
+ ~Large_absent_defaultedIn_absent (void) = default;
+
+
+ int data[150];
+};
+
+Large_absent_defaultedIn_absent::Large_absent_defaultedIn_absent (void)
+{
+ data[0] = 2;
+ data[149] = 2;
+}
+
+
+
+Large_absent_defaultedIn_absent Large_absent_defaultedIn_absent_var; /* global var */
+
+template int cbv<Large_absent_defaultedIn_absent> (Large_absent_defaultedIn_absent arg);
+/*** Class derived from Small_absent_defaultedIn_absent ***/
+class Derived_absent_defaultedIn_absent : public Small_absent_defaultedIn_absent {
+public:
+};
+
+Derived_absent_defaultedIn_absent Derived_absent_defaultedIn_absent_var; /* global var */
+
+template int cbv<Derived_absent_defaultedIn_absent> (Derived_absent_defaultedIn_absent arg);
+/*** Class that contains Small_absent_defaultedIn_absent ***/
+class Container_absent_defaultedIn_absent {
+public:
+ Small_absent_defaultedIn_absent item;
+};
+
+Container_absent_defaultedIn_absent Container_absent_defaultedIn_absent_var; /* global var */
+
+template int cbv_container<Container_absent_defaultedIn_absent> (Container_absent_defaultedIn_absent arg);
+/*** C++ class Small_absent_defaultedIn_explicit ***/
+class Small_absent_defaultedIn_explicit {
+public:
+ Small_absent_defaultedIn_explicit (void);
+ ~Small_absent_defaultedIn_explicit (void) = default;
+ Small_absent_defaultedIn_explicit (Small_absent_defaultedIn_explicit &&rhs);
+
+
+ int data[2];
+};
+
+Small_absent_defaultedIn_explicit::Small_absent_defaultedIn_explicit (void)
+{
+ data[0] = 2;
+ data[1] = 2;
+}
+
+Small_absent_defaultedIn_explicit::Small_absent_defaultedIn_explicit (Small_absent_defaultedIn_explicit &&rhs)
+{
+ data[0] = 3;
+ data[1] = 3;
+ tracer = 5;
+}
+
+
+Small_absent_defaultedIn_explicit Small_absent_defaultedIn_explicit_var; /* global var */
+
+template int cbv<Small_absent_defaultedIn_explicit> (Small_absent_defaultedIn_explicit arg);
+/*** C++ class Large_absent_defaultedIn_explicit ***/
+class Large_absent_defaultedIn_explicit {
+public:
+ Large_absent_defaultedIn_explicit (void);
+ ~Large_absent_defaultedIn_explicit (void) = default;
+ Large_absent_defaultedIn_explicit (Large_absent_defaultedIn_explicit &&rhs);
+
+
+ int data[150];
+};
+
+Large_absent_defaultedIn_explicit::Large_absent_defaultedIn_explicit (void)
+{
+ data[0] = 2;
+ data[149] = 2;
+}
+
+Large_absent_defaultedIn_explicit::Large_absent_defaultedIn_explicit (Large_absent_defaultedIn_explicit &&rhs)
+{
+ data[0] = 3;
+ data[149] = 3;
+ tracer = 5;
+}
+
+
+Large_absent_defaultedIn_explicit Large_absent_defaultedIn_explicit_var; /* global var */
+
+template int cbv<Large_absent_defaultedIn_explicit> (Large_absent_defaultedIn_explicit arg);
+/*** Class derived from Small_absent_defaultedIn_explicit ***/
+class Derived_absent_defaultedIn_explicit : public Small_absent_defaultedIn_explicit {
+public:
+};
+
+Derived_absent_defaultedIn_explicit Derived_absent_defaultedIn_explicit_var; /* global var */
+
+template int cbv<Derived_absent_defaultedIn_explicit> (Derived_absent_defaultedIn_explicit arg);
+/*** Class that contains Small_absent_defaultedIn_explicit ***/
+class Container_absent_defaultedIn_explicit {
+public:
+ Small_absent_defaultedIn_explicit item;
+};
+
+Container_absent_defaultedIn_explicit Container_absent_defaultedIn_explicit_var; /* global var */
+
+template int cbv_container<Container_absent_defaultedIn_explicit> (Container_absent_defaultedIn_explicit arg);
+/*** C++ class Small_absent_defaultedIn_defaultedIn ***/
+class Small_absent_defaultedIn_defaultedIn {
+public:
+ Small_absent_defaultedIn_defaultedIn (void);
+ ~Small_absent_defaultedIn_defaultedIn (void) = default;
+ Small_absent_defaultedIn_defaultedIn (Small_absent_defaultedIn_defaultedIn &&rhs) = default;
+
+
+ int data[2];
+};
+
+Small_absent_defaultedIn_defaultedIn::Small_absent_defaultedIn_defaultedIn (void)
+{
+ data[0] = 2;
+ data[1] = 2;
+}
+
+
+
+Small_absent_defaultedIn_defaultedIn Small_absent_defaultedIn_defaultedIn_var; /* global var */
+
+template int cbv<Small_absent_defaultedIn_defaultedIn> (Small_absent_defaultedIn_defaultedIn arg);
+/*** C++ class Large_absent_defaultedIn_defaultedIn ***/
+class Large_absent_defaultedIn_defaultedIn {
+public:
+ Large_absent_defaultedIn_defaultedIn (void);
+ ~Large_absent_defaultedIn_defaultedIn (void) = default;
+ Large_absent_defaultedIn_defaultedIn (Large_absent_defaultedIn_defaultedIn &&rhs) = default;
+
+
+ int data[150];
+};
+
+Large_absent_defaultedIn_defaultedIn::Large_absent_defaultedIn_defaultedIn (void)
+{
+ data[0] = 2;
+ data[149] = 2;
+}
+
+
+
+Large_absent_defaultedIn_defaultedIn Large_absent_defaultedIn_defaultedIn_var; /* global var */
+
+template int cbv<Large_absent_defaultedIn_defaultedIn> (Large_absent_defaultedIn_defaultedIn arg);
+/*** Class derived from Small_absent_defaultedIn_defaultedIn ***/
+class Derived_absent_defaultedIn_defaultedIn : public Small_absent_defaultedIn_defaultedIn {
+public:
+};
+
+Derived_absent_defaultedIn_defaultedIn Derived_absent_defaultedIn_defaultedIn_var; /* global var */
+
+template int cbv<Derived_absent_defaultedIn_defaultedIn> (Derived_absent_defaultedIn_defaultedIn arg);
+/*** Class that contains Small_absent_defaultedIn_defaultedIn ***/
+class Container_absent_defaultedIn_defaultedIn {
+public:
+ Small_absent_defaultedIn_defaultedIn item;
+};
+
+Container_absent_defaultedIn_defaultedIn Container_absent_defaultedIn_defaultedIn_var; /* global var */
+
+template int cbv_container<Container_absent_defaultedIn_defaultedIn> (Container_absent_defaultedIn_defaultedIn arg);
+/*** C++ class Small_absent_defaultedIn_defaultedOut ***/
+class Small_absent_defaultedIn_defaultedOut {
+public:
+ Small_absent_defaultedIn_defaultedOut (void);
+ ~Small_absent_defaultedIn_defaultedOut (void) = default;
+ Small_absent_defaultedIn_defaultedOut (Small_absent_defaultedIn_defaultedOut &&rhs);
+
+
+ int data[2];
+};
+
+Small_absent_defaultedIn_defaultedOut::Small_absent_defaultedIn_defaultedOut (void)
+{
+ data[0] = 2;
+ data[1] = 2;
+}
+
+Small_absent_defaultedIn_defaultedOut::Small_absent_defaultedIn_defaultedOut (Small_absent_defaultedIn_defaultedOut &&rhs) = default;
+
+
+Small_absent_defaultedIn_defaultedOut Small_absent_defaultedIn_defaultedOut_var; /* global var */
+
+template int cbv<Small_absent_defaultedIn_defaultedOut> (Small_absent_defaultedIn_defaultedOut arg);
+/*** C++ class Large_absent_defaultedIn_defaultedOut ***/
+class Large_absent_defaultedIn_defaultedOut {
+public:
+ Large_absent_defaultedIn_defaultedOut (void);
+ ~Large_absent_defaultedIn_defaultedOut (void) = default;
+ Large_absent_defaultedIn_defaultedOut (Large_absent_defaultedIn_defaultedOut &&rhs);
+
+
+ int data[150];
+};
+
+Large_absent_defaultedIn_defaultedOut::Large_absent_defaultedIn_defaultedOut (void)
+{
+ data[0] = 2;
+ data[149] = 2;
+}
+
+Large_absent_defaultedIn_defaultedOut::Large_absent_defaultedIn_defaultedOut (Large_absent_defaultedIn_defaultedOut &&rhs) = default;
+
+
+Large_absent_defaultedIn_defaultedOut Large_absent_defaultedIn_defaultedOut_var; /* global var */
+
+template int cbv<Large_absent_defaultedIn_defaultedOut> (Large_absent_defaultedIn_defaultedOut arg);
+/*** Class derived from Small_absent_defaultedIn_defaultedOut ***/
+class Derived_absent_defaultedIn_defaultedOut : public Small_absent_defaultedIn_defaultedOut {
+public:
+};
+
+Derived_absent_defaultedIn_defaultedOut Derived_absent_defaultedIn_defaultedOut_var; /* global var */
+
+template int cbv<Derived_absent_defaultedIn_defaultedOut> (Derived_absent_defaultedIn_defaultedOut arg);
+/*** Class that contains Small_absent_defaultedIn_defaultedOut ***/
+class Container_absent_defaultedIn_defaultedOut {
+public:
+ Small_absent_defaultedIn_defaultedOut item;
+};
+
+Container_absent_defaultedIn_defaultedOut Container_absent_defaultedIn_defaultedOut_var; /* global var */
+
+template int cbv_container<Container_absent_defaultedIn_defaultedOut> (Container_absent_defaultedIn_defaultedOut arg);
+/*** C++ class Small_absent_defaultedIn_deleted ***/
+class Small_absent_defaultedIn_deleted {
+public:
+ Small_absent_defaultedIn_deleted (void);
+ ~Small_absent_defaultedIn_deleted (void) = default;
+ Small_absent_defaultedIn_deleted (Small_absent_defaultedIn_deleted &&rhs) = delete;
+
+
+ int data[2];
+};
+
+Small_absent_defaultedIn_deleted::Small_absent_defaultedIn_deleted (void)
+{
+ data[0] = 2;
+ data[1] = 2;
+}
+
+
+
+Small_absent_defaultedIn_deleted Small_absent_defaultedIn_deleted_var; /* global var */
+
+template int cbv<Small_absent_defaultedIn_deleted> (Small_absent_defaultedIn_deleted arg);
+/*** C++ class Large_absent_defaultedIn_deleted ***/
+class Large_absent_defaultedIn_deleted {
+public:
+ Large_absent_defaultedIn_deleted (void);
+ ~Large_absent_defaultedIn_deleted (void) = default;
+ Large_absent_defaultedIn_deleted (Large_absent_defaultedIn_deleted &&rhs) = delete;
+
+
+ int data[150];
+};
+
+Large_absent_defaultedIn_deleted::Large_absent_defaultedIn_deleted (void)
+{
+ data[0] = 2;
+ data[149] = 2;
+}
+
+
+
+Large_absent_defaultedIn_deleted Large_absent_defaultedIn_deleted_var; /* global var */
+
+template int cbv<Large_absent_defaultedIn_deleted> (Large_absent_defaultedIn_deleted arg);
+/*** Class derived from Small_absent_defaultedIn_deleted ***/
+class Derived_absent_defaultedIn_deleted : public Small_absent_defaultedIn_deleted {
+public:
+};
+
+Derived_absent_defaultedIn_deleted Derived_absent_defaultedIn_deleted_var; /* global var */
+
+template int cbv<Derived_absent_defaultedIn_deleted> (Derived_absent_defaultedIn_deleted arg);
+/*** Class that contains Small_absent_defaultedIn_deleted ***/
+class Container_absent_defaultedIn_deleted {
+public:
+ Small_absent_defaultedIn_deleted item;
+};
+
+Container_absent_defaultedIn_deleted Container_absent_defaultedIn_deleted_var; /* global var */
+
+template int cbv_container<Container_absent_defaultedIn_deleted> (Container_absent_defaultedIn_deleted arg);
+/*** C++ class Small_absent_defaultedOut_absent ***/
+class Small_absent_defaultedOut_absent {
+public:
+ Small_absent_defaultedOut_absent (void);
+ ~Small_absent_defaultedOut_absent (void);
+
+
+ int data[2];
+};
+
+Small_absent_defaultedOut_absent::Small_absent_defaultedOut_absent (void)
+{
+ data[0] = 2;
+ data[1] = 2;
+}
+
+Small_absent_defaultedOut_absent::~Small_absent_defaultedOut_absent (void) = default;
+
+
+Small_absent_defaultedOut_absent Small_absent_defaultedOut_absent_var; /* global var */
+
+template int cbv<Small_absent_defaultedOut_absent> (Small_absent_defaultedOut_absent arg);
+/*** C++ class Large_absent_defaultedOut_absent ***/
+class Large_absent_defaultedOut_absent {
+public:
+ Large_absent_defaultedOut_absent (void);
+ ~Large_absent_defaultedOut_absent (void);
+
+
+ int data[150];
+};
+
+Large_absent_defaultedOut_absent::Large_absent_defaultedOut_absent (void)
+{
+ data[0] = 2;
+ data[149] = 2;
+}
+
+Large_absent_defaultedOut_absent::~Large_absent_defaultedOut_absent (void) = default;
+
+
+Large_absent_defaultedOut_absent Large_absent_defaultedOut_absent_var; /* global var */
+
+template int cbv<Large_absent_defaultedOut_absent> (Large_absent_defaultedOut_absent arg);
+/*** Class derived from Small_absent_defaultedOut_absent ***/
+class Derived_absent_defaultedOut_absent : public Small_absent_defaultedOut_absent {
+public:
+};
+
+Derived_absent_defaultedOut_absent Derived_absent_defaultedOut_absent_var; /* global var */
+
+template int cbv<Derived_absent_defaultedOut_absent> (Derived_absent_defaultedOut_absent arg);
+/*** Class that contains Small_absent_defaultedOut_absent ***/
+class Container_absent_defaultedOut_absent {
+public:
+ Small_absent_defaultedOut_absent item;
+};
+
+Container_absent_defaultedOut_absent Container_absent_defaultedOut_absent_var; /* global var */
+
+template int cbv_container<Container_absent_defaultedOut_absent> (Container_absent_defaultedOut_absent arg);
+/*** C++ class Small_absent_defaultedOut_explicit ***/
+class Small_absent_defaultedOut_explicit {
+public:
+ Small_absent_defaultedOut_explicit (void);
+ ~Small_absent_defaultedOut_explicit (void);
+ Small_absent_defaultedOut_explicit (Small_absent_defaultedOut_explicit &&rhs);
+
+
+ int data[2];
+};
+
+Small_absent_defaultedOut_explicit::Small_absent_defaultedOut_explicit (void)
+{
+ data[0] = 2;
+ data[1] = 2;
+}
+
+Small_absent_defaultedOut_explicit::~Small_absent_defaultedOut_explicit (void) = default;
+Small_absent_defaultedOut_explicit::Small_absent_defaultedOut_explicit (Small_absent_defaultedOut_explicit &&rhs)
+{
+ data[0] = 3;
+ data[1] = 3;
+ tracer = 5;
+}
+
+
+Small_absent_defaultedOut_explicit Small_absent_defaultedOut_explicit_var; /* global var */
+
+template int cbv<Small_absent_defaultedOut_explicit> (Small_absent_defaultedOut_explicit arg);
+/*** C++ class Large_absent_defaultedOut_explicit ***/
+class Large_absent_defaultedOut_explicit {
+public:
+ Large_absent_defaultedOut_explicit (void);
+ ~Large_absent_defaultedOut_explicit (void);
+ Large_absent_defaultedOut_explicit (Large_absent_defaultedOut_explicit &&rhs);
+
+
+ int data[150];
+};
+
+Large_absent_defaultedOut_explicit::Large_absent_defaultedOut_explicit (void)
+{
+ data[0] = 2;
+ data[149] = 2;
+}
+
+Large_absent_defaultedOut_explicit::~Large_absent_defaultedOut_explicit (void) = default;
+Large_absent_defaultedOut_explicit::Large_absent_defaultedOut_explicit (Large_absent_defaultedOut_explicit &&rhs)
+{
+ data[0] = 3;
+ data[149] = 3;
+ tracer = 5;
+}
+
+
+Large_absent_defaultedOut_explicit Large_absent_defaultedOut_explicit_var; /* global var */
+
+template int cbv<Large_absent_defaultedOut_explicit> (Large_absent_defaultedOut_explicit arg);
+/*** Class derived from Small_absent_defaultedOut_explicit ***/
+class Derived_absent_defaultedOut_explicit : public Small_absent_defaultedOut_explicit {
+public:
+};
+
+Derived_absent_defaultedOut_explicit Derived_absent_defaultedOut_explicit_var; /* global var */
+
+template int cbv<Derived_absent_defaultedOut_explicit> (Derived_absent_defaultedOut_explicit arg);
+/*** Class that contains Small_absent_defaultedOut_explicit ***/
+class Container_absent_defaultedOut_explicit {
+public:
+ Small_absent_defaultedOut_explicit item;
+};
+
+Container_absent_defaultedOut_explicit Container_absent_defaultedOut_explicit_var; /* global var */
+
+template int cbv_container<Container_absent_defaultedOut_explicit> (Container_absent_defaultedOut_explicit arg);
+/*** C++ class Small_absent_defaultedOut_defaultedIn ***/
+class Small_absent_defaultedOut_defaultedIn {
+public:
+ Small_absent_defaultedOut_defaultedIn (void);
+ ~Small_absent_defaultedOut_defaultedIn (void);
+ Small_absent_defaultedOut_defaultedIn (Small_absent_defaultedOut_defaultedIn &&rhs) = default;
+
+
+ int data[2];
+};
+
+Small_absent_defaultedOut_defaultedIn::Small_absent_defaultedOut_defaultedIn (void)
+{
+ data[0] = 2;
+ data[1] = 2;
+}
+
+Small_absent_defaultedOut_defaultedIn::~Small_absent_defaultedOut_defaultedIn (void) = default;
+
+
+Small_absent_defaultedOut_defaultedIn Small_absent_defaultedOut_defaultedIn_var; /* global var */
+
+template int cbv<Small_absent_defaultedOut_defaultedIn> (Small_absent_defaultedOut_defaultedIn arg);
+/*** C++ class Large_absent_defaultedOut_defaultedIn ***/
+class Large_absent_defaultedOut_defaultedIn {
+public:
+ Large_absent_defaultedOut_defaultedIn (void);
+ ~Large_absent_defaultedOut_defaultedIn (void);
+ Large_absent_defaultedOut_defaultedIn (Large_absent_defaultedOut_defaultedIn &&rhs) = default;
+
+
+ int data[150];
+};
+
+Large_absent_defaultedOut_defaultedIn::Large_absent_defaultedOut_defaultedIn (void)
+{
+ data[0] = 2;
+ data[149] = 2;
+}
+
+Large_absent_defaultedOut_defaultedIn::~Large_absent_defaultedOut_defaultedIn (void) = default;
+
+
+Large_absent_defaultedOut_defaultedIn Large_absent_defaultedOut_defaultedIn_var; /* global var */
+
+template int cbv<Large_absent_defaultedOut_defaultedIn> (Large_absent_defaultedOut_defaultedIn arg);
+/*** Class derived from Small_absent_defaultedOut_defaultedIn ***/
+class Derived_absent_defaultedOut_defaultedIn : public Small_absent_defaultedOut_defaultedIn {
+public:
+};
+
+Derived_absent_defaultedOut_defaultedIn Derived_absent_defaultedOut_defaultedIn_var; /* global var */
+
+template int cbv<Derived_absent_defaultedOut_defaultedIn> (Derived_absent_defaultedOut_defaultedIn arg);
+/*** Class that contains Small_absent_defaultedOut_defaultedIn ***/
+class Container_absent_defaultedOut_defaultedIn {
+public:
+ Small_absent_defaultedOut_defaultedIn item;
+};
+
+Container_absent_defaultedOut_defaultedIn Container_absent_defaultedOut_defaultedIn_var; /* global var */
+
+template int cbv_container<Container_absent_defaultedOut_defaultedIn> (Container_absent_defaultedOut_defaultedIn arg);
+/*** C++ class Small_absent_defaultedOut_defaultedOut ***/
+class Small_absent_defaultedOut_defaultedOut {
+public:
+ Small_absent_defaultedOut_defaultedOut (void);
+ ~Small_absent_defaultedOut_defaultedOut (void);
+ Small_absent_defaultedOut_defaultedOut (Small_absent_defaultedOut_defaultedOut &&rhs);
+
+
+ int data[2];
+};
+
+Small_absent_defaultedOut_defaultedOut::Small_absent_defaultedOut_defaultedOut (void)
+{
+ data[0] = 2;
+ data[1] = 2;
+}
+
+Small_absent_defaultedOut_defaultedOut::~Small_absent_defaultedOut_defaultedOut (void) = default;
+Small_absent_defaultedOut_defaultedOut::Small_absent_defaultedOut_defaultedOut (Small_absent_defaultedOut_defaultedOut &&rhs) = default;
+
+
+Small_absent_defaultedOut_defaultedOut Small_absent_defaultedOut_defaultedOut_var; /* global var */
+
+template int cbv<Small_absent_defaultedOut_defaultedOut> (Small_absent_defaultedOut_defaultedOut arg);
+/*** C++ class Large_absent_defaultedOut_defaultedOut ***/
+class Large_absent_defaultedOut_defaultedOut {
+public:
+ Large_absent_defaultedOut_defaultedOut (void);
+ ~Large_absent_defaultedOut_defaultedOut (void);
+ Large_absent_defaultedOut_defaultedOut (Large_absent_defaultedOut_defaultedOut &&rhs);
+
+
+ int data[150];
+};
+
+Large_absent_defaultedOut_defaultedOut::Large_absent_defaultedOut_defaultedOut (void)
+{
+ data[0] = 2;
+ data[149] = 2;
+}
+
+Large_absent_defaultedOut_defaultedOut::~Large_absent_defaultedOut_defaultedOut (void) = default;
+Large_absent_defaultedOut_defaultedOut::Large_absent_defaultedOut_defaultedOut (Large_absent_defaultedOut_defaultedOut &&rhs) = default;
+
+
+Large_absent_defaultedOut_defaultedOut Large_absent_defaultedOut_defaultedOut_var; /* global var */
+
+template int cbv<Large_absent_defaultedOut_defaultedOut> (Large_absent_defaultedOut_defaultedOut arg);
+/*** Class derived from Small_absent_defaultedOut_defaultedOut ***/
+class Derived_absent_defaultedOut_defaultedOut : public Small_absent_defaultedOut_defaultedOut {
+public:
+};
+
+Derived_absent_defaultedOut_defaultedOut Derived_absent_defaultedOut_defaultedOut_var; /* global var */
+
+template int cbv<Derived_absent_defaultedOut_defaultedOut> (Derived_absent_defaultedOut_defaultedOut arg);
+/*** Class that contains Small_absent_defaultedOut_defaultedOut ***/
+class Container_absent_defaultedOut_defaultedOut {
+public:
+ Small_absent_defaultedOut_defaultedOut item;
+};
+
+Container_absent_defaultedOut_defaultedOut Container_absent_defaultedOut_defaultedOut_var; /* global var */
+
+template int cbv_container<Container_absent_defaultedOut_defaultedOut> (Container_absent_defaultedOut_defaultedOut arg);
+/*** C++ class Small_absent_defaultedOut_deleted ***/
+class Small_absent_defaultedOut_deleted {
+public:
+ Small_absent_defaultedOut_deleted (void);
+ ~Small_absent_defaultedOut_deleted (void);
+ Small_absent_defaultedOut_deleted (Small_absent_defaultedOut_deleted &&rhs) = delete;
+
+
+ int data[2];
+};
+
+Small_absent_defaultedOut_deleted::Small_absent_defaultedOut_deleted (void)
+{
+ data[0] = 2;
+ data[1] = 2;
+}
+
+Small_absent_defaultedOut_deleted::~Small_absent_defaultedOut_deleted (void) = default;
+
+
+Small_absent_defaultedOut_deleted Small_absent_defaultedOut_deleted_var; /* global var */
+
+template int cbv<Small_absent_defaultedOut_deleted> (Small_absent_defaultedOut_deleted arg);
+/*** C++ class Large_absent_defaultedOut_deleted ***/
+class Large_absent_defaultedOut_deleted {
+public:
+ Large_absent_defaultedOut_deleted (void);
+ ~Large_absent_defaultedOut_deleted (void);
+ Large_absent_defaultedOut_deleted (Large_absent_defaultedOut_deleted &&rhs) = delete;
+
+
+ int data[150];
+};
+
+Large_absent_defaultedOut_deleted::Large_absent_defaultedOut_deleted (void)
+{
+ data[0] = 2;
+ data[149] = 2;
+}
+
+Large_absent_defaultedOut_deleted::~Large_absent_defaultedOut_deleted (void) = default;
+
+
+Large_absent_defaultedOut_deleted Large_absent_defaultedOut_deleted_var; /* global var */
+
+template int cbv<Large_absent_defaultedOut_deleted> (Large_absent_defaultedOut_deleted arg);
+/*** Class derived from Small_absent_defaultedOut_deleted ***/
+class Derived_absent_defaultedOut_deleted : public Small_absent_defaultedOut_deleted {
+public:
+};
+
+Derived_absent_defaultedOut_deleted Derived_absent_defaultedOut_deleted_var; /* global var */
+
+template int cbv<Derived_absent_defaultedOut_deleted> (Derived_absent_defaultedOut_deleted arg);
+/*** Class that contains Small_absent_defaultedOut_deleted ***/
+class Container_absent_defaultedOut_deleted {
+public:
+ Small_absent_defaultedOut_deleted item;
+};
+
+Container_absent_defaultedOut_deleted Container_absent_defaultedOut_deleted_var; /* global var */
+
+template int cbv_container<Container_absent_defaultedOut_deleted> (Container_absent_defaultedOut_deleted arg);
+/*** C++ class Small_explicit_absent_absent ***/
+class Small_explicit_absent_absent {
+public:
+ Small_explicit_absent_absent (void);
+ Small_explicit_absent_absent (const Small_explicit_absent_absent &rhs);
+
+
+ int data[2];
+};
+
+Small_explicit_absent_absent::Small_explicit_absent_absent (void)
+{
+ data[0] = 2;
+ data[1] = 2;
+}
+
+Small_explicit_absent_absent::Small_explicit_absent_absent (const Small_explicit_absent_absent &rhs)
+{
+ data[0] = 3;
+ data[1] = 3;
+ tracer = 5;
+}
+
+
+Small_explicit_absent_absent Small_explicit_absent_absent_var; /* global var */
+
+template int cbv<Small_explicit_absent_absent> (Small_explicit_absent_absent arg);
+/*** C++ class Large_explicit_absent_absent ***/
+class Large_explicit_absent_absent {
+public:
+ Large_explicit_absent_absent (void);
+ Large_explicit_absent_absent (const Large_explicit_absent_absent &rhs);
+
+
+ int data[150];
+};
+
+Large_explicit_absent_absent::Large_explicit_absent_absent (void)
+{
+ data[0] = 2;
+ data[149] = 2;
+}
+
+Large_explicit_absent_absent::Large_explicit_absent_absent (const Large_explicit_absent_absent &rhs)
+{
+ data[0] = 3;
+ data[149] = 3;
+ tracer = 5;
+}
+
+
+Large_explicit_absent_absent Large_explicit_absent_absent_var; /* global var */
+
+template int cbv<Large_explicit_absent_absent> (Large_explicit_absent_absent arg);
+/*** Class derived from Small_explicit_absent_absent ***/
+class Derived_explicit_absent_absent : public Small_explicit_absent_absent {
+public:
+};
+
+Derived_explicit_absent_absent Derived_explicit_absent_absent_var; /* global var */
+
+template int cbv<Derived_explicit_absent_absent> (Derived_explicit_absent_absent arg);
+/*** Class that contains Small_explicit_absent_absent ***/
+class Container_explicit_absent_absent {
+public:
+ Small_explicit_absent_absent item;
+};
+
+Container_explicit_absent_absent Container_explicit_absent_absent_var; /* global var */
+
+template int cbv_container<Container_explicit_absent_absent> (Container_explicit_absent_absent arg);
+/*** C++ class Small_explicit_absent_explicit ***/
+class Small_explicit_absent_explicit {
+public:
+ Small_explicit_absent_explicit (void);
+ Small_explicit_absent_explicit (const Small_explicit_absent_explicit &rhs);
+ Small_explicit_absent_explicit (Small_explicit_absent_explicit &&rhs);
+
+
+ int data[2];
+};
+
+Small_explicit_absent_explicit::Small_explicit_absent_explicit (void)
+{
+ data[0] = 2;
+ data[1] = 2;
+}
+
+Small_explicit_absent_explicit::Small_explicit_absent_explicit (const Small_explicit_absent_explicit &rhs)
+{
+ data[0] = 3;
+ data[1] = 3;
+ tracer = 5;
+}
+Small_explicit_absent_explicit::Small_explicit_absent_explicit (Small_explicit_absent_explicit &&rhs)
+{
+ data[0] = 3;
+ data[1] = 3;
+ tracer = 5;
+}
+
+
+Small_explicit_absent_explicit Small_explicit_absent_explicit_var; /* global var */
+
+template int cbv<Small_explicit_absent_explicit> (Small_explicit_absent_explicit arg);
+/*** C++ class Large_explicit_absent_explicit ***/
+class Large_explicit_absent_explicit {
+public:
+ Large_explicit_absent_explicit (void);
+ Large_explicit_absent_explicit (const Large_explicit_absent_explicit &rhs);
+ Large_explicit_absent_explicit (Large_explicit_absent_explicit &&rhs);
+
+
+ int data[150];
+};
+
+Large_explicit_absent_explicit::Large_explicit_absent_explicit (void)
+{
+ data[0] = 2;
+ data[149] = 2;
+}
+
+Large_explicit_absent_explicit::Large_explicit_absent_explicit (const Large_explicit_absent_explicit &rhs)
+{
+ data[0] = 3;
+ data[149] = 3;
+ tracer = 5;
+}
+Large_explicit_absent_explicit::Large_explicit_absent_explicit (Large_explicit_absent_explicit &&rhs)
+{
+ data[0] = 3;
+ data[149] = 3;
+ tracer = 5;
+}
+
+
+Large_explicit_absent_explicit Large_explicit_absent_explicit_var; /* global var */
+
+template int cbv<Large_explicit_absent_explicit> (Large_explicit_absent_explicit arg);
+/*** Class derived from Small_explicit_absent_explicit ***/
+class Derived_explicit_absent_explicit : public Small_explicit_absent_explicit {
+public:
+};
+
+Derived_explicit_absent_explicit Derived_explicit_absent_explicit_var; /* global var */
+
+template int cbv<Derived_explicit_absent_explicit> (Derived_explicit_absent_explicit arg);
+/*** Class that contains Small_explicit_absent_explicit ***/
+class Container_explicit_absent_explicit {
+public:
+ Small_explicit_absent_explicit item;
+};
+
+Container_explicit_absent_explicit Container_explicit_absent_explicit_var; /* global var */
+
+template int cbv_container<Container_explicit_absent_explicit> (Container_explicit_absent_explicit arg);
+/*** C++ class Small_explicit_absent_defaultedIn ***/
+class Small_explicit_absent_defaultedIn {
+public:
+ Small_explicit_absent_defaultedIn (void);
+ Small_explicit_absent_defaultedIn (const Small_explicit_absent_defaultedIn &rhs);
+ Small_explicit_absent_defaultedIn (Small_explicit_absent_defaultedIn &&rhs) = default;
+
+
+ int data[2];
+};
+
+Small_explicit_absent_defaultedIn::Small_explicit_absent_defaultedIn (void)
+{
+ data[0] = 2;
+ data[1] = 2;
+}
+
+Small_explicit_absent_defaultedIn::Small_explicit_absent_defaultedIn (const Small_explicit_absent_defaultedIn &rhs)
+{
+ data[0] = 3;
+ data[1] = 3;
+ tracer = 5;
+}
+
+
+Small_explicit_absent_defaultedIn Small_explicit_absent_defaultedIn_var; /* global var */
+
+template int cbv<Small_explicit_absent_defaultedIn> (Small_explicit_absent_defaultedIn arg);
+/*** C++ class Large_explicit_absent_defaultedIn ***/
+class Large_explicit_absent_defaultedIn {
+public:
+ Large_explicit_absent_defaultedIn (void);
+ Large_explicit_absent_defaultedIn (const Large_explicit_absent_defaultedIn &rhs);
+ Large_explicit_absent_defaultedIn (Large_explicit_absent_defaultedIn &&rhs) = default;
+
+
+ int data[150];
+};
+
+Large_explicit_absent_defaultedIn::Large_explicit_absent_defaultedIn (void)
+{
+ data[0] = 2;
+ data[149] = 2;
+}
+
+Large_explicit_absent_defaultedIn::Large_explicit_absent_defaultedIn (const Large_explicit_absent_defaultedIn &rhs)
+{
+ data[0] = 3;
+ data[149] = 3;
+ tracer = 5;
+}
+
+
+Large_explicit_absent_defaultedIn Large_explicit_absent_defaultedIn_var; /* global var */
+
+template int cbv<Large_explicit_absent_defaultedIn> (Large_explicit_absent_defaultedIn arg);
+/*** Class derived from Small_explicit_absent_defaultedIn ***/
+class Derived_explicit_absent_defaultedIn : public Small_explicit_absent_defaultedIn {
+public:
+};
+
+Derived_explicit_absent_defaultedIn Derived_explicit_absent_defaultedIn_var; /* global var */
+
+template int cbv<Derived_explicit_absent_defaultedIn> (Derived_explicit_absent_defaultedIn arg);
+/*** Class that contains Small_explicit_absent_defaultedIn ***/
+class Container_explicit_absent_defaultedIn {
+public:
+ Small_explicit_absent_defaultedIn item;
+};
+
+Container_explicit_absent_defaultedIn Container_explicit_absent_defaultedIn_var; /* global var */
+
+template int cbv_container<Container_explicit_absent_defaultedIn> (Container_explicit_absent_defaultedIn arg);
+/*** C++ class Small_explicit_absent_defaultedOut ***/
+class Small_explicit_absent_defaultedOut {
+public:
+ Small_explicit_absent_defaultedOut (void);
+ Small_explicit_absent_defaultedOut (const Small_explicit_absent_defaultedOut &rhs);
+ Small_explicit_absent_defaultedOut (Small_explicit_absent_defaultedOut &&rhs);
+
+
+ int data[2];
+};
+
+Small_explicit_absent_defaultedOut::Small_explicit_absent_defaultedOut (void)
+{
+ data[0] = 2;
+ data[1] = 2;
+}
+
+Small_explicit_absent_defaultedOut::Small_explicit_absent_defaultedOut (const Small_explicit_absent_defaultedOut &rhs)
+{
+ data[0] = 3;
+ data[1] = 3;
+ tracer = 5;
+}
+Small_explicit_absent_defaultedOut::Small_explicit_absent_defaultedOut (Small_explicit_absent_defaultedOut &&rhs) = default;
+
+
+Small_explicit_absent_defaultedOut Small_explicit_absent_defaultedOut_var; /* global var */
+
+template int cbv<Small_explicit_absent_defaultedOut> (Small_explicit_absent_defaultedOut arg);
+/*** C++ class Large_explicit_absent_defaultedOut ***/
+class Large_explicit_absent_defaultedOut {
+public:
+ Large_explicit_absent_defaultedOut (void);
+ Large_explicit_absent_defaultedOut (const Large_explicit_absent_defaultedOut &rhs);
+ Large_explicit_absent_defaultedOut (Large_explicit_absent_defaultedOut &&rhs);
+
+
+ int data[150];
+};
+
+Large_explicit_absent_defaultedOut::Large_explicit_absent_defaultedOut (void)
+{
+ data[0] = 2;
+ data[149] = 2;
+}
+
+Large_explicit_absent_defaultedOut::Large_explicit_absent_defaultedOut (const Large_explicit_absent_defaultedOut &rhs)
+{
+ data[0] = 3;
+ data[149] = 3;
+ tracer = 5;
+}
+Large_explicit_absent_defaultedOut::Large_explicit_absent_defaultedOut (Large_explicit_absent_defaultedOut &&rhs) = default;
+
+
+Large_explicit_absent_defaultedOut Large_explicit_absent_defaultedOut_var; /* global var */
+
+template int cbv<Large_explicit_absent_defaultedOut> (Large_explicit_absent_defaultedOut arg);
+/*** Class derived from Small_explicit_absent_defaultedOut ***/
+class Derived_explicit_absent_defaultedOut : public Small_explicit_absent_defaultedOut {
+public:
+};
+
+Derived_explicit_absent_defaultedOut Derived_explicit_absent_defaultedOut_var; /* global var */
+
+template int cbv<Derived_explicit_absent_defaultedOut> (Derived_explicit_absent_defaultedOut arg);
+/*** Class that contains Small_explicit_absent_defaultedOut ***/
+class Container_explicit_absent_defaultedOut {
+public:
+ Small_explicit_absent_defaultedOut item;
+};
+
+Container_explicit_absent_defaultedOut Container_explicit_absent_defaultedOut_var; /* global var */
+
+template int cbv_container<Container_explicit_absent_defaultedOut> (Container_explicit_absent_defaultedOut arg);
+/*** C++ class Small_explicit_absent_deleted ***/
+class Small_explicit_absent_deleted {
+public:
+ Small_explicit_absent_deleted (void);
+ Small_explicit_absent_deleted (const Small_explicit_absent_deleted &rhs);
+ Small_explicit_absent_deleted (Small_explicit_absent_deleted &&rhs) = delete;
+
+
+ int data[2];
+};
+
+Small_explicit_absent_deleted::Small_explicit_absent_deleted (void)
+{
+ data[0] = 2;
+ data[1] = 2;
+}
+
+Small_explicit_absent_deleted::Small_explicit_absent_deleted (const Small_explicit_absent_deleted &rhs)
+{
+ data[0] = 3;
+ data[1] = 3;
+ tracer = 5;
+}
+
+
+Small_explicit_absent_deleted Small_explicit_absent_deleted_var; /* global var */
+
+template int cbv<Small_explicit_absent_deleted> (Small_explicit_absent_deleted arg);
+/*** C++ class Large_explicit_absent_deleted ***/
+class Large_explicit_absent_deleted {
+public:
+ Large_explicit_absent_deleted (void);
+ Large_explicit_absent_deleted (const Large_explicit_absent_deleted &rhs);
+ Large_explicit_absent_deleted (Large_explicit_absent_deleted &&rhs) = delete;
+
+
+ int data[150];
+};
+
+Large_explicit_absent_deleted::Large_explicit_absent_deleted (void)
+{
+ data[0] = 2;
+ data[149] = 2;
+}
+
+Large_explicit_absent_deleted::Large_explicit_absent_deleted (const Large_explicit_absent_deleted &rhs)
+{
+ data[0] = 3;
+ data[149] = 3;
+ tracer = 5;
+}
+
+
+Large_explicit_absent_deleted Large_explicit_absent_deleted_var; /* global var */
+
+template int cbv<Large_explicit_absent_deleted> (Large_explicit_absent_deleted arg);
+/*** Class derived from Small_explicit_absent_deleted ***/
+class Derived_explicit_absent_deleted : public Small_explicit_absent_deleted {
+public:
+};
+
+Derived_explicit_absent_deleted Derived_explicit_absent_deleted_var; /* global var */
+
+template int cbv<Derived_explicit_absent_deleted> (Derived_explicit_absent_deleted arg);
+/*** Class that contains Small_explicit_absent_deleted ***/
+class Container_explicit_absent_deleted {
+public:
+ Small_explicit_absent_deleted item;
+};
+
+Container_explicit_absent_deleted Container_explicit_absent_deleted_var; /* global var */
+
+template int cbv_container<Container_explicit_absent_deleted> (Container_explicit_absent_deleted arg);
+/*** C++ class Small_explicit_explicit_absent ***/
+class Small_explicit_explicit_absent {
+public:
+ Small_explicit_explicit_absent (void);
+ Small_explicit_explicit_absent (const Small_explicit_explicit_absent &rhs);
+ ~Small_explicit_explicit_absent (void);
+
+
+ int data[2];
+};
+
+Small_explicit_explicit_absent::Small_explicit_explicit_absent (void)
+{
+ data[0] = 2;
+ data[1] = 2;
+}
+
+Small_explicit_explicit_absent::Small_explicit_explicit_absent (const Small_explicit_explicit_absent &rhs)
+{
+ data[0] = 3;
+ data[1] = 3;
+ tracer = 5;
+}
+Small_explicit_explicit_absent::~Small_explicit_explicit_absent (void)
+{
+ data[0] = 3;
+ data[1] = 3;
+ tracer = 5;
+}
+
+
+Small_explicit_explicit_absent Small_explicit_explicit_absent_var; /* global var */
+
+template int cbv<Small_explicit_explicit_absent> (Small_explicit_explicit_absent arg);
+/*** C++ class Large_explicit_explicit_absent ***/
+class Large_explicit_explicit_absent {
+public:
+ Large_explicit_explicit_absent (void);
+ Large_explicit_explicit_absent (const Large_explicit_explicit_absent &rhs);
+ ~Large_explicit_explicit_absent (void);
+
+
+ int data[150];
+};
+
+Large_explicit_explicit_absent::Large_explicit_explicit_absent (void)
+{
+ data[0] = 2;
+ data[149] = 2;
+}
+
+Large_explicit_explicit_absent::Large_explicit_explicit_absent (const Large_explicit_explicit_absent &rhs)
+{
+ data[0] = 3;
+ data[149] = 3;
+ tracer = 5;
+}
+Large_explicit_explicit_absent::~Large_explicit_explicit_absent (void)
+{
+ data[0] = 3;
+ data[149] = 3;
+ tracer = 5;
+}
+
+
+Large_explicit_explicit_absent Large_explicit_explicit_absent_var; /* global var */
+
+template int cbv<Large_explicit_explicit_absent> (Large_explicit_explicit_absent arg);
+/*** Class derived from Small_explicit_explicit_absent ***/
+class Derived_explicit_explicit_absent : public Small_explicit_explicit_absent {
+public:
+};
+
+Derived_explicit_explicit_absent Derived_explicit_explicit_absent_var; /* global var */
+
+template int cbv<Derived_explicit_explicit_absent> (Derived_explicit_explicit_absent arg);
+/*** Class that contains Small_explicit_explicit_absent ***/
+class Container_explicit_explicit_absent {
+public:
+ Small_explicit_explicit_absent item;
+};
+
+Container_explicit_explicit_absent Container_explicit_explicit_absent_var; /* global var */
+
+template int cbv_container<Container_explicit_explicit_absent> (Container_explicit_explicit_absent arg);
+/*** C++ class Small_explicit_explicit_explicit ***/
+class Small_explicit_explicit_explicit {
+public:
+ Small_explicit_explicit_explicit (void);
+ Small_explicit_explicit_explicit (const Small_explicit_explicit_explicit &rhs);
+ ~Small_explicit_explicit_explicit (void);
+ Small_explicit_explicit_explicit (Small_explicit_explicit_explicit &&rhs);
+
+
+ int data[2];
+};
+
+Small_explicit_explicit_explicit::Small_explicit_explicit_explicit (void)
+{
+ data[0] = 2;
+ data[1] = 2;
+}
+
+Small_explicit_explicit_explicit::Small_explicit_explicit_explicit (const Small_explicit_explicit_explicit &rhs)
+{
+ data[0] = 3;
+ data[1] = 3;
+ tracer = 5;
+}
+Small_explicit_explicit_explicit::~Small_explicit_explicit_explicit (void)
+{
+ data[0] = 3;
+ data[1] = 3;
+ tracer = 5;
+}
+Small_explicit_explicit_explicit::Small_explicit_explicit_explicit (Small_explicit_explicit_explicit &&rhs)
+{
+ data[0] = 3;
+ data[1] = 3;
+ tracer = 5;
+}
+
+
+Small_explicit_explicit_explicit Small_explicit_explicit_explicit_var; /* global var */
+
+template int cbv<Small_explicit_explicit_explicit> (Small_explicit_explicit_explicit arg);
+/*** C++ class Large_explicit_explicit_explicit ***/
+class Large_explicit_explicit_explicit {
+public:
+ Large_explicit_explicit_explicit (void);
+ Large_explicit_explicit_explicit (const Large_explicit_explicit_explicit &rhs);
+ ~Large_explicit_explicit_explicit (void);
+ Large_explicit_explicit_explicit (Large_explicit_explicit_explicit &&rhs);
+
+
+ int data[150];
+};
+
+Large_explicit_explicit_explicit::Large_explicit_explicit_explicit (void)
+{
+ data[0] = 2;
+ data[149] = 2;
+}
+
+Large_explicit_explicit_explicit::Large_explicit_explicit_explicit (const Large_explicit_explicit_explicit &rhs)
+{
+ data[0] = 3;
+ data[149] = 3;
+ tracer = 5;
+}
+Large_explicit_explicit_explicit::~Large_explicit_explicit_explicit (void)
+{
+ data[0] = 3;
+ data[149] = 3;
+ tracer = 5;
+}
+Large_explicit_explicit_explicit::Large_explicit_explicit_explicit (Large_explicit_explicit_explicit &&rhs)
+{
+ data[0] = 3;
+ data[149] = 3;
+ tracer = 5;
+}
+
+
+Large_explicit_explicit_explicit Large_explicit_explicit_explicit_var; /* global var */
+
+template int cbv<Large_explicit_explicit_explicit> (Large_explicit_explicit_explicit arg);
+/*** Class derived from Small_explicit_explicit_explicit ***/
+class Derived_explicit_explicit_explicit : public Small_explicit_explicit_explicit {
+public:
+};
+
+Derived_explicit_explicit_explicit Derived_explicit_explicit_explicit_var; /* global var */
+
+template int cbv<Derived_explicit_explicit_explicit> (Derived_explicit_explicit_explicit arg);
+/*** Class that contains Small_explicit_explicit_explicit ***/
+class Container_explicit_explicit_explicit {
+public:
+ Small_explicit_explicit_explicit item;
+};
+
+Container_explicit_explicit_explicit Container_explicit_explicit_explicit_var; /* global var */
+
+template int cbv_container<Container_explicit_explicit_explicit> (Container_explicit_explicit_explicit arg);
+/*** C++ class Small_explicit_explicit_defaultedIn ***/
+class Small_explicit_explicit_defaultedIn {
+public:
+ Small_explicit_explicit_defaultedIn (void);
+ Small_explicit_explicit_defaultedIn (const Small_explicit_explicit_defaultedIn &rhs);
+ ~Small_explicit_explicit_defaultedIn (void);
+ Small_explicit_explicit_defaultedIn (Small_explicit_explicit_defaultedIn &&rhs) = default;
+
+
+ int data[2];
+};
+
+Small_explicit_explicit_defaultedIn::Small_explicit_explicit_defaultedIn (void)
+{
+ data[0] = 2;
+ data[1] = 2;
+}
+
+Small_explicit_explicit_defaultedIn::Small_explicit_explicit_defaultedIn (const Small_explicit_explicit_defaultedIn &rhs)
+{
+ data[0] = 3;
+ data[1] = 3;
+ tracer = 5;
+}
+Small_explicit_explicit_defaultedIn::~Small_explicit_explicit_defaultedIn (void)
+{
+ data[0] = 3;
+ data[1] = 3;
+ tracer = 5;
+}
+
+
+Small_explicit_explicit_defaultedIn Small_explicit_explicit_defaultedIn_var; /* global var */
+
+template int cbv<Small_explicit_explicit_defaultedIn> (Small_explicit_explicit_defaultedIn arg);
+/*** C++ class Large_explicit_explicit_defaultedIn ***/
+class Large_explicit_explicit_defaultedIn {
+public:
+ Large_explicit_explicit_defaultedIn (void);
+ Large_explicit_explicit_defaultedIn (const Large_explicit_explicit_defaultedIn &rhs);
+ ~Large_explicit_explicit_defaultedIn (void);
+ Large_explicit_explicit_defaultedIn (Large_explicit_explicit_defaultedIn &&rhs) = default;
+
+
+ int data[150];
+};
+
+Large_explicit_explicit_defaultedIn::Large_explicit_explicit_defaultedIn (void)
+{
+ data[0] = 2;
+ data[149] = 2;
+}
+
+Large_explicit_explicit_defaultedIn::Large_explicit_explicit_defaultedIn (const Large_explicit_explicit_defaultedIn &rhs)
+{
+ data[0] = 3;
+ data[149] = 3;
+ tracer = 5;
+}
+Large_explicit_explicit_defaultedIn::~Large_explicit_explicit_defaultedIn (void)
+{
+ data[0] = 3;
+ data[149] = 3;
+ tracer = 5;
+}
+
+
+Large_explicit_explicit_defaultedIn Large_explicit_explicit_defaultedIn_var; /* global var */
+
+template int cbv<Large_explicit_explicit_defaultedIn> (Large_explicit_explicit_defaultedIn arg);
+/*** Class derived from Small_explicit_explicit_defaultedIn ***/
+class Derived_explicit_explicit_defaultedIn : public Small_explicit_explicit_defaultedIn {
+public:
+};
+
+Derived_explicit_explicit_defaultedIn Derived_explicit_explicit_defaultedIn_var; /* global var */
+
+template int cbv<Derived_explicit_explicit_defaultedIn> (Derived_explicit_explicit_defaultedIn arg);
+/*** Class that contains Small_explicit_explicit_defaultedIn ***/
+class Container_explicit_explicit_defaultedIn {
+public:
+ Small_explicit_explicit_defaultedIn item;
+};
+
+Container_explicit_explicit_defaultedIn Container_explicit_explicit_defaultedIn_var; /* global var */
+
+template int cbv_container<Container_explicit_explicit_defaultedIn> (Container_explicit_explicit_defaultedIn arg);
+/*** C++ class Small_explicit_explicit_defaultedOut ***/
+class Small_explicit_explicit_defaultedOut {
+public:
+ Small_explicit_explicit_defaultedOut (void);
+ Small_explicit_explicit_defaultedOut (const Small_explicit_explicit_defaultedOut &rhs);
+ ~Small_explicit_explicit_defaultedOut (void);
+ Small_explicit_explicit_defaultedOut (Small_explicit_explicit_defaultedOut &&rhs);
+
+
+ int data[2];
+};
+
+Small_explicit_explicit_defaultedOut::Small_explicit_explicit_defaultedOut (void)
+{
+ data[0] = 2;
+ data[1] = 2;
+}
+
+Small_explicit_explicit_defaultedOut::Small_explicit_explicit_defaultedOut (const Small_explicit_explicit_defaultedOut &rhs)
+{
+ data[0] = 3;
+ data[1] = 3;
+ tracer = 5;
+}
+Small_explicit_explicit_defaultedOut::~Small_explicit_explicit_defaultedOut (void)
+{
+ data[0] = 3;
+ data[1] = 3;
+ tracer = 5;
+}
+Small_explicit_explicit_defaultedOut::Small_explicit_explicit_defaultedOut (Small_explicit_explicit_defaultedOut &&rhs) = default;
+
+
+Small_explicit_explicit_defaultedOut Small_explicit_explicit_defaultedOut_var; /* global var */
+
+template int cbv<Small_explicit_explicit_defaultedOut> (Small_explicit_explicit_defaultedOut arg);
+/*** C++ class Large_explicit_explicit_defaultedOut ***/
+class Large_explicit_explicit_defaultedOut {
+public:
+ Large_explicit_explicit_defaultedOut (void);
+ Large_explicit_explicit_defaultedOut (const Large_explicit_explicit_defaultedOut &rhs);
+ ~Large_explicit_explicit_defaultedOut (void);
+ Large_explicit_explicit_defaultedOut (Large_explicit_explicit_defaultedOut &&rhs);
+
+
+ int data[150];
+};
+
+Large_explicit_explicit_defaultedOut::Large_explicit_explicit_defaultedOut (void)
+{
+ data[0] = 2;
+ data[149] = 2;
+}
+
+Large_explicit_explicit_defaultedOut::Large_explicit_explicit_defaultedOut (const Large_explicit_explicit_defaultedOut &rhs)
+{
+ data[0] = 3;
+ data[149] = 3;
+ tracer = 5;
+}
+Large_explicit_explicit_defaultedOut::~Large_explicit_explicit_defaultedOut (void)
+{
+ data[0] = 3;
+ data[149] = 3;
+ tracer = 5;
+}
+Large_explicit_explicit_defaultedOut::Large_explicit_explicit_defaultedOut (Large_explicit_explicit_defaultedOut &&rhs) = default;
+
+
+Large_explicit_explicit_defaultedOut Large_explicit_explicit_defaultedOut_var; /* global var */
+
+template int cbv<Large_explicit_explicit_defaultedOut> (Large_explicit_explicit_defaultedOut arg);
+/*** Class derived from Small_explicit_explicit_defaultedOut ***/
+class Derived_explicit_explicit_defaultedOut : public Small_explicit_explicit_defaultedOut {
+public:
+};
+
+Derived_explicit_explicit_defaultedOut Derived_explicit_explicit_defaultedOut_var; /* global var */
+
+template int cbv<Derived_explicit_explicit_defaultedOut> (Derived_explicit_explicit_defaultedOut arg);
+/*** Class that contains Small_explicit_explicit_defaultedOut ***/
+class Container_explicit_explicit_defaultedOut {
+public:
+ Small_explicit_explicit_defaultedOut item;
+};
+
+Container_explicit_explicit_defaultedOut Container_explicit_explicit_defaultedOut_var; /* global var */
+
+template int cbv_container<Container_explicit_explicit_defaultedOut> (Container_explicit_explicit_defaultedOut arg);
+/*** C++ class Small_explicit_explicit_deleted ***/
+class Small_explicit_explicit_deleted {
+public:
+ Small_explicit_explicit_deleted (void);
+ Small_explicit_explicit_deleted (const Small_explicit_explicit_deleted &rhs);
+ ~Small_explicit_explicit_deleted (void);
+ Small_explicit_explicit_deleted (Small_explicit_explicit_deleted &&rhs) = delete;
+
+
+ int data[2];
+};
+
+Small_explicit_explicit_deleted::Small_explicit_explicit_deleted (void)
+{
+ data[0] = 2;
+ data[1] = 2;
+}
+
+Small_explicit_explicit_deleted::Small_explicit_explicit_deleted (const Small_explicit_explicit_deleted &rhs)
+{
+ data[0] = 3;
+ data[1] = 3;
+ tracer = 5;
+}
+Small_explicit_explicit_deleted::~Small_explicit_explicit_deleted (void)
+{
+ data[0] = 3;
+ data[1] = 3;
+ tracer = 5;
+}
+
+
+Small_explicit_explicit_deleted Small_explicit_explicit_deleted_var; /* global var */
+
+template int cbv<Small_explicit_explicit_deleted> (Small_explicit_explicit_deleted arg);
+/*** C++ class Large_explicit_explicit_deleted ***/
+class Large_explicit_explicit_deleted {
+public:
+ Large_explicit_explicit_deleted (void);
+ Large_explicit_explicit_deleted (const Large_explicit_explicit_deleted &rhs);
+ ~Large_explicit_explicit_deleted (void);
+ Large_explicit_explicit_deleted (Large_explicit_explicit_deleted &&rhs) = delete;
+
+
+ int data[150];
+};
+
+Large_explicit_explicit_deleted::Large_explicit_explicit_deleted (void)
+{
+ data[0] = 2;
+ data[149] = 2;
+}
+
+Large_explicit_explicit_deleted::Large_explicit_explicit_deleted (const Large_explicit_explicit_deleted &rhs)
+{
+ data[0] = 3;
+ data[149] = 3;
+ tracer = 5;
+}
+Large_explicit_explicit_deleted::~Large_explicit_explicit_deleted (void)
+{
+ data[0] = 3;
+ data[149] = 3;
+ tracer = 5;
+}
+
+
+Large_explicit_explicit_deleted Large_explicit_explicit_deleted_var; /* global var */
+
+template int cbv<Large_explicit_explicit_deleted> (Large_explicit_explicit_deleted arg);
+/*** Class derived from Small_explicit_explicit_deleted ***/
+class Derived_explicit_explicit_deleted : public Small_explicit_explicit_deleted {
+public:
+};
+
+Derived_explicit_explicit_deleted Derived_explicit_explicit_deleted_var; /* global var */
+
+template int cbv<Derived_explicit_explicit_deleted> (Derived_explicit_explicit_deleted arg);
+/*** Class that contains Small_explicit_explicit_deleted ***/
+class Container_explicit_explicit_deleted {
+public:
+ Small_explicit_explicit_deleted item;
+};
+
+Container_explicit_explicit_deleted Container_explicit_explicit_deleted_var; /* global var */
+
+template int cbv_container<Container_explicit_explicit_deleted> (Container_explicit_explicit_deleted arg);
+/*** C++ class Small_explicit_defaultedIn_absent ***/
+class Small_explicit_defaultedIn_absent {
+public:
+ Small_explicit_defaultedIn_absent (void);
+ Small_explicit_defaultedIn_absent (const Small_explicit_defaultedIn_absent &rhs);
+ ~Small_explicit_defaultedIn_absent (void) = default;
+
+
+ int data[2];
+};
+
+Small_explicit_defaultedIn_absent::Small_explicit_defaultedIn_absent (void)
+{
+ data[0] = 2;
+ data[1] = 2;
+}
+
+Small_explicit_defaultedIn_absent::Small_explicit_defaultedIn_absent (const Small_explicit_defaultedIn_absent &rhs)
+{
+ data[0] = 3;
+ data[1] = 3;
+ tracer = 5;
+}
+
+
+Small_explicit_defaultedIn_absent Small_explicit_defaultedIn_absent_var; /* global var */
+
+template int cbv<Small_explicit_defaultedIn_absent> (Small_explicit_defaultedIn_absent arg);
+/*** C++ class Large_explicit_defaultedIn_absent ***/
+class Large_explicit_defaultedIn_absent {
+public:
+ Large_explicit_defaultedIn_absent (void);
+ Large_explicit_defaultedIn_absent (const Large_explicit_defaultedIn_absent &rhs);
+ ~Large_explicit_defaultedIn_absent (void) = default;
+
+
+ int data[150];
+};
+
+Large_explicit_defaultedIn_absent::Large_explicit_defaultedIn_absent (void)
+{
+ data[0] = 2;
+ data[149] = 2;
+}
+
+Large_explicit_defaultedIn_absent::Large_explicit_defaultedIn_absent (const Large_explicit_defaultedIn_absent &rhs)
+{
+ data[0] = 3;
+ data[149] = 3;
+ tracer = 5;
+}
+
+
+Large_explicit_defaultedIn_absent Large_explicit_defaultedIn_absent_var; /* global var */
+
+template int cbv<Large_explicit_defaultedIn_absent> (Large_explicit_defaultedIn_absent arg);
+/*** Class derived from Small_explicit_defaultedIn_absent ***/
+class Derived_explicit_defaultedIn_absent : public Small_explicit_defaultedIn_absent {
+public:
+};
+
+Derived_explicit_defaultedIn_absent Derived_explicit_defaultedIn_absent_var; /* global var */
+
+template int cbv<Derived_explicit_defaultedIn_absent> (Derived_explicit_defaultedIn_absent arg);
+/*** Class that contains Small_explicit_defaultedIn_absent ***/
+class Container_explicit_defaultedIn_absent {
+public:
+ Small_explicit_defaultedIn_absent item;
+};
+
+Container_explicit_defaultedIn_absent Container_explicit_defaultedIn_absent_var; /* global var */
+
+template int cbv_container<Container_explicit_defaultedIn_absent> (Container_explicit_defaultedIn_absent arg);
+/*** C++ class Small_explicit_defaultedIn_explicit ***/
+class Small_explicit_defaultedIn_explicit {
+public:
+ Small_explicit_defaultedIn_explicit (void);
+ Small_explicit_defaultedIn_explicit (const Small_explicit_defaultedIn_explicit &rhs);
+ ~Small_explicit_defaultedIn_explicit (void) = default;
+ Small_explicit_defaultedIn_explicit (Small_explicit_defaultedIn_explicit &&rhs);
+
+
+ int data[2];
+};
+
+Small_explicit_defaultedIn_explicit::Small_explicit_defaultedIn_explicit (void)
+{
+ data[0] = 2;
+ data[1] = 2;
+}
+
+Small_explicit_defaultedIn_explicit::Small_explicit_defaultedIn_explicit (const Small_explicit_defaultedIn_explicit &rhs)
+{
+ data[0] = 3;
+ data[1] = 3;
+ tracer = 5;
+}
+Small_explicit_defaultedIn_explicit::Small_explicit_defaultedIn_explicit (Small_explicit_defaultedIn_explicit &&rhs)
+{
+ data[0] = 3;
+ data[1] = 3;
+ tracer = 5;
+}
+
+
+Small_explicit_defaultedIn_explicit Small_explicit_defaultedIn_explicit_var; /* global var */
+
+template int cbv<Small_explicit_defaultedIn_explicit> (Small_explicit_defaultedIn_explicit arg);
+/*** C++ class Large_explicit_defaultedIn_explicit ***/
+class Large_explicit_defaultedIn_explicit {
+public:
+ Large_explicit_defaultedIn_explicit (void);
+ Large_explicit_defaultedIn_explicit (const Large_explicit_defaultedIn_explicit &rhs);
+ ~Large_explicit_defaultedIn_explicit (void) = default;
+ Large_explicit_defaultedIn_explicit (Large_explicit_defaultedIn_explicit &&rhs);
+
+
+ int data[150];
+};
+
+Large_explicit_defaultedIn_explicit::Large_explicit_defaultedIn_explicit (void)
+{
+ data[0] = 2;
+ data[149] = 2;
+}
+
+Large_explicit_defaultedIn_explicit::Large_explicit_defaultedIn_explicit (const Large_explicit_defaultedIn_explicit &rhs)
+{
+ data[0] = 3;
+ data[149] = 3;
+ tracer = 5;
+}
+Large_explicit_defaultedIn_explicit::Large_explicit_defaultedIn_explicit (Large_explicit_defaultedIn_explicit &&rhs)
+{
+ data[0] = 3;
+ data[149] = 3;
+ tracer = 5;
+}
+
+
+Large_explicit_defaultedIn_explicit Large_explicit_defaultedIn_explicit_var; /* global var */
+
+template int cbv<Large_explicit_defaultedIn_explicit> (Large_explicit_defaultedIn_explicit arg);
+/*** Class derived from Small_explicit_defaultedIn_explicit ***/
+class Derived_explicit_defaultedIn_explicit : public Small_explicit_defaultedIn_explicit {
+public:
+};
+
+Derived_explicit_defaultedIn_explicit Derived_explicit_defaultedIn_explicit_var; /* global var */
+
+template int cbv<Derived_explicit_defaultedIn_explicit> (Derived_explicit_defaultedIn_explicit arg);
+/*** Class that contains Small_explicit_defaultedIn_explicit ***/
+class Container_explicit_defaultedIn_explicit {
+public:
+ Small_explicit_defaultedIn_explicit item;
+};
+
+Container_explicit_defaultedIn_explicit Container_explicit_defaultedIn_explicit_var; /* global var */
+
+template int cbv_container<Container_explicit_defaultedIn_explicit> (Container_explicit_defaultedIn_explicit arg);
+/*** C++ class Small_explicit_defaultedIn_defaultedIn ***/
+class Small_explicit_defaultedIn_defaultedIn {
+public:
+ Small_explicit_defaultedIn_defaultedIn (void);
+ Small_explicit_defaultedIn_defaultedIn (const Small_explicit_defaultedIn_defaultedIn &rhs);
+ ~Small_explicit_defaultedIn_defaultedIn (void) = default;
+ Small_explicit_defaultedIn_defaultedIn (Small_explicit_defaultedIn_defaultedIn &&rhs) = default;
+
+
+ int data[2];
+};
+
+Small_explicit_defaultedIn_defaultedIn::Small_explicit_defaultedIn_defaultedIn (void)
+{
+ data[0] = 2;
+ data[1] = 2;
+}
+
+Small_explicit_defaultedIn_defaultedIn::Small_explicit_defaultedIn_defaultedIn (const Small_explicit_defaultedIn_defaultedIn &rhs)
+{
+ data[0] = 3;
+ data[1] = 3;
+ tracer = 5;
+}
+
+
+Small_explicit_defaultedIn_defaultedIn Small_explicit_defaultedIn_defaultedIn_var; /* global var */
+
+template int cbv<Small_explicit_defaultedIn_defaultedIn> (Small_explicit_defaultedIn_defaultedIn arg);
+/*** C++ class Large_explicit_defaultedIn_defaultedIn ***/
+class Large_explicit_defaultedIn_defaultedIn {
+public:
+ Large_explicit_defaultedIn_defaultedIn (void);
+ Large_explicit_defaultedIn_defaultedIn (const Large_explicit_defaultedIn_defaultedIn &rhs);
+ ~Large_explicit_defaultedIn_defaultedIn (void) = default;
+ Large_explicit_defaultedIn_defaultedIn (Large_explicit_defaultedIn_defaultedIn &&rhs) = default;
+
+
+ int data[150];
+};
+
+Large_explicit_defaultedIn_defaultedIn::Large_explicit_defaultedIn_defaultedIn (void)
+{
+ data[0] = 2;
+ data[149] = 2;
+}
+
+Large_explicit_defaultedIn_defaultedIn::Large_explicit_defaultedIn_defaultedIn (const Large_explicit_defaultedIn_defaultedIn &rhs)
+{
+ data[0] = 3;
+ data[149] = 3;
+ tracer = 5;
+}
+
+
+Large_explicit_defaultedIn_defaultedIn Large_explicit_defaultedIn_defaultedIn_var; /* global var */
+
+template int cbv<Large_explicit_defaultedIn_defaultedIn> (Large_explicit_defaultedIn_defaultedIn arg);
+/*** Class derived from Small_explicit_defaultedIn_defaultedIn ***/
+class Derived_explicit_defaultedIn_defaultedIn : public Small_explicit_defaultedIn_defaultedIn {
+public:
+};
+
+Derived_explicit_defaultedIn_defaultedIn Derived_explicit_defaultedIn_defaultedIn_var; /* global var */
+
+template int cbv<Derived_explicit_defaultedIn_defaultedIn> (Derived_explicit_defaultedIn_defaultedIn arg);
+/*** Class that contains Small_explicit_defaultedIn_defaultedIn ***/
+class Container_explicit_defaultedIn_defaultedIn {
+public:
+ Small_explicit_defaultedIn_defaultedIn item;
+};
+
+Container_explicit_defaultedIn_defaultedIn Container_explicit_defaultedIn_defaultedIn_var; /* global var */
+
+template int cbv_container<Container_explicit_defaultedIn_defaultedIn> (Container_explicit_defaultedIn_defaultedIn arg);
+/*** C++ class Small_explicit_defaultedIn_defaultedOut ***/
+class Small_explicit_defaultedIn_defaultedOut {
+public:
+ Small_explicit_defaultedIn_defaultedOut (void);
+ Small_explicit_defaultedIn_defaultedOut (const Small_explicit_defaultedIn_defaultedOut &rhs);
+ ~Small_explicit_defaultedIn_defaultedOut (void) = default;
+ Small_explicit_defaultedIn_defaultedOut (Small_explicit_defaultedIn_defaultedOut &&rhs);
+
+
+ int data[2];
+};
+
+Small_explicit_defaultedIn_defaultedOut::Small_explicit_defaultedIn_defaultedOut (void)
+{
+ data[0] = 2;
+ data[1] = 2;
+}
+
+Small_explicit_defaultedIn_defaultedOut::Small_explicit_defaultedIn_defaultedOut (const Small_explicit_defaultedIn_defaultedOut &rhs)
+{
+ data[0] = 3;
+ data[1] = 3;
+ tracer = 5;
+}
+Small_explicit_defaultedIn_defaultedOut::Small_explicit_defaultedIn_defaultedOut (Small_explicit_defaultedIn_defaultedOut &&rhs) = default;
+
+
+Small_explicit_defaultedIn_defaultedOut Small_explicit_defaultedIn_defaultedOut_var; /* global var */
+
+template int cbv<Small_explicit_defaultedIn_defaultedOut> (Small_explicit_defaultedIn_defaultedOut arg);
+/*** C++ class Large_explicit_defaultedIn_defaultedOut ***/
+class Large_explicit_defaultedIn_defaultedOut {
+public:
+ Large_explicit_defaultedIn_defaultedOut (void);
+ Large_explicit_defaultedIn_defaultedOut (const Large_explicit_defaultedIn_defaultedOut &rhs);
+ ~Large_explicit_defaultedIn_defaultedOut (void) = default;
+ Large_explicit_defaultedIn_defaultedOut (Large_explicit_defaultedIn_defaultedOut &&rhs);
+
+
+ int data[150];
+};
+
+Large_explicit_defaultedIn_defaultedOut::Large_explicit_defaultedIn_defaultedOut (void)
+{
+ data[0] = 2;
+ data[149] = 2;
+}
+
+Large_explicit_defaultedIn_defaultedOut::Large_explicit_defaultedIn_defaultedOut (const Large_explicit_defaultedIn_defaultedOut &rhs)
+{
+ data[0] = 3;
+ data[149] = 3;
+ tracer = 5;
+}
+Large_explicit_defaultedIn_defaultedOut::Large_explicit_defaultedIn_defaultedOut (Large_explicit_defaultedIn_defaultedOut &&rhs) = default;
+
+
+Large_explicit_defaultedIn_defaultedOut Large_explicit_defaultedIn_defaultedOut_var; /* global var */
+
+template int cbv<Large_explicit_defaultedIn_defaultedOut> (Large_explicit_defaultedIn_defaultedOut arg);
+/*** Class derived from Small_explicit_defaultedIn_defaultedOut ***/
+class Derived_explicit_defaultedIn_defaultedOut : public Small_explicit_defaultedIn_defaultedOut {
+public:
+};
+
+Derived_explicit_defaultedIn_defaultedOut Derived_explicit_defaultedIn_defaultedOut_var; /* global var */
+
+template int cbv<Derived_explicit_defaultedIn_defaultedOut> (Derived_explicit_defaultedIn_defaultedOut arg);
+/*** Class that contains Small_explicit_defaultedIn_defaultedOut ***/
+class Container_explicit_defaultedIn_defaultedOut {
+public:
+ Small_explicit_defaultedIn_defaultedOut item;
+};
+
+Container_explicit_defaultedIn_defaultedOut Container_explicit_defaultedIn_defaultedOut_var; /* global var */
+
+template int cbv_container<Container_explicit_defaultedIn_defaultedOut> (Container_explicit_defaultedIn_defaultedOut arg);
+/*** C++ class Small_explicit_defaultedIn_deleted ***/
+class Small_explicit_defaultedIn_deleted {
+public:
+ Small_explicit_defaultedIn_deleted (void);
+ Small_explicit_defaultedIn_deleted (const Small_explicit_defaultedIn_deleted &rhs);
+ ~Small_explicit_defaultedIn_deleted (void) = default;
+ Small_explicit_defaultedIn_deleted (Small_explicit_defaultedIn_deleted &&rhs) = delete;
+
+
+ int data[2];
+};
+
+Small_explicit_defaultedIn_deleted::Small_explicit_defaultedIn_deleted (void)
+{
+ data[0] = 2;
+ data[1] = 2;
+}
+
+Small_explicit_defaultedIn_deleted::Small_explicit_defaultedIn_deleted (const Small_explicit_defaultedIn_deleted &rhs)
+{
+ data[0] = 3;
+ data[1] = 3;
+ tracer = 5;
+}
+
+
+Small_explicit_defaultedIn_deleted Small_explicit_defaultedIn_deleted_var; /* global var */
+
+template int cbv<Small_explicit_defaultedIn_deleted> (Small_explicit_defaultedIn_deleted arg);
+/*** C++ class Large_explicit_defaultedIn_deleted ***/
+class Large_explicit_defaultedIn_deleted {
+public:
+ Large_explicit_defaultedIn_deleted (void);
+ Large_explicit_defaultedIn_deleted (const Large_explicit_defaultedIn_deleted &rhs);
+ ~Large_explicit_defaultedIn_deleted (void) = default;
+ Large_explicit_defaultedIn_deleted (Large_explicit_defaultedIn_deleted &&rhs) = delete;
+
+
+ int data[150];
+};
+
+Large_explicit_defaultedIn_deleted::Large_explicit_defaultedIn_deleted (void)
+{
+ data[0] = 2;
+ data[149] = 2;
+}
+
+Large_explicit_defaultedIn_deleted::Large_explicit_defaultedIn_deleted (const Large_explicit_defaultedIn_deleted &rhs)
+{
+ data[0] = 3;
+ data[149] = 3;
+ tracer = 5;
+}
+
+
+Large_explicit_defaultedIn_deleted Large_explicit_defaultedIn_deleted_var; /* global var */
+
+template int cbv<Large_explicit_defaultedIn_deleted> (Large_explicit_defaultedIn_deleted arg);
+/*** Class derived from Small_explicit_defaultedIn_deleted ***/
+class Derived_explicit_defaultedIn_deleted : public Small_explicit_defaultedIn_deleted {
+public:
+};
+
+Derived_explicit_defaultedIn_deleted Derived_explicit_defaultedIn_deleted_var; /* global var */
+
+template int cbv<Derived_explicit_defaultedIn_deleted> (Derived_explicit_defaultedIn_deleted arg);
+/*** Class that contains Small_explicit_defaultedIn_deleted ***/
+class Container_explicit_defaultedIn_deleted {
+public:
+ Small_explicit_defaultedIn_deleted item;
+};
+
+Container_explicit_defaultedIn_deleted Container_explicit_defaultedIn_deleted_var; /* global var */
+
+template int cbv_container<Container_explicit_defaultedIn_deleted> (Container_explicit_defaultedIn_deleted arg);
+/*** C++ class Small_explicit_defaultedOut_absent ***/
+class Small_explicit_defaultedOut_absent {
+public:
+ Small_explicit_defaultedOut_absent (void);
+ Small_explicit_defaultedOut_absent (const Small_explicit_defaultedOut_absent &rhs);
+ ~Small_explicit_defaultedOut_absent (void);
+
+
+ int data[2];
+};
+
+Small_explicit_defaultedOut_absent::Small_explicit_defaultedOut_absent (void)
+{
+ data[0] = 2;
+ data[1] = 2;
+}
+
+Small_explicit_defaultedOut_absent::Small_explicit_defaultedOut_absent (const Small_explicit_defaultedOut_absent &rhs)
+{
+ data[0] = 3;
+ data[1] = 3;
+ tracer = 5;
+}
+Small_explicit_defaultedOut_absent::~Small_explicit_defaultedOut_absent (void) = default;
+
+
+Small_explicit_defaultedOut_absent Small_explicit_defaultedOut_absent_var; /* global var */
+
+template int cbv<Small_explicit_defaultedOut_absent> (Small_explicit_defaultedOut_absent arg);
+/*** C++ class Large_explicit_defaultedOut_absent ***/
+class Large_explicit_defaultedOut_absent {
+public:
+ Large_explicit_defaultedOut_absent (void);
+ Large_explicit_defaultedOut_absent (const Large_explicit_defaultedOut_absent &rhs);
+ ~Large_explicit_defaultedOut_absent (void);
+
+
+ int data[150];
+};
+
+Large_explicit_defaultedOut_absent::Large_explicit_defaultedOut_absent (void)
+{
+ data[0] = 2;
+ data[149] = 2;
+}
+
+Large_explicit_defaultedOut_absent::Large_explicit_defaultedOut_absent (const Large_explicit_defaultedOut_absent &rhs)
+{
+ data[0] = 3;
+ data[149] = 3;
+ tracer = 5;
+}
+Large_explicit_defaultedOut_absent::~Large_explicit_defaultedOut_absent (void) = default;
+
+
+Large_explicit_defaultedOut_absent Large_explicit_defaultedOut_absent_var; /* global var */
+
+template int cbv<Large_explicit_defaultedOut_absent> (Large_explicit_defaultedOut_absent arg);
+/*** Class derived from Small_explicit_defaultedOut_absent ***/
+class Derived_explicit_defaultedOut_absent : public Small_explicit_defaultedOut_absent {
+public:
+};
+
+Derived_explicit_defaultedOut_absent Derived_explicit_defaultedOut_absent_var; /* global var */
+
+template int cbv<Derived_explicit_defaultedOut_absent> (Derived_explicit_defaultedOut_absent arg);
+/*** Class that contains Small_explicit_defaultedOut_absent ***/
+class Container_explicit_defaultedOut_absent {
+public:
+ Small_explicit_defaultedOut_absent item;
+};
+
+Container_explicit_defaultedOut_absent Container_explicit_defaultedOut_absent_var; /* global var */
+
+template int cbv_container<Container_explicit_defaultedOut_absent> (Container_explicit_defaultedOut_absent arg);
+/*** C++ class Small_explicit_defaultedOut_explicit ***/
+class Small_explicit_defaultedOut_explicit {
+public:
+ Small_explicit_defaultedOut_explicit (void);
+ Small_explicit_defaultedOut_explicit (const Small_explicit_defaultedOut_explicit &rhs);
+ ~Small_explicit_defaultedOut_explicit (void);
+ Small_explicit_defaultedOut_explicit (Small_explicit_defaultedOut_explicit &&rhs);
+
+
+ int data[2];
+};
+
+Small_explicit_defaultedOut_explicit::Small_explicit_defaultedOut_explicit (void)
+{
+ data[0] = 2;
+ data[1] = 2;
+}
+
+Small_explicit_defaultedOut_explicit::Small_explicit_defaultedOut_explicit (const Small_explicit_defaultedOut_explicit &rhs)
+{
+ data[0] = 3;
+ data[1] = 3;
+ tracer = 5;
+}
+Small_explicit_defaultedOut_explicit::~Small_explicit_defaultedOut_explicit (void) = default;
+Small_explicit_defaultedOut_explicit::Small_explicit_defaultedOut_explicit (Small_explicit_defaultedOut_explicit &&rhs)
+{
+ data[0] = 3;
+ data[1] = 3;
+ tracer = 5;
+}
+
+
+Small_explicit_defaultedOut_explicit Small_explicit_defaultedOut_explicit_var; /* global var */
+
+template int cbv<Small_explicit_defaultedOut_explicit> (Small_explicit_defaultedOut_explicit arg);
+/*** C++ class Large_explicit_defaultedOut_explicit ***/
+class Large_explicit_defaultedOut_explicit {
+public:
+ Large_explicit_defaultedOut_explicit (void);
+ Large_explicit_defaultedOut_explicit (const Large_explicit_defaultedOut_explicit &rhs);
+ ~Large_explicit_defaultedOut_explicit (void);
+ Large_explicit_defaultedOut_explicit (Large_explicit_defaultedOut_explicit &&rhs);
+
+
+ int data[150];
+};
+
+Large_explicit_defaultedOut_explicit::Large_explicit_defaultedOut_explicit (void)
+{
+ data[0] = 2;
+ data[149] = 2;
+}
+
+Large_explicit_defaultedOut_explicit::Large_explicit_defaultedOut_explicit (const Large_explicit_defaultedOut_explicit &rhs)
+{
+ data[0] = 3;
+ data[149] = 3;
+ tracer = 5;
+}
+Large_explicit_defaultedOut_explicit::~Large_explicit_defaultedOut_explicit (void) = default;
+Large_explicit_defaultedOut_explicit::Large_explicit_defaultedOut_explicit (Large_explicit_defaultedOut_explicit &&rhs)
+{
+ data[0] = 3;
+ data[149] = 3;
+ tracer = 5;
+}
+
+
+Large_explicit_defaultedOut_explicit Large_explicit_defaultedOut_explicit_var; /* global var */
+
+template int cbv<Large_explicit_defaultedOut_explicit> (Large_explicit_defaultedOut_explicit arg);
+/*** Class derived from Small_explicit_defaultedOut_explicit ***/
+class Derived_explicit_defaultedOut_explicit : public Small_explicit_defaultedOut_explicit {
+public:
+};
+
+Derived_explicit_defaultedOut_explicit Derived_explicit_defaultedOut_explicit_var; /* global var */
+
+template int cbv<Derived_explicit_defaultedOut_explicit> (Derived_explicit_defaultedOut_explicit arg);
+/*** Class that contains Small_explicit_defaultedOut_explicit ***/
+class Container_explicit_defaultedOut_explicit {
+public:
+ Small_explicit_defaultedOut_explicit item;
+};
+
+Container_explicit_defaultedOut_explicit Container_explicit_defaultedOut_explicit_var; /* global var */
+
+template int cbv_container<Container_explicit_defaultedOut_explicit> (Container_explicit_defaultedOut_explicit arg);
+/*** C++ class Small_explicit_defaultedOut_defaultedIn ***/
+class Small_explicit_defaultedOut_defaultedIn {
+public:
+ Small_explicit_defaultedOut_defaultedIn (void);
+ Small_explicit_defaultedOut_defaultedIn (const Small_explicit_defaultedOut_defaultedIn &rhs);
+ ~Small_explicit_defaultedOut_defaultedIn (void);
+ Small_explicit_defaultedOut_defaultedIn (Small_explicit_defaultedOut_defaultedIn &&rhs) = default;
+
+
+ int data[2];
+};
+
+Small_explicit_defaultedOut_defaultedIn::Small_explicit_defaultedOut_defaultedIn (void)
+{
+ data[0] = 2;
+ data[1] = 2;
+}
+
+Small_explicit_defaultedOut_defaultedIn::Small_explicit_defaultedOut_defaultedIn (const Small_explicit_defaultedOut_defaultedIn &rhs)
+{
+ data[0] = 3;
+ data[1] = 3;
+ tracer = 5;
+}
+Small_explicit_defaultedOut_defaultedIn::~Small_explicit_defaultedOut_defaultedIn (void) = default;
+
+
+Small_explicit_defaultedOut_defaultedIn Small_explicit_defaultedOut_defaultedIn_var; /* global var */
+
+template int cbv<Small_explicit_defaultedOut_defaultedIn> (Small_explicit_defaultedOut_defaultedIn arg);
+/*** C++ class Large_explicit_defaultedOut_defaultedIn ***/
+class Large_explicit_defaultedOut_defaultedIn {
+public:
+ Large_explicit_defaultedOut_defaultedIn (void);
+ Large_explicit_defaultedOut_defaultedIn (const Large_explicit_defaultedOut_defaultedIn &rhs);
+ ~Large_explicit_defaultedOut_defaultedIn (void);
+ Large_explicit_defaultedOut_defaultedIn (Large_explicit_defaultedOut_defaultedIn &&rhs) = default;
+
+
+ int data[150];
+};
+
+Large_explicit_defaultedOut_defaultedIn::Large_explicit_defaultedOut_defaultedIn (void)
+{
+ data[0] = 2;
+ data[149] = 2;
+}
+
+Large_explicit_defaultedOut_defaultedIn::Large_explicit_defaultedOut_defaultedIn (const Large_explicit_defaultedOut_defaultedIn &rhs)
+{
+ data[0] = 3;
+ data[149] = 3;
+ tracer = 5;
+}
+Large_explicit_defaultedOut_defaultedIn::~Large_explicit_defaultedOut_defaultedIn (void) = default;
+
+
+Large_explicit_defaultedOut_defaultedIn Large_explicit_defaultedOut_defaultedIn_var; /* global var */
+
+template int cbv<Large_explicit_defaultedOut_defaultedIn> (Large_explicit_defaultedOut_defaultedIn arg);
+/*** Class derived from Small_explicit_defaultedOut_defaultedIn ***/
+class Derived_explicit_defaultedOut_defaultedIn : public Small_explicit_defaultedOut_defaultedIn {
+public:
+};
+
+Derived_explicit_defaultedOut_defaultedIn Derived_explicit_defaultedOut_defaultedIn_var; /* global var */
+
+template int cbv<Derived_explicit_defaultedOut_defaultedIn> (Derived_explicit_defaultedOut_defaultedIn arg);
+/*** Class that contains Small_explicit_defaultedOut_defaultedIn ***/
+class Container_explicit_defaultedOut_defaultedIn {
+public:
+ Small_explicit_defaultedOut_defaultedIn item;
+};
+
+Container_explicit_defaultedOut_defaultedIn Container_explicit_defaultedOut_defaultedIn_var; /* global var */
+
+template int cbv_container<Container_explicit_defaultedOut_defaultedIn> (Container_explicit_defaultedOut_defaultedIn arg);
+/*** C++ class Small_explicit_defaultedOut_defaultedOut ***/
+class Small_explicit_defaultedOut_defaultedOut {
+public:
+ Small_explicit_defaultedOut_defaultedOut (void);
+ Small_explicit_defaultedOut_defaultedOut (const Small_explicit_defaultedOut_defaultedOut &rhs);
+ ~Small_explicit_defaultedOut_defaultedOut (void);
+ Small_explicit_defaultedOut_defaultedOut (Small_explicit_defaultedOut_defaultedOut &&rhs);
+
+
+ int data[2];
+};
+
+Small_explicit_defaultedOut_defaultedOut::Small_explicit_defaultedOut_defaultedOut (void)
+{
+ data[0] = 2;
+ data[1] = 2;
+}
+
+Small_explicit_defaultedOut_defaultedOut::Small_explicit_defaultedOut_defaultedOut (const Small_explicit_defaultedOut_defaultedOut &rhs)
+{
+ data[0] = 3;
+ data[1] = 3;
+ tracer = 5;
+}
+Small_explicit_defaultedOut_defaultedOut::~Small_explicit_defaultedOut_defaultedOut (void) = default;
+Small_explicit_defaultedOut_defaultedOut::Small_explicit_defaultedOut_defaultedOut (Small_explicit_defaultedOut_defaultedOut &&rhs) = default;
+
+
+Small_explicit_defaultedOut_defaultedOut Small_explicit_defaultedOut_defaultedOut_var; /* global var */
+
+template int cbv<Small_explicit_defaultedOut_defaultedOut> (Small_explicit_defaultedOut_defaultedOut arg);
+/*** C++ class Large_explicit_defaultedOut_defaultedOut ***/
+class Large_explicit_defaultedOut_defaultedOut {
+public:
+ Large_explicit_defaultedOut_defaultedOut (void);
+ Large_explicit_defaultedOut_defaultedOut (const Large_explicit_defaultedOut_defaultedOut &rhs);
+ ~Large_explicit_defaultedOut_defaultedOut (void);
+ Large_explicit_defaultedOut_defaultedOut (Large_explicit_defaultedOut_defaultedOut &&rhs);
+
+
+ int data[150];
+};
+
+Large_explicit_defaultedOut_defaultedOut::Large_explicit_defaultedOut_defaultedOut (void)
+{
+ data[0] = 2;
+ data[149] = 2;
+}
+
+Large_explicit_defaultedOut_defaultedOut::Large_explicit_defaultedOut_defaultedOut (const Large_explicit_defaultedOut_defaultedOut &rhs)
+{
+ data[0] = 3;
+ data[149] = 3;
+ tracer = 5;
+}
+Large_explicit_defaultedOut_defaultedOut::~Large_explicit_defaultedOut_defaultedOut (void) = default;
+Large_explicit_defaultedOut_defaultedOut::Large_explicit_defaultedOut_defaultedOut (Large_explicit_defaultedOut_defaultedOut &&rhs) = default;
+
+
+Large_explicit_defaultedOut_defaultedOut Large_explicit_defaultedOut_defaultedOut_var; /* global var */
+
+template int cbv<Large_explicit_defaultedOut_defaultedOut> (Large_explicit_defaultedOut_defaultedOut arg);
+/*** Class derived from Small_explicit_defaultedOut_defaultedOut ***/
+class Derived_explicit_defaultedOut_defaultedOut : public Small_explicit_defaultedOut_defaultedOut {
+public:
+};
+
+Derived_explicit_defaultedOut_defaultedOut Derived_explicit_defaultedOut_defaultedOut_var; /* global var */
+
+template int cbv<Derived_explicit_defaultedOut_defaultedOut> (Derived_explicit_defaultedOut_defaultedOut arg);
+/*** Class that contains Small_explicit_defaultedOut_defaultedOut ***/
+class Container_explicit_defaultedOut_defaultedOut {
+public:
+ Small_explicit_defaultedOut_defaultedOut item;
+};
+
+Container_explicit_defaultedOut_defaultedOut Container_explicit_defaultedOut_defaultedOut_var; /* global var */
+
+template int cbv_container<Container_explicit_defaultedOut_defaultedOut> (Container_explicit_defaultedOut_defaultedOut arg);
+/*** C++ class Small_explicit_defaultedOut_deleted ***/
+class Small_explicit_defaultedOut_deleted {
+public:
+ Small_explicit_defaultedOut_deleted (void);
+ Small_explicit_defaultedOut_deleted (const Small_explicit_defaultedOut_deleted &rhs);
+ ~Small_explicit_defaultedOut_deleted (void);
+ Small_explicit_defaultedOut_deleted (Small_explicit_defaultedOut_deleted &&rhs) = delete;
+
+
+ int data[2];
+};
+
+Small_explicit_defaultedOut_deleted::Small_explicit_defaultedOut_deleted (void)
+{
+ data[0] = 2;
+ data[1] = 2;
+}
+
+Small_explicit_defaultedOut_deleted::Small_explicit_defaultedOut_deleted (const Small_explicit_defaultedOut_deleted &rhs)
+{
+ data[0] = 3;
+ data[1] = 3;
+ tracer = 5;
+}
+Small_explicit_defaultedOut_deleted::~Small_explicit_defaultedOut_deleted (void) = default;
+
+
+Small_explicit_defaultedOut_deleted Small_explicit_defaultedOut_deleted_var; /* global var */
+
+template int cbv<Small_explicit_defaultedOut_deleted> (Small_explicit_defaultedOut_deleted arg);
+/*** C++ class Large_explicit_defaultedOut_deleted ***/
+class Large_explicit_defaultedOut_deleted {
+public:
+ Large_explicit_defaultedOut_deleted (void);
+ Large_explicit_defaultedOut_deleted (const Large_explicit_defaultedOut_deleted &rhs);
+ ~Large_explicit_defaultedOut_deleted (void);
+ Large_explicit_defaultedOut_deleted (Large_explicit_defaultedOut_deleted &&rhs) = delete;
+
+
+ int data[150];
+};
+
+Large_explicit_defaultedOut_deleted::Large_explicit_defaultedOut_deleted (void)
+{
+ data[0] = 2;
+ data[149] = 2;
+}
+
+Large_explicit_defaultedOut_deleted::Large_explicit_defaultedOut_deleted (const Large_explicit_defaultedOut_deleted &rhs)
+{
+ data[0] = 3;
+ data[149] = 3;
+ tracer = 5;
+}
+Large_explicit_defaultedOut_deleted::~Large_explicit_defaultedOut_deleted (void) = default;
+
+
+Large_explicit_defaultedOut_deleted Large_explicit_defaultedOut_deleted_var; /* global var */
+
+template int cbv<Large_explicit_defaultedOut_deleted> (Large_explicit_defaultedOut_deleted arg);
+/*** Class derived from Small_explicit_defaultedOut_deleted ***/
+class Derived_explicit_defaultedOut_deleted : public Small_explicit_defaultedOut_deleted {
+public:
+};
+
+Derived_explicit_defaultedOut_deleted Derived_explicit_defaultedOut_deleted_var; /* global var */
+
+template int cbv<Derived_explicit_defaultedOut_deleted> (Derived_explicit_defaultedOut_deleted arg);
+/*** Class that contains Small_explicit_defaultedOut_deleted ***/
+class Container_explicit_defaultedOut_deleted {
+public:
+ Small_explicit_defaultedOut_deleted item;
+};
+
+Container_explicit_defaultedOut_deleted Container_explicit_defaultedOut_deleted_var; /* global var */
+
+template int cbv_container<Container_explicit_defaultedOut_deleted> (Container_explicit_defaultedOut_deleted arg);
+/*** C++ class Small_defaultedIn_absent_absent ***/
+class Small_defaultedIn_absent_absent {
+public:
+ Small_defaultedIn_absent_absent (void);
+ Small_defaultedIn_absent_absent (const Small_defaultedIn_absent_absent &rhs) = default;
+
+
+ int data[2];
+};
+
+Small_defaultedIn_absent_absent::Small_defaultedIn_absent_absent (void)
+{
+ data[0] = 2;
+ data[1] = 2;
+}
+
+
+
+Small_defaultedIn_absent_absent Small_defaultedIn_absent_absent_var; /* global var */
+
+template int cbv<Small_defaultedIn_absent_absent> (Small_defaultedIn_absent_absent arg);
+/*** C++ class Large_defaultedIn_absent_absent ***/
+class Large_defaultedIn_absent_absent {
+public:
+ Large_defaultedIn_absent_absent (void);
+ Large_defaultedIn_absent_absent (const Large_defaultedIn_absent_absent &rhs) = default;
+
+
+ int data[150];
+};
+
+Large_defaultedIn_absent_absent::Large_defaultedIn_absent_absent (void)
+{
+ data[0] = 2;
+ data[149] = 2;
+}
+
+
+
+Large_defaultedIn_absent_absent Large_defaultedIn_absent_absent_var; /* global var */
+
+template int cbv<Large_defaultedIn_absent_absent> (Large_defaultedIn_absent_absent arg);
+/*** Class derived from Small_defaultedIn_absent_absent ***/
+class Derived_defaultedIn_absent_absent : public Small_defaultedIn_absent_absent {
+public:
+};
+
+Derived_defaultedIn_absent_absent Derived_defaultedIn_absent_absent_var; /* global var */
+
+template int cbv<Derived_defaultedIn_absent_absent> (Derived_defaultedIn_absent_absent arg);
+/*** Class that contains Small_defaultedIn_absent_absent ***/
+class Container_defaultedIn_absent_absent {
+public:
+ Small_defaultedIn_absent_absent item;
+};
+
+Container_defaultedIn_absent_absent Container_defaultedIn_absent_absent_var; /* global var */
+
+template int cbv_container<Container_defaultedIn_absent_absent> (Container_defaultedIn_absent_absent arg);
+/*** C++ class Small_defaultedIn_absent_explicit ***/
+class Small_defaultedIn_absent_explicit {
+public:
+ Small_defaultedIn_absent_explicit (void);
+ Small_defaultedIn_absent_explicit (const Small_defaultedIn_absent_explicit &rhs) = default;
+ Small_defaultedIn_absent_explicit (Small_defaultedIn_absent_explicit &&rhs);
+
+
+ int data[2];
+};
+
+Small_defaultedIn_absent_explicit::Small_defaultedIn_absent_explicit (void)
+{
+ data[0] = 2;
+ data[1] = 2;
+}
+
+Small_defaultedIn_absent_explicit::Small_defaultedIn_absent_explicit (Small_defaultedIn_absent_explicit &&rhs)
+{
+ data[0] = 3;
+ data[1] = 3;
+ tracer = 5;
+}
+
+
+Small_defaultedIn_absent_explicit Small_defaultedIn_absent_explicit_var; /* global var */
+
+template int cbv<Small_defaultedIn_absent_explicit> (Small_defaultedIn_absent_explicit arg);
+/*** C++ class Large_defaultedIn_absent_explicit ***/
+class Large_defaultedIn_absent_explicit {
+public:
+ Large_defaultedIn_absent_explicit (void);
+ Large_defaultedIn_absent_explicit (const Large_defaultedIn_absent_explicit &rhs) = default;
+ Large_defaultedIn_absent_explicit (Large_defaultedIn_absent_explicit &&rhs);
+
+
+ int data[150];
+};
+
+Large_defaultedIn_absent_explicit::Large_defaultedIn_absent_explicit (void)
+{
+ data[0] = 2;
+ data[149] = 2;
+}
+
+Large_defaultedIn_absent_explicit::Large_defaultedIn_absent_explicit (Large_defaultedIn_absent_explicit &&rhs)
+{
+ data[0] = 3;
+ data[149] = 3;
+ tracer = 5;
+}
+
+
+Large_defaultedIn_absent_explicit Large_defaultedIn_absent_explicit_var; /* global var */
+
+template int cbv<Large_defaultedIn_absent_explicit> (Large_defaultedIn_absent_explicit arg);
+/*** Class derived from Small_defaultedIn_absent_explicit ***/
+class Derived_defaultedIn_absent_explicit : public Small_defaultedIn_absent_explicit {
+public:
+};
+
+Derived_defaultedIn_absent_explicit Derived_defaultedIn_absent_explicit_var; /* global var */
+
+template int cbv<Derived_defaultedIn_absent_explicit> (Derived_defaultedIn_absent_explicit arg);
+/*** Class that contains Small_defaultedIn_absent_explicit ***/
+class Container_defaultedIn_absent_explicit {
+public:
+ Small_defaultedIn_absent_explicit item;
+};
+
+Container_defaultedIn_absent_explicit Container_defaultedIn_absent_explicit_var; /* global var */
+
+template int cbv_container<Container_defaultedIn_absent_explicit> (Container_defaultedIn_absent_explicit arg);
+/*** C++ class Small_defaultedIn_absent_defaultedIn ***/
+class Small_defaultedIn_absent_defaultedIn {
+public:
+ Small_defaultedIn_absent_defaultedIn (void);
+ Small_defaultedIn_absent_defaultedIn (const Small_defaultedIn_absent_defaultedIn &rhs) = default;
+ Small_defaultedIn_absent_defaultedIn (Small_defaultedIn_absent_defaultedIn &&rhs) = default;
+
+
+ int data[2];
+};
+
+Small_defaultedIn_absent_defaultedIn::Small_defaultedIn_absent_defaultedIn (void)
+{
+ data[0] = 2;
+ data[1] = 2;
+}
+
+
+
+Small_defaultedIn_absent_defaultedIn Small_defaultedIn_absent_defaultedIn_var; /* global var */
+
+template int cbv<Small_defaultedIn_absent_defaultedIn> (Small_defaultedIn_absent_defaultedIn arg);
+/*** C++ class Large_defaultedIn_absent_defaultedIn ***/
+class Large_defaultedIn_absent_defaultedIn {
+public:
+ Large_defaultedIn_absent_defaultedIn (void);
+ Large_defaultedIn_absent_defaultedIn (const Large_defaultedIn_absent_defaultedIn &rhs) = default;
+ Large_defaultedIn_absent_defaultedIn (Large_defaultedIn_absent_defaultedIn &&rhs) = default;
+
+
+ int data[150];
+};
+
+Large_defaultedIn_absent_defaultedIn::Large_defaultedIn_absent_defaultedIn (void)
+{
+ data[0] = 2;
+ data[149] = 2;
+}
+
+
+
+Large_defaultedIn_absent_defaultedIn Large_defaultedIn_absent_defaultedIn_var; /* global var */
+
+template int cbv<Large_defaultedIn_absent_defaultedIn> (Large_defaultedIn_absent_defaultedIn arg);
+/*** Class derived from Small_defaultedIn_absent_defaultedIn ***/
+class Derived_defaultedIn_absent_defaultedIn : public Small_defaultedIn_absent_defaultedIn {
+public:
+};
+
+Derived_defaultedIn_absent_defaultedIn Derived_defaultedIn_absent_defaultedIn_var; /* global var */
+
+template int cbv<Derived_defaultedIn_absent_defaultedIn> (Derived_defaultedIn_absent_defaultedIn arg);
+/*** Class that contains Small_defaultedIn_absent_defaultedIn ***/
+class Container_defaultedIn_absent_defaultedIn {
+public:
+ Small_defaultedIn_absent_defaultedIn item;
+};
+
+Container_defaultedIn_absent_defaultedIn Container_defaultedIn_absent_defaultedIn_var; /* global var */
+
+template int cbv_container<Container_defaultedIn_absent_defaultedIn> (Container_defaultedIn_absent_defaultedIn arg);
+/*** C++ class Small_defaultedIn_absent_defaultedOut ***/
+class Small_defaultedIn_absent_defaultedOut {
+public:
+ Small_defaultedIn_absent_defaultedOut (void);
+ Small_defaultedIn_absent_defaultedOut (const Small_defaultedIn_absent_defaultedOut &rhs) = default;
+ Small_defaultedIn_absent_defaultedOut (Small_defaultedIn_absent_defaultedOut &&rhs);
+
+
+ int data[2];
+};
+
+Small_defaultedIn_absent_defaultedOut::Small_defaultedIn_absent_defaultedOut (void)
+{
+ data[0] = 2;
+ data[1] = 2;
+}
+
+Small_defaultedIn_absent_defaultedOut::Small_defaultedIn_absent_defaultedOut (Small_defaultedIn_absent_defaultedOut &&rhs) = default;
+
+
+Small_defaultedIn_absent_defaultedOut Small_defaultedIn_absent_defaultedOut_var; /* global var */
+
+template int cbv<Small_defaultedIn_absent_defaultedOut> (Small_defaultedIn_absent_defaultedOut arg);
+/*** C++ class Large_defaultedIn_absent_defaultedOut ***/
+class Large_defaultedIn_absent_defaultedOut {
+public:
+ Large_defaultedIn_absent_defaultedOut (void);
+ Large_defaultedIn_absent_defaultedOut (const Large_defaultedIn_absent_defaultedOut &rhs) = default;
+ Large_defaultedIn_absent_defaultedOut (Large_defaultedIn_absent_defaultedOut &&rhs);
+
+
+ int data[150];
+};
+
+Large_defaultedIn_absent_defaultedOut::Large_defaultedIn_absent_defaultedOut (void)
+{
+ data[0] = 2;
+ data[149] = 2;
+}
+
+Large_defaultedIn_absent_defaultedOut::Large_defaultedIn_absent_defaultedOut (Large_defaultedIn_absent_defaultedOut &&rhs) = default;
+
+
+Large_defaultedIn_absent_defaultedOut Large_defaultedIn_absent_defaultedOut_var; /* global var */
+
+template int cbv<Large_defaultedIn_absent_defaultedOut> (Large_defaultedIn_absent_defaultedOut arg);
+/*** Class derived from Small_defaultedIn_absent_defaultedOut ***/
+class Derived_defaultedIn_absent_defaultedOut : public Small_defaultedIn_absent_defaultedOut {
+public:
+};
+
+Derived_defaultedIn_absent_defaultedOut Derived_defaultedIn_absent_defaultedOut_var; /* global var */
+
+template int cbv<Derived_defaultedIn_absent_defaultedOut> (Derived_defaultedIn_absent_defaultedOut arg);
+/*** Class that contains Small_defaultedIn_absent_defaultedOut ***/
+class Container_defaultedIn_absent_defaultedOut {
+public:
+ Small_defaultedIn_absent_defaultedOut item;
+};
+
+Container_defaultedIn_absent_defaultedOut Container_defaultedIn_absent_defaultedOut_var; /* global var */
+
+template int cbv_container<Container_defaultedIn_absent_defaultedOut> (Container_defaultedIn_absent_defaultedOut arg);
+/*** C++ class Small_defaultedIn_absent_deleted ***/
+class Small_defaultedIn_absent_deleted {
+public:
+ Small_defaultedIn_absent_deleted (void);
+ Small_defaultedIn_absent_deleted (const Small_defaultedIn_absent_deleted &rhs) = default;
+ Small_defaultedIn_absent_deleted (Small_defaultedIn_absent_deleted &&rhs) = delete;
+
+
+ int data[2];
+};
+
+Small_defaultedIn_absent_deleted::Small_defaultedIn_absent_deleted (void)
+{
+ data[0] = 2;
+ data[1] = 2;
+}
+
+
+
+Small_defaultedIn_absent_deleted Small_defaultedIn_absent_deleted_var; /* global var */
+
+template int cbv<Small_defaultedIn_absent_deleted> (Small_defaultedIn_absent_deleted arg);
+/*** C++ class Large_defaultedIn_absent_deleted ***/
+class Large_defaultedIn_absent_deleted {
+public:
+ Large_defaultedIn_absent_deleted (void);
+ Large_defaultedIn_absent_deleted (const Large_defaultedIn_absent_deleted &rhs) = default;
+ Large_defaultedIn_absent_deleted (Large_defaultedIn_absent_deleted &&rhs) = delete;
+
+
+ int data[150];
+};
+
+Large_defaultedIn_absent_deleted::Large_defaultedIn_absent_deleted (void)
+{
+ data[0] = 2;
+ data[149] = 2;
+}
+
+
+
+Large_defaultedIn_absent_deleted Large_defaultedIn_absent_deleted_var; /* global var */
+
+template int cbv<Large_defaultedIn_absent_deleted> (Large_defaultedIn_absent_deleted arg);
+/*** Class derived from Small_defaultedIn_absent_deleted ***/
+class Derived_defaultedIn_absent_deleted : public Small_defaultedIn_absent_deleted {
+public:
+};
+
+Derived_defaultedIn_absent_deleted Derived_defaultedIn_absent_deleted_var; /* global var */
+
+template int cbv<Derived_defaultedIn_absent_deleted> (Derived_defaultedIn_absent_deleted arg);
+/*** Class that contains Small_defaultedIn_absent_deleted ***/
+class Container_defaultedIn_absent_deleted {
+public:
+ Small_defaultedIn_absent_deleted item;
+};
+
+Container_defaultedIn_absent_deleted Container_defaultedIn_absent_deleted_var; /* global var */
+
+template int cbv_container<Container_defaultedIn_absent_deleted> (Container_defaultedIn_absent_deleted arg);
+/*** C++ class Small_defaultedIn_explicit_absent ***/
+class Small_defaultedIn_explicit_absent {
+public:
+ Small_defaultedIn_explicit_absent (void);
+ Small_defaultedIn_explicit_absent (const Small_defaultedIn_explicit_absent &rhs) = default;
+ ~Small_defaultedIn_explicit_absent (void);
+
+
+ int data[2];
+};
+
+Small_defaultedIn_explicit_absent::Small_defaultedIn_explicit_absent (void)
+{
+ data[0] = 2;
+ data[1] = 2;
+}
+
+Small_defaultedIn_explicit_absent::~Small_defaultedIn_explicit_absent (void)
+{
+ data[0] = 3;
+ data[1] = 3;
+ tracer = 5;
+}
+
+
+Small_defaultedIn_explicit_absent Small_defaultedIn_explicit_absent_var; /* global var */
+
+template int cbv<Small_defaultedIn_explicit_absent> (Small_defaultedIn_explicit_absent arg);
+/*** C++ class Large_defaultedIn_explicit_absent ***/
+class Large_defaultedIn_explicit_absent {
+public:
+ Large_defaultedIn_explicit_absent (void);
+ Large_defaultedIn_explicit_absent (const Large_defaultedIn_explicit_absent &rhs) = default;
+ ~Large_defaultedIn_explicit_absent (void);
+
+
+ int data[150];
+};
+
+Large_defaultedIn_explicit_absent::Large_defaultedIn_explicit_absent (void)
+{
+ data[0] = 2;
+ data[149] = 2;
+}
+
+Large_defaultedIn_explicit_absent::~Large_defaultedIn_explicit_absent (void)
+{
+ data[0] = 3;
+ data[149] = 3;
+ tracer = 5;
+}
+
+
+Large_defaultedIn_explicit_absent Large_defaultedIn_explicit_absent_var; /* global var */
+
+template int cbv<Large_defaultedIn_explicit_absent> (Large_defaultedIn_explicit_absent arg);
+/*** Class derived from Small_defaultedIn_explicit_absent ***/
+class Derived_defaultedIn_explicit_absent : public Small_defaultedIn_explicit_absent {
+public:
+};
+
+Derived_defaultedIn_explicit_absent Derived_defaultedIn_explicit_absent_var; /* global var */
+
+template int cbv<Derived_defaultedIn_explicit_absent> (Derived_defaultedIn_explicit_absent arg);
+/*** Class that contains Small_defaultedIn_explicit_absent ***/
+class Container_defaultedIn_explicit_absent {
+public:
+ Small_defaultedIn_explicit_absent item;
+};
+
+Container_defaultedIn_explicit_absent Container_defaultedIn_explicit_absent_var; /* global var */
+
+template int cbv_container<Container_defaultedIn_explicit_absent> (Container_defaultedIn_explicit_absent arg);
+/*** C++ class Small_defaultedIn_explicit_explicit ***/
+class Small_defaultedIn_explicit_explicit {
+public:
+ Small_defaultedIn_explicit_explicit (void);
+ Small_defaultedIn_explicit_explicit (const Small_defaultedIn_explicit_explicit &rhs) = default;
+ ~Small_defaultedIn_explicit_explicit (void);
+ Small_defaultedIn_explicit_explicit (Small_defaultedIn_explicit_explicit &&rhs);
+
+
+ int data[2];
+};
+
+Small_defaultedIn_explicit_explicit::Small_defaultedIn_explicit_explicit (void)
+{
+ data[0] = 2;
+ data[1] = 2;
+}
+
+Small_defaultedIn_explicit_explicit::~Small_defaultedIn_explicit_explicit (void)
+{
+ data[0] = 3;
+ data[1] = 3;
+ tracer = 5;
+}
+Small_defaultedIn_explicit_explicit::Small_defaultedIn_explicit_explicit (Small_defaultedIn_explicit_explicit &&rhs)
+{
+ data[0] = 3;
+ data[1] = 3;
+ tracer = 5;
+}
+
+
+Small_defaultedIn_explicit_explicit Small_defaultedIn_explicit_explicit_var; /* global var */
+
+template int cbv<Small_defaultedIn_explicit_explicit> (Small_defaultedIn_explicit_explicit arg);
+/*** C++ class Large_defaultedIn_explicit_explicit ***/
+class Large_defaultedIn_explicit_explicit {
+public:
+ Large_defaultedIn_explicit_explicit (void);
+ Large_defaultedIn_explicit_explicit (const Large_defaultedIn_explicit_explicit &rhs) = default;
+ ~Large_defaultedIn_explicit_explicit (void);
+ Large_defaultedIn_explicit_explicit (Large_defaultedIn_explicit_explicit &&rhs);
+
+
+ int data[150];
+};
+
+Large_defaultedIn_explicit_explicit::Large_defaultedIn_explicit_explicit (void)
+{
+ data[0] = 2;
+ data[149] = 2;
+}
+
+Large_defaultedIn_explicit_explicit::~Large_defaultedIn_explicit_explicit (void)
+{
+ data[0] = 3;
+ data[149] = 3;
+ tracer = 5;
+}
+Large_defaultedIn_explicit_explicit::Large_defaultedIn_explicit_explicit (Large_defaultedIn_explicit_explicit &&rhs)
+{
+ data[0] = 3;
+ data[149] = 3;
+ tracer = 5;
+}
+
+
+Large_defaultedIn_explicit_explicit Large_defaultedIn_explicit_explicit_var; /* global var */
+
+template int cbv<Large_defaultedIn_explicit_explicit> (Large_defaultedIn_explicit_explicit arg);
+/*** Class derived from Small_defaultedIn_explicit_explicit ***/
+class Derived_defaultedIn_explicit_explicit : public Small_defaultedIn_explicit_explicit {
+public:
+};
+
+Derived_defaultedIn_explicit_explicit Derived_defaultedIn_explicit_explicit_var; /* global var */
+
+template int cbv<Derived_defaultedIn_explicit_explicit> (Derived_defaultedIn_explicit_explicit arg);
+/*** Class that contains Small_defaultedIn_explicit_explicit ***/
+class Container_defaultedIn_explicit_explicit {
+public:
+ Small_defaultedIn_explicit_explicit item;
+};
+
+Container_defaultedIn_explicit_explicit Container_defaultedIn_explicit_explicit_var; /* global var */
+
+template int cbv_container<Container_defaultedIn_explicit_explicit> (Container_defaultedIn_explicit_explicit arg);
+/*** C++ class Small_defaultedIn_explicit_defaultedIn ***/
+class Small_defaultedIn_explicit_defaultedIn {
+public:
+ Small_defaultedIn_explicit_defaultedIn (void);
+ Small_defaultedIn_explicit_defaultedIn (const Small_defaultedIn_explicit_defaultedIn &rhs) = default;
+ ~Small_defaultedIn_explicit_defaultedIn (void);
+ Small_defaultedIn_explicit_defaultedIn (Small_defaultedIn_explicit_defaultedIn &&rhs) = default;
+
+
+ int data[2];
+};
+
+Small_defaultedIn_explicit_defaultedIn::Small_defaultedIn_explicit_defaultedIn (void)
+{
+ data[0] = 2;
+ data[1] = 2;
+}
+
+Small_defaultedIn_explicit_defaultedIn::~Small_defaultedIn_explicit_defaultedIn (void)
+{
+ data[0] = 3;
+ data[1] = 3;
+ tracer = 5;
+}
+
+
+Small_defaultedIn_explicit_defaultedIn Small_defaultedIn_explicit_defaultedIn_var; /* global var */
+
+template int cbv<Small_defaultedIn_explicit_defaultedIn> (Small_defaultedIn_explicit_defaultedIn arg);
+/*** C++ class Large_defaultedIn_explicit_defaultedIn ***/
+class Large_defaultedIn_explicit_defaultedIn {
+public:
+ Large_defaultedIn_explicit_defaultedIn (void);
+ Large_defaultedIn_explicit_defaultedIn (const Large_defaultedIn_explicit_defaultedIn &rhs) = default;
+ ~Large_defaultedIn_explicit_defaultedIn (void);
+ Large_defaultedIn_explicit_defaultedIn (Large_defaultedIn_explicit_defaultedIn &&rhs) = default;
+
+
+ int data[150];
+};
+
+Large_defaultedIn_explicit_defaultedIn::Large_defaultedIn_explicit_defaultedIn (void)
+{
+ data[0] = 2;
+ data[149] = 2;
+}
+
+Large_defaultedIn_explicit_defaultedIn::~Large_defaultedIn_explicit_defaultedIn (void)
+{
+ data[0] = 3;
+ data[149] = 3;
+ tracer = 5;
+}
+
+
+Large_defaultedIn_explicit_defaultedIn Large_defaultedIn_explicit_defaultedIn_var; /* global var */
+
+template int cbv<Large_defaultedIn_explicit_defaultedIn> (Large_defaultedIn_explicit_defaultedIn arg);
+/*** Class derived from Small_defaultedIn_explicit_defaultedIn ***/
+class Derived_defaultedIn_explicit_defaultedIn : public Small_defaultedIn_explicit_defaultedIn {
+public:
+};
+
+Derived_defaultedIn_explicit_defaultedIn Derived_defaultedIn_explicit_defaultedIn_var; /* global var */
+
+template int cbv<Derived_defaultedIn_explicit_defaultedIn> (Derived_defaultedIn_explicit_defaultedIn arg);
+/*** Class that contains Small_defaultedIn_explicit_defaultedIn ***/
+class Container_defaultedIn_explicit_defaultedIn {
+public:
+ Small_defaultedIn_explicit_defaultedIn item;
+};
+
+Container_defaultedIn_explicit_defaultedIn Container_defaultedIn_explicit_defaultedIn_var; /* global var */
+
+template int cbv_container<Container_defaultedIn_explicit_defaultedIn> (Container_defaultedIn_explicit_defaultedIn arg);
+/*** C++ class Small_defaultedIn_explicit_defaultedOut ***/
+class Small_defaultedIn_explicit_defaultedOut {
+public:
+ Small_defaultedIn_explicit_defaultedOut (void);
+ Small_defaultedIn_explicit_defaultedOut (const Small_defaultedIn_explicit_defaultedOut &rhs) = default;
+ ~Small_defaultedIn_explicit_defaultedOut (void);
+ Small_defaultedIn_explicit_defaultedOut (Small_defaultedIn_explicit_defaultedOut &&rhs);
+
+
+ int data[2];
+};
+
+Small_defaultedIn_explicit_defaultedOut::Small_defaultedIn_explicit_defaultedOut (void)
+{
+ data[0] = 2;
+ data[1] = 2;
+}
+
+Small_defaultedIn_explicit_defaultedOut::~Small_defaultedIn_explicit_defaultedOut (void)
+{
+ data[0] = 3;
+ data[1] = 3;
+ tracer = 5;
+}
+Small_defaultedIn_explicit_defaultedOut::Small_defaultedIn_explicit_defaultedOut (Small_defaultedIn_explicit_defaultedOut &&rhs) = default;
+
+
+Small_defaultedIn_explicit_defaultedOut Small_defaultedIn_explicit_defaultedOut_var; /* global var */
+
+template int cbv<Small_defaultedIn_explicit_defaultedOut> (Small_defaultedIn_explicit_defaultedOut arg);
+/*** C++ class Large_defaultedIn_explicit_defaultedOut ***/
+class Large_defaultedIn_explicit_defaultedOut {
+public:
+ Large_defaultedIn_explicit_defaultedOut (void);
+ Large_defaultedIn_explicit_defaultedOut (const Large_defaultedIn_explicit_defaultedOut &rhs) = default;
+ ~Large_defaultedIn_explicit_defaultedOut (void);
+ Large_defaultedIn_explicit_defaultedOut (Large_defaultedIn_explicit_defaultedOut &&rhs);
+
+
+ int data[150];
+};
+
+Large_defaultedIn_explicit_defaultedOut::Large_defaultedIn_explicit_defaultedOut (void)
+{
+ data[0] = 2;
+ data[149] = 2;
+}
+
+Large_defaultedIn_explicit_defaultedOut::~Large_defaultedIn_explicit_defaultedOut (void)
+{
+ data[0] = 3;
+ data[149] = 3;
+ tracer = 5;
+}
+Large_defaultedIn_explicit_defaultedOut::Large_defaultedIn_explicit_defaultedOut (Large_defaultedIn_explicit_defaultedOut &&rhs) = default;
+
+
+Large_defaultedIn_explicit_defaultedOut Large_defaultedIn_explicit_defaultedOut_var; /* global var */
+
+template int cbv<Large_defaultedIn_explicit_defaultedOut> (Large_defaultedIn_explicit_defaultedOut arg);
+/*** Class derived from Small_defaultedIn_explicit_defaultedOut ***/
+class Derived_defaultedIn_explicit_defaultedOut : public Small_defaultedIn_explicit_defaultedOut {
+public:
+};
+
+Derived_defaultedIn_explicit_defaultedOut Derived_defaultedIn_explicit_defaultedOut_var; /* global var */
+
+template int cbv<Derived_defaultedIn_explicit_defaultedOut> (Derived_defaultedIn_explicit_defaultedOut arg);
+/*** Class that contains Small_defaultedIn_explicit_defaultedOut ***/
+class Container_defaultedIn_explicit_defaultedOut {
+public:
+ Small_defaultedIn_explicit_defaultedOut item;
+};
+
+Container_defaultedIn_explicit_defaultedOut Container_defaultedIn_explicit_defaultedOut_var; /* global var */
+
+template int cbv_container<Container_defaultedIn_explicit_defaultedOut> (Container_defaultedIn_explicit_defaultedOut arg);
+/*** C++ class Small_defaultedIn_explicit_deleted ***/
+class Small_defaultedIn_explicit_deleted {
+public:
+ Small_defaultedIn_explicit_deleted (void);
+ Small_defaultedIn_explicit_deleted (const Small_defaultedIn_explicit_deleted &rhs) = default;
+ ~Small_defaultedIn_explicit_deleted (void);
+ Small_defaultedIn_explicit_deleted (Small_defaultedIn_explicit_deleted &&rhs) = delete;
+
+
+ int data[2];
+};
+
+Small_defaultedIn_explicit_deleted::Small_defaultedIn_explicit_deleted (void)
+{
+ data[0] = 2;
+ data[1] = 2;
+}
+
+Small_defaultedIn_explicit_deleted::~Small_defaultedIn_explicit_deleted (void)
+{
+ data[0] = 3;
+ data[1] = 3;
+ tracer = 5;
+}
+
+
+Small_defaultedIn_explicit_deleted Small_defaultedIn_explicit_deleted_var; /* global var */
+
+template int cbv<Small_defaultedIn_explicit_deleted> (Small_defaultedIn_explicit_deleted arg);
+/*** C++ class Large_defaultedIn_explicit_deleted ***/
+class Large_defaultedIn_explicit_deleted {
+public:
+ Large_defaultedIn_explicit_deleted (void);
+ Large_defaultedIn_explicit_deleted (const Large_defaultedIn_explicit_deleted &rhs) = default;
+ ~Large_defaultedIn_explicit_deleted (void);
+ Large_defaultedIn_explicit_deleted (Large_defaultedIn_explicit_deleted &&rhs) = delete;
+
+
+ int data[150];
+};
+
+Large_defaultedIn_explicit_deleted::Large_defaultedIn_explicit_deleted (void)
+{
+ data[0] = 2;
+ data[149] = 2;
+}
+
+Large_defaultedIn_explicit_deleted::~Large_defaultedIn_explicit_deleted (void)
+{
+ data[0] = 3;
+ data[149] = 3;
+ tracer = 5;
+}
+
+
+Large_defaultedIn_explicit_deleted Large_defaultedIn_explicit_deleted_var; /* global var */
+
+template int cbv<Large_defaultedIn_explicit_deleted> (Large_defaultedIn_explicit_deleted arg);
+/*** Class derived from Small_defaultedIn_explicit_deleted ***/
+class Derived_defaultedIn_explicit_deleted : public Small_defaultedIn_explicit_deleted {
+public:
+};
+
+Derived_defaultedIn_explicit_deleted Derived_defaultedIn_explicit_deleted_var; /* global var */
+
+template int cbv<Derived_defaultedIn_explicit_deleted> (Derived_defaultedIn_explicit_deleted arg);
+/*** Class that contains Small_defaultedIn_explicit_deleted ***/
+class Container_defaultedIn_explicit_deleted {
+public:
+ Small_defaultedIn_explicit_deleted item;
+};
+
+Container_defaultedIn_explicit_deleted Container_defaultedIn_explicit_deleted_var; /* global var */
+
+template int cbv_container<Container_defaultedIn_explicit_deleted> (Container_defaultedIn_explicit_deleted arg);
+/*** C++ class Small_defaultedIn_defaultedIn_absent ***/
+class Small_defaultedIn_defaultedIn_absent {
+public:
+ Small_defaultedIn_defaultedIn_absent (void);
+ Small_defaultedIn_defaultedIn_absent (const Small_defaultedIn_defaultedIn_absent &rhs) = default;
+ ~Small_defaultedIn_defaultedIn_absent (void) = default;
+
+
+ int data[2];
+};
+
+Small_defaultedIn_defaultedIn_absent::Small_defaultedIn_defaultedIn_absent (void)
+{
+ data[0] = 2;
+ data[1] = 2;
+}
+
+
+
+Small_defaultedIn_defaultedIn_absent Small_defaultedIn_defaultedIn_absent_var; /* global var */
+
+template int cbv<Small_defaultedIn_defaultedIn_absent> (Small_defaultedIn_defaultedIn_absent arg);
+/*** C++ class Large_defaultedIn_defaultedIn_absent ***/
+class Large_defaultedIn_defaultedIn_absent {
+public:
+ Large_defaultedIn_defaultedIn_absent (void);
+ Large_defaultedIn_defaultedIn_absent (const Large_defaultedIn_defaultedIn_absent &rhs) = default;
+ ~Large_defaultedIn_defaultedIn_absent (void) = default;
+
+
+ int data[150];
+};
+
+Large_defaultedIn_defaultedIn_absent::Large_defaultedIn_defaultedIn_absent (void)
+{
+ data[0] = 2;
+ data[149] = 2;
+}
+
+
+
+Large_defaultedIn_defaultedIn_absent Large_defaultedIn_defaultedIn_absent_var; /* global var */
+
+template int cbv<Large_defaultedIn_defaultedIn_absent> (Large_defaultedIn_defaultedIn_absent arg);
+/*** Class derived from Small_defaultedIn_defaultedIn_absent ***/
+class Derived_defaultedIn_defaultedIn_absent : public Small_defaultedIn_defaultedIn_absent {
+public:
+};
+
+Derived_defaultedIn_defaultedIn_absent Derived_defaultedIn_defaultedIn_absent_var; /* global var */
+
+template int cbv<Derived_defaultedIn_defaultedIn_absent> (Derived_defaultedIn_defaultedIn_absent arg);
+/*** Class that contains Small_defaultedIn_defaultedIn_absent ***/
+class Container_defaultedIn_defaultedIn_absent {
+public:
+ Small_defaultedIn_defaultedIn_absent item;
+};
+
+Container_defaultedIn_defaultedIn_absent Container_defaultedIn_defaultedIn_absent_var; /* global var */
+
+template int cbv_container<Container_defaultedIn_defaultedIn_absent> (Container_defaultedIn_defaultedIn_absent arg);
+/*** C++ class Small_defaultedIn_defaultedIn_explicit ***/
+class Small_defaultedIn_defaultedIn_explicit {
+public:
+ Small_defaultedIn_defaultedIn_explicit (void);
+ Small_defaultedIn_defaultedIn_explicit (const Small_defaultedIn_defaultedIn_explicit &rhs) = default;
+ ~Small_defaultedIn_defaultedIn_explicit (void) = default;
+ Small_defaultedIn_defaultedIn_explicit (Small_defaultedIn_defaultedIn_explicit &&rhs);
+
+
+ int data[2];
+};
+
+Small_defaultedIn_defaultedIn_explicit::Small_defaultedIn_defaultedIn_explicit (void)
+{
+ data[0] = 2;
+ data[1] = 2;
+}
+
+Small_defaultedIn_defaultedIn_explicit::Small_defaultedIn_defaultedIn_explicit (Small_defaultedIn_defaultedIn_explicit &&rhs)
+{
+ data[0] = 3;
+ data[1] = 3;
+ tracer = 5;
+}
+
+
+Small_defaultedIn_defaultedIn_explicit Small_defaultedIn_defaultedIn_explicit_var; /* global var */
+
+template int cbv<Small_defaultedIn_defaultedIn_explicit> (Small_defaultedIn_defaultedIn_explicit arg);
+/*** C++ class Large_defaultedIn_defaultedIn_explicit ***/
+class Large_defaultedIn_defaultedIn_explicit {
+public:
+ Large_defaultedIn_defaultedIn_explicit (void);
+ Large_defaultedIn_defaultedIn_explicit (const Large_defaultedIn_defaultedIn_explicit &rhs) = default;
+ ~Large_defaultedIn_defaultedIn_explicit (void) = default;
+ Large_defaultedIn_defaultedIn_explicit (Large_defaultedIn_defaultedIn_explicit &&rhs);
+
+
+ int data[150];
+};
+
+Large_defaultedIn_defaultedIn_explicit::Large_defaultedIn_defaultedIn_explicit (void)
+{
+ data[0] = 2;
+ data[149] = 2;
+}
+
+Large_defaultedIn_defaultedIn_explicit::Large_defaultedIn_defaultedIn_explicit (Large_defaultedIn_defaultedIn_explicit &&rhs)
+{
+ data[0] = 3;
+ data[149] = 3;
+ tracer = 5;
+}
+
+
+Large_defaultedIn_defaultedIn_explicit Large_defaultedIn_defaultedIn_explicit_var; /* global var */
+
+template int cbv<Large_defaultedIn_defaultedIn_explicit> (Large_defaultedIn_defaultedIn_explicit arg);
+/*** Class derived from Small_defaultedIn_defaultedIn_explicit ***/
+class Derived_defaultedIn_defaultedIn_explicit : public Small_defaultedIn_defaultedIn_explicit {
+public:
+};
+
+Derived_defaultedIn_defaultedIn_explicit Derived_defaultedIn_defaultedIn_explicit_var; /* global var */
+
+template int cbv<Derived_defaultedIn_defaultedIn_explicit> (Derived_defaultedIn_defaultedIn_explicit arg);
+/*** Class that contains Small_defaultedIn_defaultedIn_explicit ***/
+class Container_defaultedIn_defaultedIn_explicit {
+public:
+ Small_defaultedIn_defaultedIn_explicit item;
+};
+
+Container_defaultedIn_defaultedIn_explicit Container_defaultedIn_defaultedIn_explicit_var; /* global var */
+
+template int cbv_container<Container_defaultedIn_defaultedIn_explicit> (Container_defaultedIn_defaultedIn_explicit arg);
+/*** C++ class Small_defaultedIn_defaultedIn_defaultedIn ***/
+class Small_defaultedIn_defaultedIn_defaultedIn {
+public:
+ Small_defaultedIn_defaultedIn_defaultedIn (void);
+ Small_defaultedIn_defaultedIn_defaultedIn (const Small_defaultedIn_defaultedIn_defaultedIn &rhs) = default;
+ ~Small_defaultedIn_defaultedIn_defaultedIn (void) = default;
+ Small_defaultedIn_defaultedIn_defaultedIn (Small_defaultedIn_defaultedIn_defaultedIn &&rhs) = default;
+
+
+ int data[2];
+};
+
+Small_defaultedIn_defaultedIn_defaultedIn::Small_defaultedIn_defaultedIn_defaultedIn (void)
+{
+ data[0] = 2;
+ data[1] = 2;
+}
+
+
+
+Small_defaultedIn_defaultedIn_defaultedIn Small_defaultedIn_defaultedIn_defaultedIn_var; /* global var */
+
+template int cbv<Small_defaultedIn_defaultedIn_defaultedIn> (Small_defaultedIn_defaultedIn_defaultedIn arg);
+/*** C++ class Large_defaultedIn_defaultedIn_defaultedIn ***/
+class Large_defaultedIn_defaultedIn_defaultedIn {
+public:
+ Large_defaultedIn_defaultedIn_defaultedIn (void);
+ Large_defaultedIn_defaultedIn_defaultedIn (const Large_defaultedIn_defaultedIn_defaultedIn &rhs) = default;
+ ~Large_defaultedIn_defaultedIn_defaultedIn (void) = default;
+ Large_defaultedIn_defaultedIn_defaultedIn (Large_defaultedIn_defaultedIn_defaultedIn &&rhs) = default;
+
+
+ int data[150];
+};
+
+Large_defaultedIn_defaultedIn_defaultedIn::Large_defaultedIn_defaultedIn_defaultedIn (void)
+{
+ data[0] = 2;
+ data[149] = 2;
+}
+
+
+
+Large_defaultedIn_defaultedIn_defaultedIn Large_defaultedIn_defaultedIn_defaultedIn_var; /* global var */
+
+template int cbv<Large_defaultedIn_defaultedIn_defaultedIn> (Large_defaultedIn_defaultedIn_defaultedIn arg);
+/*** Class derived from Small_defaultedIn_defaultedIn_defaultedIn ***/
+class Derived_defaultedIn_defaultedIn_defaultedIn : public Small_defaultedIn_defaultedIn_defaultedIn {
+public:
+};
+
+Derived_defaultedIn_defaultedIn_defaultedIn Derived_defaultedIn_defaultedIn_defaultedIn_var; /* global var */
+
+template int cbv<Derived_defaultedIn_defaultedIn_defaultedIn> (Derived_defaultedIn_defaultedIn_defaultedIn arg);
+/*** Class that contains Small_defaultedIn_defaultedIn_defaultedIn ***/
+class Container_defaultedIn_defaultedIn_defaultedIn {
+public:
+ Small_defaultedIn_defaultedIn_defaultedIn item;
+};
+
+Container_defaultedIn_defaultedIn_defaultedIn Container_defaultedIn_defaultedIn_defaultedIn_var; /* global var */
+
+template int cbv_container<Container_defaultedIn_defaultedIn_defaultedIn> (Container_defaultedIn_defaultedIn_defaultedIn arg);
+/*** C++ class Small_defaultedIn_defaultedIn_defaultedOut ***/
+class Small_defaultedIn_defaultedIn_defaultedOut {
+public:
+ Small_defaultedIn_defaultedIn_defaultedOut (void);
+ Small_defaultedIn_defaultedIn_defaultedOut (const Small_defaultedIn_defaultedIn_defaultedOut &rhs) = default;
+ ~Small_defaultedIn_defaultedIn_defaultedOut (void) = default;
+ Small_defaultedIn_defaultedIn_defaultedOut (Small_defaultedIn_defaultedIn_defaultedOut &&rhs);
+
+
+ int data[2];
+};
+
+Small_defaultedIn_defaultedIn_defaultedOut::Small_defaultedIn_defaultedIn_defaultedOut (void)
+{
+ data[0] = 2;
+ data[1] = 2;
+}
+
+Small_defaultedIn_defaultedIn_defaultedOut::Small_defaultedIn_defaultedIn_defaultedOut (Small_defaultedIn_defaultedIn_defaultedOut &&rhs) = default;
+
+
+Small_defaultedIn_defaultedIn_defaultedOut Small_defaultedIn_defaultedIn_defaultedOut_var; /* global var */
+
+template int cbv<Small_defaultedIn_defaultedIn_defaultedOut> (Small_defaultedIn_defaultedIn_defaultedOut arg);
+/*** C++ class Large_defaultedIn_defaultedIn_defaultedOut ***/
+class Large_defaultedIn_defaultedIn_defaultedOut {
+public:
+ Large_defaultedIn_defaultedIn_defaultedOut (void);
+ Large_defaultedIn_defaultedIn_defaultedOut (const Large_defaultedIn_defaultedIn_defaultedOut &rhs) = default;
+ ~Large_defaultedIn_defaultedIn_defaultedOut (void) = default;
+ Large_defaultedIn_defaultedIn_defaultedOut (Large_defaultedIn_defaultedIn_defaultedOut &&rhs);
+
+
+ int data[150];
+};
+
+Large_defaultedIn_defaultedIn_defaultedOut::Large_defaultedIn_defaultedIn_defaultedOut (void)
+{
+ data[0] = 2;
+ data[149] = 2;
+}
+
+Large_defaultedIn_defaultedIn_defaultedOut::Large_defaultedIn_defaultedIn_defaultedOut (Large_defaultedIn_defaultedIn_defaultedOut &&rhs) = default;
+
+
+Large_defaultedIn_defaultedIn_defaultedOut Large_defaultedIn_defaultedIn_defaultedOut_var; /* global var */
+
+template int cbv<Large_defaultedIn_defaultedIn_defaultedOut> (Large_defaultedIn_defaultedIn_defaultedOut arg);
+/*** Class derived from Small_defaultedIn_defaultedIn_defaultedOut ***/
+class Derived_defaultedIn_defaultedIn_defaultedOut : public Small_defaultedIn_defaultedIn_defaultedOut {
+public:
+};
+
+Derived_defaultedIn_defaultedIn_defaultedOut Derived_defaultedIn_defaultedIn_defaultedOut_var; /* global var */
+
+template int cbv<Derived_defaultedIn_defaultedIn_defaultedOut> (Derived_defaultedIn_defaultedIn_defaultedOut arg);
+/*** Class that contains Small_defaultedIn_defaultedIn_defaultedOut ***/
+class Container_defaultedIn_defaultedIn_defaultedOut {
+public:
+ Small_defaultedIn_defaultedIn_defaultedOut item;
+};
+
+Container_defaultedIn_defaultedIn_defaultedOut Container_defaultedIn_defaultedIn_defaultedOut_var; /* global var */
+
+template int cbv_container<Container_defaultedIn_defaultedIn_defaultedOut> (Container_defaultedIn_defaultedIn_defaultedOut arg);
+/*** C++ class Small_defaultedIn_defaultedIn_deleted ***/
+class Small_defaultedIn_defaultedIn_deleted {
+public:
+ Small_defaultedIn_defaultedIn_deleted (void);
+ Small_defaultedIn_defaultedIn_deleted (const Small_defaultedIn_defaultedIn_deleted &rhs) = default;
+ ~Small_defaultedIn_defaultedIn_deleted (void) = default;
+ Small_defaultedIn_defaultedIn_deleted (Small_defaultedIn_defaultedIn_deleted &&rhs) = delete;
+
+
+ int data[2];
+};
+
+Small_defaultedIn_defaultedIn_deleted::Small_defaultedIn_defaultedIn_deleted (void)
+{
+ data[0] = 2;
+ data[1] = 2;
+}
+
+
+
+Small_defaultedIn_defaultedIn_deleted Small_defaultedIn_defaultedIn_deleted_var; /* global var */
+
+template int cbv<Small_defaultedIn_defaultedIn_deleted> (Small_defaultedIn_defaultedIn_deleted arg);
+/*** C++ class Large_defaultedIn_defaultedIn_deleted ***/
+class Large_defaultedIn_defaultedIn_deleted {
+public:
+ Large_defaultedIn_defaultedIn_deleted (void);
+ Large_defaultedIn_defaultedIn_deleted (const Large_defaultedIn_defaultedIn_deleted &rhs) = default;
+ ~Large_defaultedIn_defaultedIn_deleted (void) = default;
+ Large_defaultedIn_defaultedIn_deleted (Large_defaultedIn_defaultedIn_deleted &&rhs) = delete;
+
+
+ int data[150];
+};
+
+Large_defaultedIn_defaultedIn_deleted::Large_defaultedIn_defaultedIn_deleted (void)
+{
+ data[0] = 2;
+ data[149] = 2;
+}
+
+
+
+Large_defaultedIn_defaultedIn_deleted Large_defaultedIn_defaultedIn_deleted_var; /* global var */
+
+template int cbv<Large_defaultedIn_defaultedIn_deleted> (Large_defaultedIn_defaultedIn_deleted arg);
+/*** Class derived from Small_defaultedIn_defaultedIn_deleted ***/
+class Derived_defaultedIn_defaultedIn_deleted : public Small_defaultedIn_defaultedIn_deleted {
+public:
+};
+
+Derived_defaultedIn_defaultedIn_deleted Derived_defaultedIn_defaultedIn_deleted_var; /* global var */
+
+template int cbv<Derived_defaultedIn_defaultedIn_deleted> (Derived_defaultedIn_defaultedIn_deleted arg);
+/*** Class that contains Small_defaultedIn_defaultedIn_deleted ***/
+class Container_defaultedIn_defaultedIn_deleted {
+public:
+ Small_defaultedIn_defaultedIn_deleted item;
+};
+
+Container_defaultedIn_defaultedIn_deleted Container_defaultedIn_defaultedIn_deleted_var; /* global var */
+
+template int cbv_container<Container_defaultedIn_defaultedIn_deleted> (Container_defaultedIn_defaultedIn_deleted arg);
+/*** C++ class Small_defaultedIn_defaultedOut_absent ***/
+class Small_defaultedIn_defaultedOut_absent {
+public:
+ Small_defaultedIn_defaultedOut_absent (void);
+ Small_defaultedIn_defaultedOut_absent (const Small_defaultedIn_defaultedOut_absent &rhs) = default;
+ ~Small_defaultedIn_defaultedOut_absent (void);
+
+
+ int data[2];
+};
+
+Small_defaultedIn_defaultedOut_absent::Small_defaultedIn_defaultedOut_absent (void)
+{
+ data[0] = 2;
+ data[1] = 2;
+}
+
+Small_defaultedIn_defaultedOut_absent::~Small_defaultedIn_defaultedOut_absent (void) = default;
+
+
+Small_defaultedIn_defaultedOut_absent Small_defaultedIn_defaultedOut_absent_var; /* global var */
+
+template int cbv<Small_defaultedIn_defaultedOut_absent> (Small_defaultedIn_defaultedOut_absent arg);
+/*** C++ class Large_defaultedIn_defaultedOut_absent ***/
+class Large_defaultedIn_defaultedOut_absent {
+public:
+ Large_defaultedIn_defaultedOut_absent (void);
+ Large_defaultedIn_defaultedOut_absent (const Large_defaultedIn_defaultedOut_absent &rhs) = default;
+ ~Large_defaultedIn_defaultedOut_absent (void);
+
+
+ int data[150];
+};
+
+Large_defaultedIn_defaultedOut_absent::Large_defaultedIn_defaultedOut_absent (void)
+{
+ data[0] = 2;
+ data[149] = 2;
+}
+
+Large_defaultedIn_defaultedOut_absent::~Large_defaultedIn_defaultedOut_absent (void) = default;
+
+
+Large_defaultedIn_defaultedOut_absent Large_defaultedIn_defaultedOut_absent_var; /* global var */
+
+template int cbv<Large_defaultedIn_defaultedOut_absent> (Large_defaultedIn_defaultedOut_absent arg);
+/*** Class derived from Small_defaultedIn_defaultedOut_absent ***/
+class Derived_defaultedIn_defaultedOut_absent : public Small_defaultedIn_defaultedOut_absent {
+public:
+};
+
+Derived_defaultedIn_defaultedOut_absent Derived_defaultedIn_defaultedOut_absent_var; /* global var */
+
+template int cbv<Derived_defaultedIn_defaultedOut_absent> (Derived_defaultedIn_defaultedOut_absent arg);
+/*** Class that contains Small_defaultedIn_defaultedOut_absent ***/
+class Container_defaultedIn_defaultedOut_absent {
+public:
+ Small_defaultedIn_defaultedOut_absent item;
+};
+
+Container_defaultedIn_defaultedOut_absent Container_defaultedIn_defaultedOut_absent_var; /* global var */
+
+template int cbv_container<Container_defaultedIn_defaultedOut_absent> (Container_defaultedIn_defaultedOut_absent arg);
+/*** C++ class Small_defaultedIn_defaultedOut_explicit ***/
+class Small_defaultedIn_defaultedOut_explicit {
+public:
+ Small_defaultedIn_defaultedOut_explicit (void);
+ Small_defaultedIn_defaultedOut_explicit (const Small_defaultedIn_defaultedOut_explicit &rhs) = default;
+ ~Small_defaultedIn_defaultedOut_explicit (void);
+ Small_defaultedIn_defaultedOut_explicit (Small_defaultedIn_defaultedOut_explicit &&rhs);
+
+
+ int data[2];
+};
+
+Small_defaultedIn_defaultedOut_explicit::Small_defaultedIn_defaultedOut_explicit (void)
+{
+ data[0] = 2;
+ data[1] = 2;
+}
+
+Small_defaultedIn_defaultedOut_explicit::~Small_defaultedIn_defaultedOut_explicit (void) = default;
+Small_defaultedIn_defaultedOut_explicit::Small_defaultedIn_defaultedOut_explicit (Small_defaultedIn_defaultedOut_explicit &&rhs)
+{
+ data[0] = 3;
+ data[1] = 3;
+ tracer = 5;
+}
+
+
+Small_defaultedIn_defaultedOut_explicit Small_defaultedIn_defaultedOut_explicit_var; /* global var */
+
+template int cbv<Small_defaultedIn_defaultedOut_explicit> (Small_defaultedIn_defaultedOut_explicit arg);
+/*** C++ class Large_defaultedIn_defaultedOut_explicit ***/
+class Large_defaultedIn_defaultedOut_explicit {
+public:
+ Large_defaultedIn_defaultedOut_explicit (void);
+ Large_defaultedIn_defaultedOut_explicit (const Large_defaultedIn_defaultedOut_explicit &rhs) = default;
+ ~Large_defaultedIn_defaultedOut_explicit (void);
+ Large_defaultedIn_defaultedOut_explicit (Large_defaultedIn_defaultedOut_explicit &&rhs);
+
+
+ int data[150];
+};
+
+Large_defaultedIn_defaultedOut_explicit::Large_defaultedIn_defaultedOut_explicit (void)
+{
+ data[0] = 2;
+ data[149] = 2;
+}
+
+Large_defaultedIn_defaultedOut_explicit::~Large_defaultedIn_defaultedOut_explicit (void) = default;
+Large_defaultedIn_defaultedOut_explicit::Large_defaultedIn_defaultedOut_explicit (Large_defaultedIn_defaultedOut_explicit &&rhs)
+{
+ data[0] = 3;
+ data[149] = 3;
+ tracer = 5;
+}
+
+
+Large_defaultedIn_defaultedOut_explicit Large_defaultedIn_defaultedOut_explicit_var; /* global var */
+
+template int cbv<Large_defaultedIn_defaultedOut_explicit> (Large_defaultedIn_defaultedOut_explicit arg);
+/*** Class derived from Small_defaultedIn_defaultedOut_explicit ***/
+class Derived_defaultedIn_defaultedOut_explicit : public Small_defaultedIn_defaultedOut_explicit {
+public:
+};
+
+Derived_defaultedIn_defaultedOut_explicit Derived_defaultedIn_defaultedOut_explicit_var; /* global var */
+
+template int cbv<Derived_defaultedIn_defaultedOut_explicit> (Derived_defaultedIn_defaultedOut_explicit arg);
+/*** Class that contains Small_defaultedIn_defaultedOut_explicit ***/
+class Container_defaultedIn_defaultedOut_explicit {
+public:
+ Small_defaultedIn_defaultedOut_explicit item;
+};
+
+Container_defaultedIn_defaultedOut_explicit Container_defaultedIn_defaultedOut_explicit_var; /* global var */
+
+template int cbv_container<Container_defaultedIn_defaultedOut_explicit> (Container_defaultedIn_defaultedOut_explicit arg);
+/*** C++ class Small_defaultedIn_defaultedOut_defaultedIn ***/
+class Small_defaultedIn_defaultedOut_defaultedIn {
+public:
+ Small_defaultedIn_defaultedOut_defaultedIn (void);
+ Small_defaultedIn_defaultedOut_defaultedIn (const Small_defaultedIn_defaultedOut_defaultedIn &rhs) = default;
+ ~Small_defaultedIn_defaultedOut_defaultedIn (void);
+ Small_defaultedIn_defaultedOut_defaultedIn (Small_defaultedIn_defaultedOut_defaultedIn &&rhs) = default;
+
+
+ int data[2];
+};
+
+Small_defaultedIn_defaultedOut_defaultedIn::Small_defaultedIn_defaultedOut_defaultedIn (void)
+{
+ data[0] = 2;
+ data[1] = 2;
+}
+
+Small_defaultedIn_defaultedOut_defaultedIn::~Small_defaultedIn_defaultedOut_defaultedIn (void) = default;
+
+
+Small_defaultedIn_defaultedOut_defaultedIn Small_defaultedIn_defaultedOut_defaultedIn_var; /* global var */
+
+template int cbv<Small_defaultedIn_defaultedOut_defaultedIn> (Small_defaultedIn_defaultedOut_defaultedIn arg);
+/*** C++ class Large_defaultedIn_defaultedOut_defaultedIn ***/
+class Large_defaultedIn_defaultedOut_defaultedIn {
+public:
+ Large_defaultedIn_defaultedOut_defaultedIn (void);
+ Large_defaultedIn_defaultedOut_defaultedIn (const Large_defaultedIn_defaultedOut_defaultedIn &rhs) = default;
+ ~Large_defaultedIn_defaultedOut_defaultedIn (void);
+ Large_defaultedIn_defaultedOut_defaultedIn (Large_defaultedIn_defaultedOut_defaultedIn &&rhs) = default;
+
+
+ int data[150];
+};
+
+Large_defaultedIn_defaultedOut_defaultedIn::Large_defaultedIn_defaultedOut_defaultedIn (void)
+{
+ data[0] = 2;
+ data[149] = 2;
+}
+
+Large_defaultedIn_defaultedOut_defaultedIn::~Large_defaultedIn_defaultedOut_defaultedIn (void) = default;
+
+
+Large_defaultedIn_defaultedOut_defaultedIn Large_defaultedIn_defaultedOut_defaultedIn_var; /* global var */
+
+template int cbv<Large_defaultedIn_defaultedOut_defaultedIn> (Large_defaultedIn_defaultedOut_defaultedIn arg);
+/*** Class derived from Small_defaultedIn_defaultedOut_defaultedIn ***/
+class Derived_defaultedIn_defaultedOut_defaultedIn : public Small_defaultedIn_defaultedOut_defaultedIn {
+public:
+};
+
+Derived_defaultedIn_defaultedOut_defaultedIn Derived_defaultedIn_defaultedOut_defaultedIn_var; /* global var */
+
+template int cbv<Derived_defaultedIn_defaultedOut_defaultedIn> (Derived_defaultedIn_defaultedOut_defaultedIn arg);
+/*** Class that contains Small_defaultedIn_defaultedOut_defaultedIn ***/
+class Container_defaultedIn_defaultedOut_defaultedIn {
+public:
+ Small_defaultedIn_defaultedOut_defaultedIn item;
+};
+
+Container_defaultedIn_defaultedOut_defaultedIn Container_defaultedIn_defaultedOut_defaultedIn_var; /* global var */
+
+template int cbv_container<Container_defaultedIn_defaultedOut_defaultedIn> (Container_defaultedIn_defaultedOut_defaultedIn arg);
+/*** C++ class Small_defaultedIn_defaultedOut_defaultedOut ***/
+class Small_defaultedIn_defaultedOut_defaultedOut {
+public:
+ Small_defaultedIn_defaultedOut_defaultedOut (void);
+ Small_defaultedIn_defaultedOut_defaultedOut (const Small_defaultedIn_defaultedOut_defaultedOut &rhs) = default;
+ ~Small_defaultedIn_defaultedOut_defaultedOut (void);
+ Small_defaultedIn_defaultedOut_defaultedOut (Small_defaultedIn_defaultedOut_defaultedOut &&rhs);
+
+
+ int data[2];
+};
+
+Small_defaultedIn_defaultedOut_defaultedOut::Small_defaultedIn_defaultedOut_defaultedOut (void)
+{
+ data[0] = 2;
+ data[1] = 2;
+}
+
+Small_defaultedIn_defaultedOut_defaultedOut::~Small_defaultedIn_defaultedOut_defaultedOut (void) = default;
+Small_defaultedIn_defaultedOut_defaultedOut::Small_defaultedIn_defaultedOut_defaultedOut (Small_defaultedIn_defaultedOut_defaultedOut &&rhs) = default;
+
+
+Small_defaultedIn_defaultedOut_defaultedOut Small_defaultedIn_defaultedOut_defaultedOut_var; /* global var */
+
+template int cbv<Small_defaultedIn_defaultedOut_defaultedOut> (Small_defaultedIn_defaultedOut_defaultedOut arg);
+/*** C++ class Large_defaultedIn_defaultedOut_defaultedOut ***/
+class Large_defaultedIn_defaultedOut_defaultedOut {
+public:
+ Large_defaultedIn_defaultedOut_defaultedOut (void);
+ Large_defaultedIn_defaultedOut_defaultedOut (const Large_defaultedIn_defaultedOut_defaultedOut &rhs) = default;
+ ~Large_defaultedIn_defaultedOut_defaultedOut (void);
+ Large_defaultedIn_defaultedOut_defaultedOut (Large_defaultedIn_defaultedOut_defaultedOut &&rhs);
+
+
+ int data[150];
+};
+
+Large_defaultedIn_defaultedOut_defaultedOut::Large_defaultedIn_defaultedOut_defaultedOut (void)
+{
+ data[0] = 2;
+ data[149] = 2;
+}
+
+Large_defaultedIn_defaultedOut_defaultedOut::~Large_defaultedIn_defaultedOut_defaultedOut (void) = default;
+Large_defaultedIn_defaultedOut_defaultedOut::Large_defaultedIn_defaultedOut_defaultedOut (Large_defaultedIn_defaultedOut_defaultedOut &&rhs) = default;
+
+
+Large_defaultedIn_defaultedOut_defaultedOut Large_defaultedIn_defaultedOut_defaultedOut_var; /* global var */
+
+template int cbv<Large_defaultedIn_defaultedOut_defaultedOut> (Large_defaultedIn_defaultedOut_defaultedOut arg);
+/*** Class derived from Small_defaultedIn_defaultedOut_defaultedOut ***/
+class Derived_defaultedIn_defaultedOut_defaultedOut : public Small_defaultedIn_defaultedOut_defaultedOut {
+public:
+};
+
+Derived_defaultedIn_defaultedOut_defaultedOut Derived_defaultedIn_defaultedOut_defaultedOut_var; /* global var */
+
+template int cbv<Derived_defaultedIn_defaultedOut_defaultedOut> (Derived_defaultedIn_defaultedOut_defaultedOut arg);
+/*** Class that contains Small_defaultedIn_defaultedOut_defaultedOut ***/
+class Container_defaultedIn_defaultedOut_defaultedOut {
+public:
+ Small_defaultedIn_defaultedOut_defaultedOut item;
+};
+
+Container_defaultedIn_defaultedOut_defaultedOut Container_defaultedIn_defaultedOut_defaultedOut_var; /* global var */
+
+template int cbv_container<Container_defaultedIn_defaultedOut_defaultedOut> (Container_defaultedIn_defaultedOut_defaultedOut arg);
+/*** C++ class Small_defaultedIn_defaultedOut_deleted ***/
+class Small_defaultedIn_defaultedOut_deleted {
+public:
+ Small_defaultedIn_defaultedOut_deleted (void);
+ Small_defaultedIn_defaultedOut_deleted (const Small_defaultedIn_defaultedOut_deleted &rhs) = default;
+ ~Small_defaultedIn_defaultedOut_deleted (void);
+ Small_defaultedIn_defaultedOut_deleted (Small_defaultedIn_defaultedOut_deleted &&rhs) = delete;
+
+
+ int data[2];
+};
+
+Small_defaultedIn_defaultedOut_deleted::Small_defaultedIn_defaultedOut_deleted (void)
+{
+ data[0] = 2;
+ data[1] = 2;
+}
+
+Small_defaultedIn_defaultedOut_deleted::~Small_defaultedIn_defaultedOut_deleted (void) = default;
+
+
+Small_defaultedIn_defaultedOut_deleted Small_defaultedIn_defaultedOut_deleted_var; /* global var */
+
+template int cbv<Small_defaultedIn_defaultedOut_deleted> (Small_defaultedIn_defaultedOut_deleted arg);
+/*** C++ class Large_defaultedIn_defaultedOut_deleted ***/
+class Large_defaultedIn_defaultedOut_deleted {
+public:
+ Large_defaultedIn_defaultedOut_deleted (void);
+ Large_defaultedIn_defaultedOut_deleted (const Large_defaultedIn_defaultedOut_deleted &rhs) = default;
+ ~Large_defaultedIn_defaultedOut_deleted (void);
+ Large_defaultedIn_defaultedOut_deleted (Large_defaultedIn_defaultedOut_deleted &&rhs) = delete;
+
+
+ int data[150];
+};
+
+Large_defaultedIn_defaultedOut_deleted::Large_defaultedIn_defaultedOut_deleted (void)
+{
+ data[0] = 2;
+ data[149] = 2;
+}
+
+Large_defaultedIn_defaultedOut_deleted::~Large_defaultedIn_defaultedOut_deleted (void) = default;
+
+
+Large_defaultedIn_defaultedOut_deleted Large_defaultedIn_defaultedOut_deleted_var; /* global var */
+
+template int cbv<Large_defaultedIn_defaultedOut_deleted> (Large_defaultedIn_defaultedOut_deleted arg);
+/*** Class derived from Small_defaultedIn_defaultedOut_deleted ***/
+class Derived_defaultedIn_defaultedOut_deleted : public Small_defaultedIn_defaultedOut_deleted {
+public:
+};
+
+Derived_defaultedIn_defaultedOut_deleted Derived_defaultedIn_defaultedOut_deleted_var; /* global var */
+
+template int cbv<Derived_defaultedIn_defaultedOut_deleted> (Derived_defaultedIn_defaultedOut_deleted arg);
+/*** Class that contains Small_defaultedIn_defaultedOut_deleted ***/
+class Container_defaultedIn_defaultedOut_deleted {
+public:
+ Small_defaultedIn_defaultedOut_deleted item;
+};
+
+Container_defaultedIn_defaultedOut_deleted Container_defaultedIn_defaultedOut_deleted_var; /* global var */
+
+template int cbv_container<Container_defaultedIn_defaultedOut_deleted> (Container_defaultedIn_defaultedOut_deleted arg);
+/*** C++ class Small_defaultedOut_absent_absent ***/
+class Small_defaultedOut_absent_absent {
+public:
+ Small_defaultedOut_absent_absent (void);
+ Small_defaultedOut_absent_absent (const Small_defaultedOut_absent_absent &rhs);
+
+
+ int data[2];
+};
+
+Small_defaultedOut_absent_absent::Small_defaultedOut_absent_absent (void)
+{
+ data[0] = 2;
+ data[1] = 2;
+}
+
+Small_defaultedOut_absent_absent::Small_defaultedOut_absent_absent (const Small_defaultedOut_absent_absent &rhs) = default;
+
+
+Small_defaultedOut_absent_absent Small_defaultedOut_absent_absent_var; /* global var */
+
+template int cbv<Small_defaultedOut_absent_absent> (Small_defaultedOut_absent_absent arg);
+/*** C++ class Large_defaultedOut_absent_absent ***/
+class Large_defaultedOut_absent_absent {
+public:
+ Large_defaultedOut_absent_absent (void);
+ Large_defaultedOut_absent_absent (const Large_defaultedOut_absent_absent &rhs);
+
+
+ int data[150];
+};
+
+Large_defaultedOut_absent_absent::Large_defaultedOut_absent_absent (void)
+{
+ data[0] = 2;
+ data[149] = 2;
+}
+
+Large_defaultedOut_absent_absent::Large_defaultedOut_absent_absent (const Large_defaultedOut_absent_absent &rhs) = default;
+
+
+Large_defaultedOut_absent_absent Large_defaultedOut_absent_absent_var; /* global var */
+
+template int cbv<Large_defaultedOut_absent_absent> (Large_defaultedOut_absent_absent arg);
+/*** Class derived from Small_defaultedOut_absent_absent ***/
+class Derived_defaultedOut_absent_absent : public Small_defaultedOut_absent_absent {
+public:
+};
+
+Derived_defaultedOut_absent_absent Derived_defaultedOut_absent_absent_var; /* global var */
+
+template int cbv<Derived_defaultedOut_absent_absent> (Derived_defaultedOut_absent_absent arg);
+/*** Class that contains Small_defaultedOut_absent_absent ***/
+class Container_defaultedOut_absent_absent {
+public:
+ Small_defaultedOut_absent_absent item;
+};
+
+Container_defaultedOut_absent_absent Container_defaultedOut_absent_absent_var; /* global var */
+
+template int cbv_container<Container_defaultedOut_absent_absent> (Container_defaultedOut_absent_absent arg);
+/*** C++ class Small_defaultedOut_absent_explicit ***/
+class Small_defaultedOut_absent_explicit {
+public:
+ Small_defaultedOut_absent_explicit (void);
+ Small_defaultedOut_absent_explicit (const Small_defaultedOut_absent_explicit &rhs);
+ Small_defaultedOut_absent_explicit (Small_defaultedOut_absent_explicit &&rhs);
+
+
+ int data[2];
+};
+
+Small_defaultedOut_absent_explicit::Small_defaultedOut_absent_explicit (void)
+{
+ data[0] = 2;
+ data[1] = 2;
+}
+
+Small_defaultedOut_absent_explicit::Small_defaultedOut_absent_explicit (const Small_defaultedOut_absent_explicit &rhs) = default;
+Small_defaultedOut_absent_explicit::Small_defaultedOut_absent_explicit (Small_defaultedOut_absent_explicit &&rhs)
+{
+ data[0] = 3;
+ data[1] = 3;
+ tracer = 5;
+}
+
+
+Small_defaultedOut_absent_explicit Small_defaultedOut_absent_explicit_var; /* global var */
+
+template int cbv<Small_defaultedOut_absent_explicit> (Small_defaultedOut_absent_explicit arg);
+/*** C++ class Large_defaultedOut_absent_explicit ***/
+class Large_defaultedOut_absent_explicit {
+public:
+ Large_defaultedOut_absent_explicit (void);
+ Large_defaultedOut_absent_explicit (const Large_defaultedOut_absent_explicit &rhs);
+ Large_defaultedOut_absent_explicit (Large_defaultedOut_absent_explicit &&rhs);
+
+
+ int data[150];
+};
+
+Large_defaultedOut_absent_explicit::Large_defaultedOut_absent_explicit (void)
+{
+ data[0] = 2;
+ data[149] = 2;
+}
+
+Large_defaultedOut_absent_explicit::Large_defaultedOut_absent_explicit (const Large_defaultedOut_absent_explicit &rhs) = default;
+Large_defaultedOut_absent_explicit::Large_defaultedOut_absent_explicit (Large_defaultedOut_absent_explicit &&rhs)
+{
+ data[0] = 3;
+ data[149] = 3;
+ tracer = 5;
+}
+
+
+Large_defaultedOut_absent_explicit Large_defaultedOut_absent_explicit_var; /* global var */
+
+template int cbv<Large_defaultedOut_absent_explicit> (Large_defaultedOut_absent_explicit arg);
+/*** Class derived from Small_defaultedOut_absent_explicit ***/
+class Derived_defaultedOut_absent_explicit : public Small_defaultedOut_absent_explicit {
+public:
+};
+
+Derived_defaultedOut_absent_explicit Derived_defaultedOut_absent_explicit_var; /* global var */
+
+template int cbv<Derived_defaultedOut_absent_explicit> (Derived_defaultedOut_absent_explicit arg);
+/*** Class that contains Small_defaultedOut_absent_explicit ***/
+class Container_defaultedOut_absent_explicit {
+public:
+ Small_defaultedOut_absent_explicit item;
+};
+
+Container_defaultedOut_absent_explicit Container_defaultedOut_absent_explicit_var; /* global var */
+
+template int cbv_container<Container_defaultedOut_absent_explicit> (Container_defaultedOut_absent_explicit arg);
+/*** C++ class Small_defaultedOut_absent_defaultedIn ***/
+class Small_defaultedOut_absent_defaultedIn {
+public:
+ Small_defaultedOut_absent_defaultedIn (void);
+ Small_defaultedOut_absent_defaultedIn (const Small_defaultedOut_absent_defaultedIn &rhs);
+ Small_defaultedOut_absent_defaultedIn (Small_defaultedOut_absent_defaultedIn &&rhs) = default;
+
+
+ int data[2];
+};
+
+Small_defaultedOut_absent_defaultedIn::Small_defaultedOut_absent_defaultedIn (void)
+{
+ data[0] = 2;
+ data[1] = 2;
+}
+
+Small_defaultedOut_absent_defaultedIn::Small_defaultedOut_absent_defaultedIn (const Small_defaultedOut_absent_defaultedIn &rhs) = default;
+
+
+Small_defaultedOut_absent_defaultedIn Small_defaultedOut_absent_defaultedIn_var; /* global var */
+
+template int cbv<Small_defaultedOut_absent_defaultedIn> (Small_defaultedOut_absent_defaultedIn arg);
+/*** C++ class Large_defaultedOut_absent_defaultedIn ***/
+class Large_defaultedOut_absent_defaultedIn {
+public:
+ Large_defaultedOut_absent_defaultedIn (void);
+ Large_defaultedOut_absent_defaultedIn (const Large_defaultedOut_absent_defaultedIn &rhs);
+ Large_defaultedOut_absent_defaultedIn (Large_defaultedOut_absent_defaultedIn &&rhs) = default;
+
+
+ int data[150];
+};
+
+Large_defaultedOut_absent_defaultedIn::Large_defaultedOut_absent_defaultedIn (void)
+{
+ data[0] = 2;
+ data[149] = 2;
+}
+
+Large_defaultedOut_absent_defaultedIn::Large_defaultedOut_absent_defaultedIn (const Large_defaultedOut_absent_defaultedIn &rhs) = default;
+
+
+Large_defaultedOut_absent_defaultedIn Large_defaultedOut_absent_defaultedIn_var; /* global var */
+
+template int cbv<Large_defaultedOut_absent_defaultedIn> (Large_defaultedOut_absent_defaultedIn arg);
+/*** Class derived from Small_defaultedOut_absent_defaultedIn ***/
+class Derived_defaultedOut_absent_defaultedIn : public Small_defaultedOut_absent_defaultedIn {
+public:
+};
+
+Derived_defaultedOut_absent_defaultedIn Derived_defaultedOut_absent_defaultedIn_var; /* global var */
+
+template int cbv<Derived_defaultedOut_absent_defaultedIn> (Derived_defaultedOut_absent_defaultedIn arg);
+/*** Class that contains Small_defaultedOut_absent_defaultedIn ***/
+class Container_defaultedOut_absent_defaultedIn {
+public:
+ Small_defaultedOut_absent_defaultedIn item;
+};
+
+Container_defaultedOut_absent_defaultedIn Container_defaultedOut_absent_defaultedIn_var; /* global var */
+
+template int cbv_container<Container_defaultedOut_absent_defaultedIn> (Container_defaultedOut_absent_defaultedIn arg);
+/*** C++ class Small_defaultedOut_absent_defaultedOut ***/
+class Small_defaultedOut_absent_defaultedOut {
+public:
+ Small_defaultedOut_absent_defaultedOut (void);
+ Small_defaultedOut_absent_defaultedOut (const Small_defaultedOut_absent_defaultedOut &rhs);
+ Small_defaultedOut_absent_defaultedOut (Small_defaultedOut_absent_defaultedOut &&rhs);
+
+
+ int data[2];
+};
+
+Small_defaultedOut_absent_defaultedOut::Small_defaultedOut_absent_defaultedOut (void)
+{
+ data[0] = 2;
+ data[1] = 2;
+}
+
+Small_defaultedOut_absent_defaultedOut::Small_defaultedOut_absent_defaultedOut (const Small_defaultedOut_absent_defaultedOut &rhs) = default;
+Small_defaultedOut_absent_defaultedOut::Small_defaultedOut_absent_defaultedOut (Small_defaultedOut_absent_defaultedOut &&rhs) = default;
+
+
+Small_defaultedOut_absent_defaultedOut Small_defaultedOut_absent_defaultedOut_var; /* global var */
+
+template int cbv<Small_defaultedOut_absent_defaultedOut> (Small_defaultedOut_absent_defaultedOut arg);
+/*** C++ class Large_defaultedOut_absent_defaultedOut ***/
+class Large_defaultedOut_absent_defaultedOut {
+public:
+ Large_defaultedOut_absent_defaultedOut (void);
+ Large_defaultedOut_absent_defaultedOut (const Large_defaultedOut_absent_defaultedOut &rhs);
+ Large_defaultedOut_absent_defaultedOut (Large_defaultedOut_absent_defaultedOut &&rhs);
+
+
+ int data[150];
+};
+
+Large_defaultedOut_absent_defaultedOut::Large_defaultedOut_absent_defaultedOut (void)
+{
+ data[0] = 2;
+ data[149] = 2;
+}
+
+Large_defaultedOut_absent_defaultedOut::Large_defaultedOut_absent_defaultedOut (const Large_defaultedOut_absent_defaultedOut &rhs) = default;
+Large_defaultedOut_absent_defaultedOut::Large_defaultedOut_absent_defaultedOut (Large_defaultedOut_absent_defaultedOut &&rhs) = default;
+
+
+Large_defaultedOut_absent_defaultedOut Large_defaultedOut_absent_defaultedOut_var; /* global var */
+
+template int cbv<Large_defaultedOut_absent_defaultedOut> (Large_defaultedOut_absent_defaultedOut arg);
+/*** Class derived from Small_defaultedOut_absent_defaultedOut ***/
+class Derived_defaultedOut_absent_defaultedOut : public Small_defaultedOut_absent_defaultedOut {
+public:
+};
+
+Derived_defaultedOut_absent_defaultedOut Derived_defaultedOut_absent_defaultedOut_var; /* global var */
+
+template int cbv<Derived_defaultedOut_absent_defaultedOut> (Derived_defaultedOut_absent_defaultedOut arg);
+/*** Class that contains Small_defaultedOut_absent_defaultedOut ***/
+class Container_defaultedOut_absent_defaultedOut {
+public:
+ Small_defaultedOut_absent_defaultedOut item;
+};
+
+Container_defaultedOut_absent_defaultedOut Container_defaultedOut_absent_defaultedOut_var; /* global var */
+
+template int cbv_container<Container_defaultedOut_absent_defaultedOut> (Container_defaultedOut_absent_defaultedOut arg);
+/*** C++ class Small_defaultedOut_absent_deleted ***/
+class Small_defaultedOut_absent_deleted {
+public:
+ Small_defaultedOut_absent_deleted (void);
+ Small_defaultedOut_absent_deleted (const Small_defaultedOut_absent_deleted &rhs);
+ Small_defaultedOut_absent_deleted (Small_defaultedOut_absent_deleted &&rhs) = delete;
+
+
+ int data[2];
+};
+
+Small_defaultedOut_absent_deleted::Small_defaultedOut_absent_deleted (void)
+{
+ data[0] = 2;
+ data[1] = 2;
+}
+
+Small_defaultedOut_absent_deleted::Small_defaultedOut_absent_deleted (const Small_defaultedOut_absent_deleted &rhs) = default;
+
+
+Small_defaultedOut_absent_deleted Small_defaultedOut_absent_deleted_var; /* global var */
+
+template int cbv<Small_defaultedOut_absent_deleted> (Small_defaultedOut_absent_deleted arg);
+/*** C++ class Large_defaultedOut_absent_deleted ***/
+class Large_defaultedOut_absent_deleted {
+public:
+ Large_defaultedOut_absent_deleted (void);
+ Large_defaultedOut_absent_deleted (const Large_defaultedOut_absent_deleted &rhs);
+ Large_defaultedOut_absent_deleted (Large_defaultedOut_absent_deleted &&rhs) = delete;
+
+
+ int data[150];
+};
+
+Large_defaultedOut_absent_deleted::Large_defaultedOut_absent_deleted (void)
+{
+ data[0] = 2;
+ data[149] = 2;
+}
+
+Large_defaultedOut_absent_deleted::Large_defaultedOut_absent_deleted (const Large_defaultedOut_absent_deleted &rhs) = default;
+
+
+Large_defaultedOut_absent_deleted Large_defaultedOut_absent_deleted_var; /* global var */
+
+template int cbv<Large_defaultedOut_absent_deleted> (Large_defaultedOut_absent_deleted arg);
+/*** Class derived from Small_defaultedOut_absent_deleted ***/
+class Derived_defaultedOut_absent_deleted : public Small_defaultedOut_absent_deleted {
+public:
+};
+
+Derived_defaultedOut_absent_deleted Derived_defaultedOut_absent_deleted_var; /* global var */
+
+template int cbv<Derived_defaultedOut_absent_deleted> (Derived_defaultedOut_absent_deleted arg);
+/*** Class that contains Small_defaultedOut_absent_deleted ***/
+class Container_defaultedOut_absent_deleted {
+public:
+ Small_defaultedOut_absent_deleted item;
+};
+
+Container_defaultedOut_absent_deleted Container_defaultedOut_absent_deleted_var; /* global var */
+
+template int cbv_container<Container_defaultedOut_absent_deleted> (Container_defaultedOut_absent_deleted arg);
+/*** C++ class Small_defaultedOut_explicit_absent ***/
+class Small_defaultedOut_explicit_absent {
+public:
+ Small_defaultedOut_explicit_absent (void);
+ Small_defaultedOut_explicit_absent (const Small_defaultedOut_explicit_absent &rhs);
+ ~Small_defaultedOut_explicit_absent (void);
+
+
+ int data[2];
+};
+
+Small_defaultedOut_explicit_absent::Small_defaultedOut_explicit_absent (void)
+{
+ data[0] = 2;
+ data[1] = 2;
+}
+
+Small_defaultedOut_explicit_absent::Small_defaultedOut_explicit_absent (const Small_defaultedOut_explicit_absent &rhs) = default;
+Small_defaultedOut_explicit_absent::~Small_defaultedOut_explicit_absent (void)
+{
+ data[0] = 3;
+ data[1] = 3;
+ tracer = 5;
+}
+
+
+Small_defaultedOut_explicit_absent Small_defaultedOut_explicit_absent_var; /* global var */
+
+template int cbv<Small_defaultedOut_explicit_absent> (Small_defaultedOut_explicit_absent arg);
+/*** C++ class Large_defaultedOut_explicit_absent ***/
+class Large_defaultedOut_explicit_absent {
+public:
+ Large_defaultedOut_explicit_absent (void);
+ Large_defaultedOut_explicit_absent (const Large_defaultedOut_explicit_absent &rhs);
+ ~Large_defaultedOut_explicit_absent (void);
+
+
+ int data[150];
+};
+
+Large_defaultedOut_explicit_absent::Large_defaultedOut_explicit_absent (void)
+{
+ data[0] = 2;
+ data[149] = 2;
+}
+
+Large_defaultedOut_explicit_absent::Large_defaultedOut_explicit_absent (const Large_defaultedOut_explicit_absent &rhs) = default;
+Large_defaultedOut_explicit_absent::~Large_defaultedOut_explicit_absent (void)
+{
+ data[0] = 3;
+ data[149] = 3;
+ tracer = 5;
+}
+
+
+Large_defaultedOut_explicit_absent Large_defaultedOut_explicit_absent_var; /* global var */
+
+template int cbv<Large_defaultedOut_explicit_absent> (Large_defaultedOut_explicit_absent arg);
+/*** Class derived from Small_defaultedOut_explicit_absent ***/
+class Derived_defaultedOut_explicit_absent : public Small_defaultedOut_explicit_absent {
+public:
+};
+
+Derived_defaultedOut_explicit_absent Derived_defaultedOut_explicit_absent_var; /* global var */
+
+template int cbv<Derived_defaultedOut_explicit_absent> (Derived_defaultedOut_explicit_absent arg);
+/*** Class that contains Small_defaultedOut_explicit_absent ***/
+class Container_defaultedOut_explicit_absent {
+public:
+ Small_defaultedOut_explicit_absent item;
+};
+
+Container_defaultedOut_explicit_absent Container_defaultedOut_explicit_absent_var; /* global var */
+
+template int cbv_container<Container_defaultedOut_explicit_absent> (Container_defaultedOut_explicit_absent arg);
+/*** C++ class Small_defaultedOut_explicit_explicit ***/
+class Small_defaultedOut_explicit_explicit {
+public:
+ Small_defaultedOut_explicit_explicit (void);
+ Small_defaultedOut_explicit_explicit (const Small_defaultedOut_explicit_explicit &rhs);
+ ~Small_defaultedOut_explicit_explicit (void);
+ Small_defaultedOut_explicit_explicit (Small_defaultedOut_explicit_explicit &&rhs);
+
+
+ int data[2];
+};
+
+Small_defaultedOut_explicit_explicit::Small_defaultedOut_explicit_explicit (void)
+{
+ data[0] = 2;
+ data[1] = 2;
+}
+
+Small_defaultedOut_explicit_explicit::Small_defaultedOut_explicit_explicit (const Small_defaultedOut_explicit_explicit &rhs) = default;
+Small_defaultedOut_explicit_explicit::~Small_defaultedOut_explicit_explicit (void)
+{
+ data[0] = 3;
+ data[1] = 3;
+ tracer = 5;
+}
+Small_defaultedOut_explicit_explicit::Small_defaultedOut_explicit_explicit (Small_defaultedOut_explicit_explicit &&rhs)
+{
+ data[0] = 3;
+ data[1] = 3;
+ tracer = 5;
+}
+
+
+Small_defaultedOut_explicit_explicit Small_defaultedOut_explicit_explicit_var; /* global var */
+
+template int cbv<Small_defaultedOut_explicit_explicit> (Small_defaultedOut_explicit_explicit arg);
+/*** C++ class Large_defaultedOut_explicit_explicit ***/
+class Large_defaultedOut_explicit_explicit {
+public:
+ Large_defaultedOut_explicit_explicit (void);
+ Large_defaultedOut_explicit_explicit (const Large_defaultedOut_explicit_explicit &rhs);
+ ~Large_defaultedOut_explicit_explicit (void);
+ Large_defaultedOut_explicit_explicit (Large_defaultedOut_explicit_explicit &&rhs);
+
+
+ int data[150];
+};
+
+Large_defaultedOut_explicit_explicit::Large_defaultedOut_explicit_explicit (void)
+{
+ data[0] = 2;
+ data[149] = 2;
+}
+
+Large_defaultedOut_explicit_explicit::Large_defaultedOut_explicit_explicit (const Large_defaultedOut_explicit_explicit &rhs) = default;
+Large_defaultedOut_explicit_explicit::~Large_defaultedOut_explicit_explicit (void)
+{
+ data[0] = 3;
+ data[149] = 3;
+ tracer = 5;
+}
+Large_defaultedOut_explicit_explicit::Large_defaultedOut_explicit_explicit (Large_defaultedOut_explicit_explicit &&rhs)
+{
+ data[0] = 3;
+ data[149] = 3;
+ tracer = 5;
+}
+
+
+Large_defaultedOut_explicit_explicit Large_defaultedOut_explicit_explicit_var; /* global var */
+
+template int cbv<Large_defaultedOut_explicit_explicit> (Large_defaultedOut_explicit_explicit arg);
+/*** Class derived from Small_defaultedOut_explicit_explicit ***/
+class Derived_defaultedOut_explicit_explicit : public Small_defaultedOut_explicit_explicit {
+public:
+};
+
+Derived_defaultedOut_explicit_explicit Derived_defaultedOut_explicit_explicit_var; /* global var */
+
+template int cbv<Derived_defaultedOut_explicit_explicit> (Derived_defaultedOut_explicit_explicit arg);
+/*** Class that contains Small_defaultedOut_explicit_explicit ***/
+class Container_defaultedOut_explicit_explicit {
+public:
+ Small_defaultedOut_explicit_explicit item;
+};
+
+Container_defaultedOut_explicit_explicit Container_defaultedOut_explicit_explicit_var; /* global var */
+
+template int cbv_container<Container_defaultedOut_explicit_explicit> (Container_defaultedOut_explicit_explicit arg);
+/*** C++ class Small_defaultedOut_explicit_defaultedIn ***/
+class Small_defaultedOut_explicit_defaultedIn {
+public:
+ Small_defaultedOut_explicit_defaultedIn (void);
+ Small_defaultedOut_explicit_defaultedIn (const Small_defaultedOut_explicit_defaultedIn &rhs);
+ ~Small_defaultedOut_explicit_defaultedIn (void);
+ Small_defaultedOut_explicit_defaultedIn (Small_defaultedOut_explicit_defaultedIn &&rhs) = default;
+
+
+ int data[2];
+};
+
+Small_defaultedOut_explicit_defaultedIn::Small_defaultedOut_explicit_defaultedIn (void)
+{
+ data[0] = 2;
+ data[1] = 2;
+}
+
+Small_defaultedOut_explicit_defaultedIn::Small_defaultedOut_explicit_defaultedIn (const Small_defaultedOut_explicit_defaultedIn &rhs) = default;
+Small_defaultedOut_explicit_defaultedIn::~Small_defaultedOut_explicit_defaultedIn (void)
+{
+ data[0] = 3;
+ data[1] = 3;
+ tracer = 5;
+}
+
+
+Small_defaultedOut_explicit_defaultedIn Small_defaultedOut_explicit_defaultedIn_var; /* global var */
+
+template int cbv<Small_defaultedOut_explicit_defaultedIn> (Small_defaultedOut_explicit_defaultedIn arg);
+/*** C++ class Large_defaultedOut_explicit_defaultedIn ***/
+class Large_defaultedOut_explicit_defaultedIn {
+public:
+ Large_defaultedOut_explicit_defaultedIn (void);
+ Large_defaultedOut_explicit_defaultedIn (const Large_defaultedOut_explicit_defaultedIn &rhs);
+ ~Large_defaultedOut_explicit_defaultedIn (void);
+ Large_defaultedOut_explicit_defaultedIn (Large_defaultedOut_explicit_defaultedIn &&rhs) = default;
+
+
+ int data[150];
+};
+
+Large_defaultedOut_explicit_defaultedIn::Large_defaultedOut_explicit_defaultedIn (void)
+{
+ data[0] = 2;
+ data[149] = 2;
+}
+
+Large_defaultedOut_explicit_defaultedIn::Large_defaultedOut_explicit_defaultedIn (const Large_defaultedOut_explicit_defaultedIn &rhs) = default;
+Large_defaultedOut_explicit_defaultedIn::~Large_defaultedOut_explicit_defaultedIn (void)
+{
+ data[0] = 3;
+ data[149] = 3;
+ tracer = 5;
+}
+
+
+Large_defaultedOut_explicit_defaultedIn Large_defaultedOut_explicit_defaultedIn_var; /* global var */
+
+template int cbv<Large_defaultedOut_explicit_defaultedIn> (Large_defaultedOut_explicit_defaultedIn arg);
+/*** Class derived from Small_defaultedOut_explicit_defaultedIn ***/
+class Derived_defaultedOut_explicit_defaultedIn : public Small_defaultedOut_explicit_defaultedIn {
+public:
+};
+
+Derived_defaultedOut_explicit_defaultedIn Derived_defaultedOut_explicit_defaultedIn_var; /* global var */
+
+template int cbv<Derived_defaultedOut_explicit_defaultedIn> (Derived_defaultedOut_explicit_defaultedIn arg);
+/*** Class that contains Small_defaultedOut_explicit_defaultedIn ***/
+class Container_defaultedOut_explicit_defaultedIn {
+public:
+ Small_defaultedOut_explicit_defaultedIn item;
+};
+
+Container_defaultedOut_explicit_defaultedIn Container_defaultedOut_explicit_defaultedIn_var; /* global var */
+
+template int cbv_container<Container_defaultedOut_explicit_defaultedIn> (Container_defaultedOut_explicit_defaultedIn arg);
+/*** C++ class Small_defaultedOut_explicit_defaultedOut ***/
+class Small_defaultedOut_explicit_defaultedOut {
+public:
+ Small_defaultedOut_explicit_defaultedOut (void);
+ Small_defaultedOut_explicit_defaultedOut (const Small_defaultedOut_explicit_defaultedOut &rhs);
+ ~Small_defaultedOut_explicit_defaultedOut (void);
+ Small_defaultedOut_explicit_defaultedOut (Small_defaultedOut_explicit_defaultedOut &&rhs);
+
+
+ int data[2];
+};
+
+Small_defaultedOut_explicit_defaultedOut::Small_defaultedOut_explicit_defaultedOut (void)
+{
+ data[0] = 2;
+ data[1] = 2;
+}
+
+Small_defaultedOut_explicit_defaultedOut::Small_defaultedOut_explicit_defaultedOut (const Small_defaultedOut_explicit_defaultedOut &rhs) = default;
+Small_defaultedOut_explicit_defaultedOut::~Small_defaultedOut_explicit_defaultedOut (void)
+{
+ data[0] = 3;
+ data[1] = 3;
+ tracer = 5;
+}
+Small_defaultedOut_explicit_defaultedOut::Small_defaultedOut_explicit_defaultedOut (Small_defaultedOut_explicit_defaultedOut &&rhs) = default;
+
+
+Small_defaultedOut_explicit_defaultedOut Small_defaultedOut_explicit_defaultedOut_var; /* global var */
+
+template int cbv<Small_defaultedOut_explicit_defaultedOut> (Small_defaultedOut_explicit_defaultedOut arg);
+/*** C++ class Large_defaultedOut_explicit_defaultedOut ***/
+class Large_defaultedOut_explicit_defaultedOut {
+public:
+ Large_defaultedOut_explicit_defaultedOut (void);
+ Large_defaultedOut_explicit_defaultedOut (const Large_defaultedOut_explicit_defaultedOut &rhs);
+ ~Large_defaultedOut_explicit_defaultedOut (void);
+ Large_defaultedOut_explicit_defaultedOut (Large_defaultedOut_explicit_defaultedOut &&rhs);
+
+
+ int data[150];
+};
+
+Large_defaultedOut_explicit_defaultedOut::Large_defaultedOut_explicit_defaultedOut (void)
+{
+ data[0] = 2;
+ data[149] = 2;
+}
+
+Large_defaultedOut_explicit_defaultedOut::Large_defaultedOut_explicit_defaultedOut (const Large_defaultedOut_explicit_defaultedOut &rhs) = default;
+Large_defaultedOut_explicit_defaultedOut::~Large_defaultedOut_explicit_defaultedOut (void)
+{
+ data[0] = 3;
+ data[149] = 3;
+ tracer = 5;
+}
+Large_defaultedOut_explicit_defaultedOut::Large_defaultedOut_explicit_defaultedOut (Large_defaultedOut_explicit_defaultedOut &&rhs) = default;
+
+
+Large_defaultedOut_explicit_defaultedOut Large_defaultedOut_explicit_defaultedOut_var; /* global var */
+
+template int cbv<Large_defaultedOut_explicit_defaultedOut> (Large_defaultedOut_explicit_defaultedOut arg);
+/*** Class derived from Small_defaultedOut_explicit_defaultedOut ***/
+class Derived_defaultedOut_explicit_defaultedOut : public Small_defaultedOut_explicit_defaultedOut {
+public:
+};
+
+Derived_defaultedOut_explicit_defaultedOut Derived_defaultedOut_explicit_defaultedOut_var; /* global var */
+
+template int cbv<Derived_defaultedOut_explicit_defaultedOut> (Derived_defaultedOut_explicit_defaultedOut arg);
+/*** Class that contains Small_defaultedOut_explicit_defaultedOut ***/
+class Container_defaultedOut_explicit_defaultedOut {
+public:
+ Small_defaultedOut_explicit_defaultedOut item;
+};
+
+Container_defaultedOut_explicit_defaultedOut Container_defaultedOut_explicit_defaultedOut_var; /* global var */
+
+template int cbv_container<Container_defaultedOut_explicit_defaultedOut> (Container_defaultedOut_explicit_defaultedOut arg);
+/*** C++ class Small_defaultedOut_explicit_deleted ***/
+class Small_defaultedOut_explicit_deleted {
+public:
+ Small_defaultedOut_explicit_deleted (void);
+ Small_defaultedOut_explicit_deleted (const Small_defaultedOut_explicit_deleted &rhs);
+ ~Small_defaultedOut_explicit_deleted (void);
+ Small_defaultedOut_explicit_deleted (Small_defaultedOut_explicit_deleted &&rhs) = delete;
+
+
+ int data[2];
+};
+
+Small_defaultedOut_explicit_deleted::Small_defaultedOut_explicit_deleted (void)
+{
+ data[0] = 2;
+ data[1] = 2;
+}
+
+Small_defaultedOut_explicit_deleted::Small_defaultedOut_explicit_deleted (const Small_defaultedOut_explicit_deleted &rhs) = default;
+Small_defaultedOut_explicit_deleted::~Small_defaultedOut_explicit_deleted (void)
+{
+ data[0] = 3;
+ data[1] = 3;
+ tracer = 5;
+}
+
+
+Small_defaultedOut_explicit_deleted Small_defaultedOut_explicit_deleted_var; /* global var */
+
+template int cbv<Small_defaultedOut_explicit_deleted> (Small_defaultedOut_explicit_deleted arg);
+/*** C++ class Large_defaultedOut_explicit_deleted ***/
+class Large_defaultedOut_explicit_deleted {
+public:
+ Large_defaultedOut_explicit_deleted (void);
+ Large_defaultedOut_explicit_deleted (const Large_defaultedOut_explicit_deleted &rhs);
+ ~Large_defaultedOut_explicit_deleted (void);
+ Large_defaultedOut_explicit_deleted (Large_defaultedOut_explicit_deleted &&rhs) = delete;
+
+
+ int data[150];
+};
+
+Large_defaultedOut_explicit_deleted::Large_defaultedOut_explicit_deleted (void)
+{
+ data[0] = 2;
+ data[149] = 2;
+}
+
+Large_defaultedOut_explicit_deleted::Large_defaultedOut_explicit_deleted (const Large_defaultedOut_explicit_deleted &rhs) = default;
+Large_defaultedOut_explicit_deleted::~Large_defaultedOut_explicit_deleted (void)
+{
+ data[0] = 3;
+ data[149] = 3;
+ tracer = 5;
+}
+
+
+Large_defaultedOut_explicit_deleted Large_defaultedOut_explicit_deleted_var; /* global var */
+
+template int cbv<Large_defaultedOut_explicit_deleted> (Large_defaultedOut_explicit_deleted arg);
+/*** Class derived from Small_defaultedOut_explicit_deleted ***/
+class Derived_defaultedOut_explicit_deleted : public Small_defaultedOut_explicit_deleted {
+public:
+};
+
+Derived_defaultedOut_explicit_deleted Derived_defaultedOut_explicit_deleted_var; /* global var */
+
+template int cbv<Derived_defaultedOut_explicit_deleted> (Derived_defaultedOut_explicit_deleted arg);
+/*** Class that contains Small_defaultedOut_explicit_deleted ***/
+class Container_defaultedOut_explicit_deleted {
+public:
+ Small_defaultedOut_explicit_deleted item;
+};
+
+Container_defaultedOut_explicit_deleted Container_defaultedOut_explicit_deleted_var; /* global var */
+
+template int cbv_container<Container_defaultedOut_explicit_deleted> (Container_defaultedOut_explicit_deleted arg);
+/*** C++ class Small_defaultedOut_defaultedIn_absent ***/
+class Small_defaultedOut_defaultedIn_absent {
+public:
+ Small_defaultedOut_defaultedIn_absent (void);
+ Small_defaultedOut_defaultedIn_absent (const Small_defaultedOut_defaultedIn_absent &rhs);
+ ~Small_defaultedOut_defaultedIn_absent (void) = default;
+
+
+ int data[2];
+};
+
+Small_defaultedOut_defaultedIn_absent::Small_defaultedOut_defaultedIn_absent (void)
+{
+ data[0] = 2;
+ data[1] = 2;
+}
+
+Small_defaultedOut_defaultedIn_absent::Small_defaultedOut_defaultedIn_absent (const Small_defaultedOut_defaultedIn_absent &rhs) = default;
+
+
+Small_defaultedOut_defaultedIn_absent Small_defaultedOut_defaultedIn_absent_var; /* global var */
+
+template int cbv<Small_defaultedOut_defaultedIn_absent> (Small_defaultedOut_defaultedIn_absent arg);
+/*** C++ class Large_defaultedOut_defaultedIn_absent ***/
+class Large_defaultedOut_defaultedIn_absent {
+public:
+ Large_defaultedOut_defaultedIn_absent (void);
+ Large_defaultedOut_defaultedIn_absent (const Large_defaultedOut_defaultedIn_absent &rhs);
+ ~Large_defaultedOut_defaultedIn_absent (void) = default;
+
+
+ int data[150];
+};
+
+Large_defaultedOut_defaultedIn_absent::Large_defaultedOut_defaultedIn_absent (void)
+{
+ data[0] = 2;
+ data[149] = 2;
+}
+
+Large_defaultedOut_defaultedIn_absent::Large_defaultedOut_defaultedIn_absent (const Large_defaultedOut_defaultedIn_absent &rhs) = default;
+
+
+Large_defaultedOut_defaultedIn_absent Large_defaultedOut_defaultedIn_absent_var; /* global var */
+
+template int cbv<Large_defaultedOut_defaultedIn_absent> (Large_defaultedOut_defaultedIn_absent arg);
+/*** Class derived from Small_defaultedOut_defaultedIn_absent ***/
+class Derived_defaultedOut_defaultedIn_absent : public Small_defaultedOut_defaultedIn_absent {
+public:
+};
+
+Derived_defaultedOut_defaultedIn_absent Derived_defaultedOut_defaultedIn_absent_var; /* global var */
+
+template int cbv<Derived_defaultedOut_defaultedIn_absent> (Derived_defaultedOut_defaultedIn_absent arg);
+/*** Class that contains Small_defaultedOut_defaultedIn_absent ***/
+class Container_defaultedOut_defaultedIn_absent {
+public:
+ Small_defaultedOut_defaultedIn_absent item;
+};
+
+Container_defaultedOut_defaultedIn_absent Container_defaultedOut_defaultedIn_absent_var; /* global var */
+
+template int cbv_container<Container_defaultedOut_defaultedIn_absent> (Container_defaultedOut_defaultedIn_absent arg);
+/*** C++ class Small_defaultedOut_defaultedIn_explicit ***/
+class Small_defaultedOut_defaultedIn_explicit {
+public:
+ Small_defaultedOut_defaultedIn_explicit (void);
+ Small_defaultedOut_defaultedIn_explicit (const Small_defaultedOut_defaultedIn_explicit &rhs);
+ ~Small_defaultedOut_defaultedIn_explicit (void) = default;
+ Small_defaultedOut_defaultedIn_explicit (Small_defaultedOut_defaultedIn_explicit &&rhs);
+
+
+ int data[2];
+};
+
+Small_defaultedOut_defaultedIn_explicit::Small_defaultedOut_defaultedIn_explicit (void)
+{
+ data[0] = 2;
+ data[1] = 2;
+}
+
+Small_defaultedOut_defaultedIn_explicit::Small_defaultedOut_defaultedIn_explicit (const Small_defaultedOut_defaultedIn_explicit &rhs) = default;
+Small_defaultedOut_defaultedIn_explicit::Small_defaultedOut_defaultedIn_explicit (Small_defaultedOut_defaultedIn_explicit &&rhs)
+{
+ data[0] = 3;
+ data[1] = 3;
+ tracer = 5;
+}
+
+
+Small_defaultedOut_defaultedIn_explicit Small_defaultedOut_defaultedIn_explicit_var; /* global var */
+
+template int cbv<Small_defaultedOut_defaultedIn_explicit> (Small_defaultedOut_defaultedIn_explicit arg);
+/*** C++ class Large_defaultedOut_defaultedIn_explicit ***/
+class Large_defaultedOut_defaultedIn_explicit {
+public:
+ Large_defaultedOut_defaultedIn_explicit (void);
+ Large_defaultedOut_defaultedIn_explicit (const Large_defaultedOut_defaultedIn_explicit &rhs);
+ ~Large_defaultedOut_defaultedIn_explicit (void) = default;
+ Large_defaultedOut_defaultedIn_explicit (Large_defaultedOut_defaultedIn_explicit &&rhs);
+
+
+ int data[150];
+};
+
+Large_defaultedOut_defaultedIn_explicit::Large_defaultedOut_defaultedIn_explicit (void)
+{
+ data[0] = 2;
+ data[149] = 2;
+}
+
+Large_defaultedOut_defaultedIn_explicit::Large_defaultedOut_defaultedIn_explicit (const Large_defaultedOut_defaultedIn_explicit &rhs) = default;
+Large_defaultedOut_defaultedIn_explicit::Large_defaultedOut_defaultedIn_explicit (Large_defaultedOut_defaultedIn_explicit &&rhs)
+{
+ data[0] = 3;
+ data[149] = 3;
+ tracer = 5;
+}
+
+
+Large_defaultedOut_defaultedIn_explicit Large_defaultedOut_defaultedIn_explicit_var; /* global var */
+
+template int cbv<Large_defaultedOut_defaultedIn_explicit> (Large_defaultedOut_defaultedIn_explicit arg);
+/*** Class derived from Small_defaultedOut_defaultedIn_explicit ***/
+class Derived_defaultedOut_defaultedIn_explicit : public Small_defaultedOut_defaultedIn_explicit {
+public:
+};
+
+Derived_defaultedOut_defaultedIn_explicit Derived_defaultedOut_defaultedIn_explicit_var; /* global var */
+
+template int cbv<Derived_defaultedOut_defaultedIn_explicit> (Derived_defaultedOut_defaultedIn_explicit arg);
+/*** Class that contains Small_defaultedOut_defaultedIn_explicit ***/
+class Container_defaultedOut_defaultedIn_explicit {
+public:
+ Small_defaultedOut_defaultedIn_explicit item;
+};
+
+Container_defaultedOut_defaultedIn_explicit Container_defaultedOut_defaultedIn_explicit_var; /* global var */
+
+template int cbv_container<Container_defaultedOut_defaultedIn_explicit> (Container_defaultedOut_defaultedIn_explicit arg);
+/*** C++ class Small_defaultedOut_defaultedIn_defaultedIn ***/
+class Small_defaultedOut_defaultedIn_defaultedIn {
+public:
+ Small_defaultedOut_defaultedIn_defaultedIn (void);
+ Small_defaultedOut_defaultedIn_defaultedIn (const Small_defaultedOut_defaultedIn_defaultedIn &rhs);
+ ~Small_defaultedOut_defaultedIn_defaultedIn (void) = default;
+ Small_defaultedOut_defaultedIn_defaultedIn (Small_defaultedOut_defaultedIn_defaultedIn &&rhs) = default;
+
+
+ int data[2];
+};
+
+Small_defaultedOut_defaultedIn_defaultedIn::Small_defaultedOut_defaultedIn_defaultedIn (void)
+{
+ data[0] = 2;
+ data[1] = 2;
+}
+
+Small_defaultedOut_defaultedIn_defaultedIn::Small_defaultedOut_defaultedIn_defaultedIn (const Small_defaultedOut_defaultedIn_defaultedIn &rhs) = default;
+
+
+Small_defaultedOut_defaultedIn_defaultedIn Small_defaultedOut_defaultedIn_defaultedIn_var; /* global var */
+
+template int cbv<Small_defaultedOut_defaultedIn_defaultedIn> (Small_defaultedOut_defaultedIn_defaultedIn arg);
+/*** C++ class Large_defaultedOut_defaultedIn_defaultedIn ***/
+class Large_defaultedOut_defaultedIn_defaultedIn {
+public:
+ Large_defaultedOut_defaultedIn_defaultedIn (void);
+ Large_defaultedOut_defaultedIn_defaultedIn (const Large_defaultedOut_defaultedIn_defaultedIn &rhs);
+ ~Large_defaultedOut_defaultedIn_defaultedIn (void) = default;
+ Large_defaultedOut_defaultedIn_defaultedIn (Large_defaultedOut_defaultedIn_defaultedIn &&rhs) = default;
+
+
+ int data[150];
+};
+
+Large_defaultedOut_defaultedIn_defaultedIn::Large_defaultedOut_defaultedIn_defaultedIn (void)
+{
+ data[0] = 2;
+ data[149] = 2;
+}
+
+Large_defaultedOut_defaultedIn_defaultedIn::Large_defaultedOut_defaultedIn_defaultedIn (const Large_defaultedOut_defaultedIn_defaultedIn &rhs) = default;
+
+
+Large_defaultedOut_defaultedIn_defaultedIn Large_defaultedOut_defaultedIn_defaultedIn_var; /* global var */
+
+template int cbv<Large_defaultedOut_defaultedIn_defaultedIn> (Large_defaultedOut_defaultedIn_defaultedIn arg);
+/*** Class derived from Small_defaultedOut_defaultedIn_defaultedIn ***/
+class Derived_defaultedOut_defaultedIn_defaultedIn : public Small_defaultedOut_defaultedIn_defaultedIn {
+public:
+};
+
+Derived_defaultedOut_defaultedIn_defaultedIn Derived_defaultedOut_defaultedIn_defaultedIn_var; /* global var */
+
+template int cbv<Derived_defaultedOut_defaultedIn_defaultedIn> (Derived_defaultedOut_defaultedIn_defaultedIn arg);
+/*** Class that contains Small_defaultedOut_defaultedIn_defaultedIn ***/
+class Container_defaultedOut_defaultedIn_defaultedIn {
+public:
+ Small_defaultedOut_defaultedIn_defaultedIn item;
+};
+
+Container_defaultedOut_defaultedIn_defaultedIn Container_defaultedOut_defaultedIn_defaultedIn_var; /* global var */
+
+template int cbv_container<Container_defaultedOut_defaultedIn_defaultedIn> (Container_defaultedOut_defaultedIn_defaultedIn arg);
+/*** C++ class Small_defaultedOut_defaultedIn_defaultedOut ***/
+class Small_defaultedOut_defaultedIn_defaultedOut {
+public:
+ Small_defaultedOut_defaultedIn_defaultedOut (void);
+ Small_defaultedOut_defaultedIn_defaultedOut (const Small_defaultedOut_defaultedIn_defaultedOut &rhs);
+ ~Small_defaultedOut_defaultedIn_defaultedOut (void) = default;
+ Small_defaultedOut_defaultedIn_defaultedOut (Small_defaultedOut_defaultedIn_defaultedOut &&rhs);
+
+
+ int data[2];
+};
+
+Small_defaultedOut_defaultedIn_defaultedOut::Small_defaultedOut_defaultedIn_defaultedOut (void)
+{
+ data[0] = 2;
+ data[1] = 2;
+}
+
+Small_defaultedOut_defaultedIn_defaultedOut::Small_defaultedOut_defaultedIn_defaultedOut (const Small_defaultedOut_defaultedIn_defaultedOut &rhs) = default;
+Small_defaultedOut_defaultedIn_defaultedOut::Small_defaultedOut_defaultedIn_defaultedOut (Small_defaultedOut_defaultedIn_defaultedOut &&rhs) = default;
+
+
+Small_defaultedOut_defaultedIn_defaultedOut Small_defaultedOut_defaultedIn_defaultedOut_var; /* global var */
+
+template int cbv<Small_defaultedOut_defaultedIn_defaultedOut> (Small_defaultedOut_defaultedIn_defaultedOut arg);
+/*** C++ class Large_defaultedOut_defaultedIn_defaultedOut ***/
+class Large_defaultedOut_defaultedIn_defaultedOut {
+public:
+ Large_defaultedOut_defaultedIn_defaultedOut (void);
+ Large_defaultedOut_defaultedIn_defaultedOut (const Large_defaultedOut_defaultedIn_defaultedOut &rhs);
+ ~Large_defaultedOut_defaultedIn_defaultedOut (void) = default;
+ Large_defaultedOut_defaultedIn_defaultedOut (Large_defaultedOut_defaultedIn_defaultedOut &&rhs);
+
+
+ int data[150];
+};
+
+Large_defaultedOut_defaultedIn_defaultedOut::Large_defaultedOut_defaultedIn_defaultedOut (void)
+{
+ data[0] = 2;
+ data[149] = 2;
+}
+
+Large_defaultedOut_defaultedIn_defaultedOut::Large_defaultedOut_defaultedIn_defaultedOut (const Large_defaultedOut_defaultedIn_defaultedOut &rhs) = default;
+Large_defaultedOut_defaultedIn_defaultedOut::Large_defaultedOut_defaultedIn_defaultedOut (Large_defaultedOut_defaultedIn_defaultedOut &&rhs) = default;
+
+
+Large_defaultedOut_defaultedIn_defaultedOut Large_defaultedOut_defaultedIn_defaultedOut_var; /* global var */
+
+template int cbv<Large_defaultedOut_defaultedIn_defaultedOut> (Large_defaultedOut_defaultedIn_defaultedOut arg);
+/*** Class derived from Small_defaultedOut_defaultedIn_defaultedOut ***/
+class Derived_defaultedOut_defaultedIn_defaultedOut : public Small_defaultedOut_defaultedIn_defaultedOut {
+public:
+};
+
+Derived_defaultedOut_defaultedIn_defaultedOut Derived_defaultedOut_defaultedIn_defaultedOut_var; /* global var */
+
+template int cbv<Derived_defaultedOut_defaultedIn_defaultedOut> (Derived_defaultedOut_defaultedIn_defaultedOut arg);
+/*** Class that contains Small_defaultedOut_defaultedIn_defaultedOut ***/
+class Container_defaultedOut_defaultedIn_defaultedOut {
+public:
+ Small_defaultedOut_defaultedIn_defaultedOut item;
+};
+
+Container_defaultedOut_defaultedIn_defaultedOut Container_defaultedOut_defaultedIn_defaultedOut_var; /* global var */
+
+template int cbv_container<Container_defaultedOut_defaultedIn_defaultedOut> (Container_defaultedOut_defaultedIn_defaultedOut arg);
+/*** C++ class Small_defaultedOut_defaultedIn_deleted ***/
+class Small_defaultedOut_defaultedIn_deleted {
+public:
+ Small_defaultedOut_defaultedIn_deleted (void);
+ Small_defaultedOut_defaultedIn_deleted (const Small_defaultedOut_defaultedIn_deleted &rhs);
+ ~Small_defaultedOut_defaultedIn_deleted (void) = default;
+ Small_defaultedOut_defaultedIn_deleted (Small_defaultedOut_defaultedIn_deleted &&rhs) = delete;
+
+
+ int data[2];
+};
+
+Small_defaultedOut_defaultedIn_deleted::Small_defaultedOut_defaultedIn_deleted (void)
+{
+ data[0] = 2;
+ data[1] = 2;
+}
+
+Small_defaultedOut_defaultedIn_deleted::Small_defaultedOut_defaultedIn_deleted (const Small_defaultedOut_defaultedIn_deleted &rhs) = default;
+
+
+Small_defaultedOut_defaultedIn_deleted Small_defaultedOut_defaultedIn_deleted_var; /* global var */
+
+template int cbv<Small_defaultedOut_defaultedIn_deleted> (Small_defaultedOut_defaultedIn_deleted arg);
+/*** C++ class Large_defaultedOut_defaultedIn_deleted ***/
+class Large_defaultedOut_defaultedIn_deleted {
+public:
+ Large_defaultedOut_defaultedIn_deleted (void);
+ Large_defaultedOut_defaultedIn_deleted (const Large_defaultedOut_defaultedIn_deleted &rhs);
+ ~Large_defaultedOut_defaultedIn_deleted (void) = default;
+ Large_defaultedOut_defaultedIn_deleted (Large_defaultedOut_defaultedIn_deleted &&rhs) = delete;
+
+
+ int data[150];
+};
+
+Large_defaultedOut_defaultedIn_deleted::Large_defaultedOut_defaultedIn_deleted (void)
+{
+ data[0] = 2;
+ data[149] = 2;
+}
+
+Large_defaultedOut_defaultedIn_deleted::Large_defaultedOut_defaultedIn_deleted (const Large_defaultedOut_defaultedIn_deleted &rhs) = default;
+
+
+Large_defaultedOut_defaultedIn_deleted Large_defaultedOut_defaultedIn_deleted_var; /* global var */
+
+template int cbv<Large_defaultedOut_defaultedIn_deleted> (Large_defaultedOut_defaultedIn_deleted arg);
+/*** Class derived from Small_defaultedOut_defaultedIn_deleted ***/
+class Derived_defaultedOut_defaultedIn_deleted : public Small_defaultedOut_defaultedIn_deleted {
+public:
+};
+
+Derived_defaultedOut_defaultedIn_deleted Derived_defaultedOut_defaultedIn_deleted_var; /* global var */
+
+template int cbv<Derived_defaultedOut_defaultedIn_deleted> (Derived_defaultedOut_defaultedIn_deleted arg);
+/*** Class that contains Small_defaultedOut_defaultedIn_deleted ***/
+class Container_defaultedOut_defaultedIn_deleted {
+public:
+ Small_defaultedOut_defaultedIn_deleted item;
+};
+
+Container_defaultedOut_defaultedIn_deleted Container_defaultedOut_defaultedIn_deleted_var; /* global var */
+
+template int cbv_container<Container_defaultedOut_defaultedIn_deleted> (Container_defaultedOut_defaultedIn_deleted arg);
+/*** C++ class Small_defaultedOut_defaultedOut_absent ***/
+class Small_defaultedOut_defaultedOut_absent {
+public:
+ Small_defaultedOut_defaultedOut_absent (void);
+ Small_defaultedOut_defaultedOut_absent (const Small_defaultedOut_defaultedOut_absent &rhs);
+ ~Small_defaultedOut_defaultedOut_absent (void);
+
+
+ int data[2];
+};
+
+Small_defaultedOut_defaultedOut_absent::Small_defaultedOut_defaultedOut_absent (void)
+{
+ data[0] = 2;
+ data[1] = 2;
+}
+
+Small_defaultedOut_defaultedOut_absent::Small_defaultedOut_defaultedOut_absent (const Small_defaultedOut_defaultedOut_absent &rhs) = default;
+Small_defaultedOut_defaultedOut_absent::~Small_defaultedOut_defaultedOut_absent (void) = default;
+
+
+Small_defaultedOut_defaultedOut_absent Small_defaultedOut_defaultedOut_absent_var; /* global var */
+
+template int cbv<Small_defaultedOut_defaultedOut_absent> (Small_defaultedOut_defaultedOut_absent arg);
+/*** C++ class Large_defaultedOut_defaultedOut_absent ***/
+class Large_defaultedOut_defaultedOut_absent {
+public:
+ Large_defaultedOut_defaultedOut_absent (void);
+ Large_defaultedOut_defaultedOut_absent (const Large_defaultedOut_defaultedOut_absent &rhs);
+ ~Large_defaultedOut_defaultedOut_absent (void);
+
+
+ int data[150];
+};
+
+Large_defaultedOut_defaultedOut_absent::Large_defaultedOut_defaultedOut_absent (void)
+{
+ data[0] = 2;
+ data[149] = 2;
+}
+
+Large_defaultedOut_defaultedOut_absent::Large_defaultedOut_defaultedOut_absent (const Large_defaultedOut_defaultedOut_absent &rhs) = default;
+Large_defaultedOut_defaultedOut_absent::~Large_defaultedOut_defaultedOut_absent (void) = default;
+
+
+Large_defaultedOut_defaultedOut_absent Large_defaultedOut_defaultedOut_absent_var; /* global var */
+
+template int cbv<Large_defaultedOut_defaultedOut_absent> (Large_defaultedOut_defaultedOut_absent arg);
+/*** Class derived from Small_defaultedOut_defaultedOut_absent ***/
+class Derived_defaultedOut_defaultedOut_absent : public Small_defaultedOut_defaultedOut_absent {
+public:
+};
+
+Derived_defaultedOut_defaultedOut_absent Derived_defaultedOut_defaultedOut_absent_var; /* global var */
+
+template int cbv<Derived_defaultedOut_defaultedOut_absent> (Derived_defaultedOut_defaultedOut_absent arg);
+/*** Class that contains Small_defaultedOut_defaultedOut_absent ***/
+class Container_defaultedOut_defaultedOut_absent {
+public:
+ Small_defaultedOut_defaultedOut_absent item;
+};
+
+Container_defaultedOut_defaultedOut_absent Container_defaultedOut_defaultedOut_absent_var; /* global var */
+
+template int cbv_container<Container_defaultedOut_defaultedOut_absent> (Container_defaultedOut_defaultedOut_absent arg);
+/*** C++ class Small_defaultedOut_defaultedOut_explicit ***/
+class Small_defaultedOut_defaultedOut_explicit {
+public:
+ Small_defaultedOut_defaultedOut_explicit (void);
+ Small_defaultedOut_defaultedOut_explicit (const Small_defaultedOut_defaultedOut_explicit &rhs);
+ ~Small_defaultedOut_defaultedOut_explicit (void);
+ Small_defaultedOut_defaultedOut_explicit (Small_defaultedOut_defaultedOut_explicit &&rhs);
+
+
+ int data[2];
+};
+
+Small_defaultedOut_defaultedOut_explicit::Small_defaultedOut_defaultedOut_explicit (void)
+{
+ data[0] = 2;
+ data[1] = 2;
+}
+
+Small_defaultedOut_defaultedOut_explicit::Small_defaultedOut_defaultedOut_explicit (const Small_defaultedOut_defaultedOut_explicit &rhs) = default;
+Small_defaultedOut_defaultedOut_explicit::~Small_defaultedOut_defaultedOut_explicit (void) = default;
+Small_defaultedOut_defaultedOut_explicit::Small_defaultedOut_defaultedOut_explicit (Small_defaultedOut_defaultedOut_explicit &&rhs)
+{
+ data[0] = 3;
+ data[1] = 3;
+ tracer = 5;
+}
+
+
+Small_defaultedOut_defaultedOut_explicit Small_defaultedOut_defaultedOut_explicit_var; /* global var */
+
+template int cbv<Small_defaultedOut_defaultedOut_explicit> (Small_defaultedOut_defaultedOut_explicit arg);
+/*** C++ class Large_defaultedOut_defaultedOut_explicit ***/
+class Large_defaultedOut_defaultedOut_explicit {
+public:
+ Large_defaultedOut_defaultedOut_explicit (void);
+ Large_defaultedOut_defaultedOut_explicit (const Large_defaultedOut_defaultedOut_explicit &rhs);
+ ~Large_defaultedOut_defaultedOut_explicit (void);
+ Large_defaultedOut_defaultedOut_explicit (Large_defaultedOut_defaultedOut_explicit &&rhs);
+
+
+ int data[150];
+};
+
+Large_defaultedOut_defaultedOut_explicit::Large_defaultedOut_defaultedOut_explicit (void)
+{
+ data[0] = 2;
+ data[149] = 2;
+}
+
+Large_defaultedOut_defaultedOut_explicit::Large_defaultedOut_defaultedOut_explicit (const Large_defaultedOut_defaultedOut_explicit &rhs) = default;
+Large_defaultedOut_defaultedOut_explicit::~Large_defaultedOut_defaultedOut_explicit (void) = default;
+Large_defaultedOut_defaultedOut_explicit::Large_defaultedOut_defaultedOut_explicit (Large_defaultedOut_defaultedOut_explicit &&rhs)
+{
+ data[0] = 3;
+ data[149] = 3;
+ tracer = 5;
+}
+
+
+Large_defaultedOut_defaultedOut_explicit Large_defaultedOut_defaultedOut_explicit_var; /* global var */
+
+template int cbv<Large_defaultedOut_defaultedOut_explicit> (Large_defaultedOut_defaultedOut_explicit arg);
+/*** Class derived from Small_defaultedOut_defaultedOut_explicit ***/
+class Derived_defaultedOut_defaultedOut_explicit : public Small_defaultedOut_defaultedOut_explicit {
+public:
+};
+
+Derived_defaultedOut_defaultedOut_explicit Derived_defaultedOut_defaultedOut_explicit_var; /* global var */
+
+template int cbv<Derived_defaultedOut_defaultedOut_explicit> (Derived_defaultedOut_defaultedOut_explicit arg);
+/*** Class that contains Small_defaultedOut_defaultedOut_explicit ***/
+class Container_defaultedOut_defaultedOut_explicit {
+public:
+ Small_defaultedOut_defaultedOut_explicit item;
+};
+
+Container_defaultedOut_defaultedOut_explicit Container_defaultedOut_defaultedOut_explicit_var; /* global var */
+
+template int cbv_container<Container_defaultedOut_defaultedOut_explicit> (Container_defaultedOut_defaultedOut_explicit arg);
+/*** C++ class Small_defaultedOut_defaultedOut_defaultedIn ***/
+class Small_defaultedOut_defaultedOut_defaultedIn {
+public:
+ Small_defaultedOut_defaultedOut_defaultedIn (void);
+ Small_defaultedOut_defaultedOut_defaultedIn (const Small_defaultedOut_defaultedOut_defaultedIn &rhs);
+ ~Small_defaultedOut_defaultedOut_defaultedIn (void);
+ Small_defaultedOut_defaultedOut_defaultedIn (Small_defaultedOut_defaultedOut_defaultedIn &&rhs) = default;
+
+
+ int data[2];
+};
+
+Small_defaultedOut_defaultedOut_defaultedIn::Small_defaultedOut_defaultedOut_defaultedIn (void)
+{
+ data[0] = 2;
+ data[1] = 2;
+}
+
+Small_defaultedOut_defaultedOut_defaultedIn::Small_defaultedOut_defaultedOut_defaultedIn (const Small_defaultedOut_defaultedOut_defaultedIn &rhs) = default;
+Small_defaultedOut_defaultedOut_defaultedIn::~Small_defaultedOut_defaultedOut_defaultedIn (void) = default;
+
+
+Small_defaultedOut_defaultedOut_defaultedIn Small_defaultedOut_defaultedOut_defaultedIn_var; /* global var */
+
+template int cbv<Small_defaultedOut_defaultedOut_defaultedIn> (Small_defaultedOut_defaultedOut_defaultedIn arg);
+/*** C++ class Large_defaultedOut_defaultedOut_defaultedIn ***/
+class Large_defaultedOut_defaultedOut_defaultedIn {
+public:
+ Large_defaultedOut_defaultedOut_defaultedIn (void);
+ Large_defaultedOut_defaultedOut_defaultedIn (const Large_defaultedOut_defaultedOut_defaultedIn &rhs);
+ ~Large_defaultedOut_defaultedOut_defaultedIn (void);
+ Large_defaultedOut_defaultedOut_defaultedIn (Large_defaultedOut_defaultedOut_defaultedIn &&rhs) = default;
+
+
+ int data[150];
+};
+
+Large_defaultedOut_defaultedOut_defaultedIn::Large_defaultedOut_defaultedOut_defaultedIn (void)
+{
+ data[0] = 2;
+ data[149] = 2;
+}
+
+Large_defaultedOut_defaultedOut_defaultedIn::Large_defaultedOut_defaultedOut_defaultedIn (const Large_defaultedOut_defaultedOut_defaultedIn &rhs) = default;
+Large_defaultedOut_defaultedOut_defaultedIn::~Large_defaultedOut_defaultedOut_defaultedIn (void) = default;
+
+
+Large_defaultedOut_defaultedOut_defaultedIn Large_defaultedOut_defaultedOut_defaultedIn_var; /* global var */
+
+template int cbv<Large_defaultedOut_defaultedOut_defaultedIn> (Large_defaultedOut_defaultedOut_defaultedIn arg);
+/*** Class derived from Small_defaultedOut_defaultedOut_defaultedIn ***/
+class Derived_defaultedOut_defaultedOut_defaultedIn : public Small_defaultedOut_defaultedOut_defaultedIn {
+public:
+};
+
+Derived_defaultedOut_defaultedOut_defaultedIn Derived_defaultedOut_defaultedOut_defaultedIn_var; /* global var */
+
+template int cbv<Derived_defaultedOut_defaultedOut_defaultedIn> (Derived_defaultedOut_defaultedOut_defaultedIn arg);
+/*** Class that contains Small_defaultedOut_defaultedOut_defaultedIn ***/
+class Container_defaultedOut_defaultedOut_defaultedIn {
+public:
+ Small_defaultedOut_defaultedOut_defaultedIn item;
+};
+
+Container_defaultedOut_defaultedOut_defaultedIn Container_defaultedOut_defaultedOut_defaultedIn_var; /* global var */
+
+template int cbv_container<Container_defaultedOut_defaultedOut_defaultedIn> (Container_defaultedOut_defaultedOut_defaultedIn arg);
+/*** C++ class Small_defaultedOut_defaultedOut_defaultedOut ***/
+class Small_defaultedOut_defaultedOut_defaultedOut {
+public:
+ Small_defaultedOut_defaultedOut_defaultedOut (void);
+ Small_defaultedOut_defaultedOut_defaultedOut (const Small_defaultedOut_defaultedOut_defaultedOut &rhs);
+ ~Small_defaultedOut_defaultedOut_defaultedOut (void);
+ Small_defaultedOut_defaultedOut_defaultedOut (Small_defaultedOut_defaultedOut_defaultedOut &&rhs);
+
+
+ int data[2];
+};
+
+Small_defaultedOut_defaultedOut_defaultedOut::Small_defaultedOut_defaultedOut_defaultedOut (void)
+{
+ data[0] = 2;
+ data[1] = 2;
+}
+
+Small_defaultedOut_defaultedOut_defaultedOut::Small_defaultedOut_defaultedOut_defaultedOut (const Small_defaultedOut_defaultedOut_defaultedOut &rhs) = default;
+Small_defaultedOut_defaultedOut_defaultedOut::~Small_defaultedOut_defaultedOut_defaultedOut (void) = default;
+Small_defaultedOut_defaultedOut_defaultedOut::Small_defaultedOut_defaultedOut_defaultedOut (Small_defaultedOut_defaultedOut_defaultedOut &&rhs) = default;
+
+
+Small_defaultedOut_defaultedOut_defaultedOut Small_defaultedOut_defaultedOut_defaultedOut_var; /* global var */
+
+template int cbv<Small_defaultedOut_defaultedOut_defaultedOut> (Small_defaultedOut_defaultedOut_defaultedOut arg);
+/*** C++ class Large_defaultedOut_defaultedOut_defaultedOut ***/
+class Large_defaultedOut_defaultedOut_defaultedOut {
+public:
+ Large_defaultedOut_defaultedOut_defaultedOut (void);
+ Large_defaultedOut_defaultedOut_defaultedOut (const Large_defaultedOut_defaultedOut_defaultedOut &rhs);
+ ~Large_defaultedOut_defaultedOut_defaultedOut (void);
+ Large_defaultedOut_defaultedOut_defaultedOut (Large_defaultedOut_defaultedOut_defaultedOut &&rhs);
+
+
+ int data[150];
+};
+
+Large_defaultedOut_defaultedOut_defaultedOut::Large_defaultedOut_defaultedOut_defaultedOut (void)
+{
+ data[0] = 2;
+ data[149] = 2;
+}
+
+Large_defaultedOut_defaultedOut_defaultedOut::Large_defaultedOut_defaultedOut_defaultedOut (const Large_defaultedOut_defaultedOut_defaultedOut &rhs) = default;
+Large_defaultedOut_defaultedOut_defaultedOut::~Large_defaultedOut_defaultedOut_defaultedOut (void) = default;
+Large_defaultedOut_defaultedOut_defaultedOut::Large_defaultedOut_defaultedOut_defaultedOut (Large_defaultedOut_defaultedOut_defaultedOut &&rhs) = default;
+
+
+Large_defaultedOut_defaultedOut_defaultedOut Large_defaultedOut_defaultedOut_defaultedOut_var; /* global var */
+
+template int cbv<Large_defaultedOut_defaultedOut_defaultedOut> (Large_defaultedOut_defaultedOut_defaultedOut arg);
+/*** Class derived from Small_defaultedOut_defaultedOut_defaultedOut ***/
+class Derived_defaultedOut_defaultedOut_defaultedOut : public Small_defaultedOut_defaultedOut_defaultedOut {
+public:
+};
+
+Derived_defaultedOut_defaultedOut_defaultedOut Derived_defaultedOut_defaultedOut_defaultedOut_var; /* global var */
+
+template int cbv<Derived_defaultedOut_defaultedOut_defaultedOut> (Derived_defaultedOut_defaultedOut_defaultedOut arg);
+/*** Class that contains Small_defaultedOut_defaultedOut_defaultedOut ***/
+class Container_defaultedOut_defaultedOut_defaultedOut {
+public:
+ Small_defaultedOut_defaultedOut_defaultedOut item;
+};
+
+Container_defaultedOut_defaultedOut_defaultedOut Container_defaultedOut_defaultedOut_defaultedOut_var; /* global var */
+
+template int cbv_container<Container_defaultedOut_defaultedOut_defaultedOut> (Container_defaultedOut_defaultedOut_defaultedOut arg);
+/*** C++ class Small_defaultedOut_defaultedOut_deleted ***/
+class Small_defaultedOut_defaultedOut_deleted {
+public:
+ Small_defaultedOut_defaultedOut_deleted (void);
+ Small_defaultedOut_defaultedOut_deleted (const Small_defaultedOut_defaultedOut_deleted &rhs);
+ ~Small_defaultedOut_defaultedOut_deleted (void);
+ Small_defaultedOut_defaultedOut_deleted (Small_defaultedOut_defaultedOut_deleted &&rhs) = delete;
+
+
+ int data[2];
+};
+
+Small_defaultedOut_defaultedOut_deleted::Small_defaultedOut_defaultedOut_deleted (void)
+{
+ data[0] = 2;
+ data[1] = 2;
+}
+
+Small_defaultedOut_defaultedOut_deleted::Small_defaultedOut_defaultedOut_deleted (const Small_defaultedOut_defaultedOut_deleted &rhs) = default;
+Small_defaultedOut_defaultedOut_deleted::~Small_defaultedOut_defaultedOut_deleted (void) = default;
+
+
+Small_defaultedOut_defaultedOut_deleted Small_defaultedOut_defaultedOut_deleted_var; /* global var */
+
+template int cbv<Small_defaultedOut_defaultedOut_deleted> (Small_defaultedOut_defaultedOut_deleted arg);
+/*** C++ class Large_defaultedOut_defaultedOut_deleted ***/
+class Large_defaultedOut_defaultedOut_deleted {
+public:
+ Large_defaultedOut_defaultedOut_deleted (void);
+ Large_defaultedOut_defaultedOut_deleted (const Large_defaultedOut_defaultedOut_deleted &rhs);
+ ~Large_defaultedOut_defaultedOut_deleted (void);
+ Large_defaultedOut_defaultedOut_deleted (Large_defaultedOut_defaultedOut_deleted &&rhs) = delete;
+
+
+ int data[150];
+};
+
+Large_defaultedOut_defaultedOut_deleted::Large_defaultedOut_defaultedOut_deleted (void)
+{
+ data[0] = 2;
+ data[149] = 2;
+}
+
+Large_defaultedOut_defaultedOut_deleted::Large_defaultedOut_defaultedOut_deleted (const Large_defaultedOut_defaultedOut_deleted &rhs) = default;
+Large_defaultedOut_defaultedOut_deleted::~Large_defaultedOut_defaultedOut_deleted (void) = default;
+
+
+Large_defaultedOut_defaultedOut_deleted Large_defaultedOut_defaultedOut_deleted_var; /* global var */
+
+template int cbv<Large_defaultedOut_defaultedOut_deleted> (Large_defaultedOut_defaultedOut_deleted arg);
+/*** Class derived from Small_defaultedOut_defaultedOut_deleted ***/
+class Derived_defaultedOut_defaultedOut_deleted : public Small_defaultedOut_defaultedOut_deleted {
+public:
+};
+
+Derived_defaultedOut_defaultedOut_deleted Derived_defaultedOut_defaultedOut_deleted_var; /* global var */
+
+template int cbv<Derived_defaultedOut_defaultedOut_deleted> (Derived_defaultedOut_defaultedOut_deleted arg);
+/*** Class that contains Small_defaultedOut_defaultedOut_deleted ***/
+class Container_defaultedOut_defaultedOut_deleted {
+public:
+ Small_defaultedOut_defaultedOut_deleted item;
+};
+
+Container_defaultedOut_defaultedOut_deleted Container_defaultedOut_defaultedOut_deleted_var; /* global var */
+
+template int cbv_container<Container_defaultedOut_defaultedOut_deleted> (Container_defaultedOut_defaultedOut_deleted arg);
+/*** C++ class Small_deleted_absent_absent ***/
+class Small_deleted_absent_absent {
+public:
+ Small_deleted_absent_absent (void);
+ Small_deleted_absent_absent (const Small_deleted_absent_absent &rhs) = delete;
+
+
+ int data[2];
+};
+
+Small_deleted_absent_absent::Small_deleted_absent_absent (void)
+{
+ data[0] = 2;
+ data[1] = 2;
+}
+
+
+
+Small_deleted_absent_absent Small_deleted_absent_absent_var; /* global var */
+
+template int cbv<Small_deleted_absent_absent> (Small_deleted_absent_absent arg);
+/*** C++ class Large_deleted_absent_absent ***/
+class Large_deleted_absent_absent {
+public:
+ Large_deleted_absent_absent (void);
+ Large_deleted_absent_absent (const Large_deleted_absent_absent &rhs) = delete;
+
+
+ int data[150];
+};
+
+Large_deleted_absent_absent::Large_deleted_absent_absent (void)
+{
+ data[0] = 2;
+ data[149] = 2;
+}
+
+
+
+Large_deleted_absent_absent Large_deleted_absent_absent_var; /* global var */
+
+template int cbv<Large_deleted_absent_absent> (Large_deleted_absent_absent arg);
+/*** Class derived from Small_deleted_absent_absent ***/
+class Derived_deleted_absent_absent : public Small_deleted_absent_absent {
+public:
+};
+
+Derived_deleted_absent_absent Derived_deleted_absent_absent_var; /* global var */
+
+template int cbv<Derived_deleted_absent_absent> (Derived_deleted_absent_absent arg);
+/*** Class that contains Small_deleted_absent_absent ***/
+class Container_deleted_absent_absent {
+public:
+ Small_deleted_absent_absent item;
+};
+
+Container_deleted_absent_absent Container_deleted_absent_absent_var; /* global var */
+
+template int cbv_container<Container_deleted_absent_absent> (Container_deleted_absent_absent arg);
+/*** C++ class Small_deleted_absent_explicit ***/
+class Small_deleted_absent_explicit {
+public:
+ Small_deleted_absent_explicit (void);
+ Small_deleted_absent_explicit (const Small_deleted_absent_explicit &rhs) = delete;
+ Small_deleted_absent_explicit (Small_deleted_absent_explicit &&rhs);
+
+
+ int data[2];
+};
+
+Small_deleted_absent_explicit::Small_deleted_absent_explicit (void)
+{
+ data[0] = 2;
+ data[1] = 2;
+}
+
+Small_deleted_absent_explicit::Small_deleted_absent_explicit (Small_deleted_absent_explicit &&rhs)
+{
+ data[0] = 3;
+ data[1] = 3;
+ tracer = 5;
+}
+
+
+Small_deleted_absent_explicit Small_deleted_absent_explicit_var; /* global var */
+
+template int cbv<Small_deleted_absent_explicit> (Small_deleted_absent_explicit arg);
+/*** C++ class Large_deleted_absent_explicit ***/
+class Large_deleted_absent_explicit {
+public:
+ Large_deleted_absent_explicit (void);
+ Large_deleted_absent_explicit (const Large_deleted_absent_explicit &rhs) = delete;
+ Large_deleted_absent_explicit (Large_deleted_absent_explicit &&rhs);
+
+
+ int data[150];
+};
+
+Large_deleted_absent_explicit::Large_deleted_absent_explicit (void)
+{
+ data[0] = 2;
+ data[149] = 2;
+}
+
+Large_deleted_absent_explicit::Large_deleted_absent_explicit (Large_deleted_absent_explicit &&rhs)
+{
+ data[0] = 3;
+ data[149] = 3;
+ tracer = 5;
+}
+
+
+Large_deleted_absent_explicit Large_deleted_absent_explicit_var; /* global var */
+
+template int cbv<Large_deleted_absent_explicit> (Large_deleted_absent_explicit arg);
+/*** Class derived from Small_deleted_absent_explicit ***/
+class Derived_deleted_absent_explicit : public Small_deleted_absent_explicit {
+public:
+};
+
+Derived_deleted_absent_explicit Derived_deleted_absent_explicit_var; /* global var */
+
+template int cbv<Derived_deleted_absent_explicit> (Derived_deleted_absent_explicit arg);
+/*** Class that contains Small_deleted_absent_explicit ***/
+class Container_deleted_absent_explicit {
+public:
+ Small_deleted_absent_explicit item;
+};
+
+Container_deleted_absent_explicit Container_deleted_absent_explicit_var; /* global var */
+
+template int cbv_container<Container_deleted_absent_explicit> (Container_deleted_absent_explicit arg);
+/*** C++ class Small_deleted_absent_defaultedIn ***/
+class Small_deleted_absent_defaultedIn {
+public:
+ Small_deleted_absent_defaultedIn (void);
+ Small_deleted_absent_defaultedIn (const Small_deleted_absent_defaultedIn &rhs) = delete;
+ Small_deleted_absent_defaultedIn (Small_deleted_absent_defaultedIn &&rhs) = default;
+
+
+ int data[2];
+};
+
+Small_deleted_absent_defaultedIn::Small_deleted_absent_defaultedIn (void)
+{
+ data[0] = 2;
+ data[1] = 2;
+}
+
+
+
+Small_deleted_absent_defaultedIn Small_deleted_absent_defaultedIn_var; /* global var */
+
+template int cbv<Small_deleted_absent_defaultedIn> (Small_deleted_absent_defaultedIn arg);
+/*** C++ class Large_deleted_absent_defaultedIn ***/
+class Large_deleted_absent_defaultedIn {
+public:
+ Large_deleted_absent_defaultedIn (void);
+ Large_deleted_absent_defaultedIn (const Large_deleted_absent_defaultedIn &rhs) = delete;
+ Large_deleted_absent_defaultedIn (Large_deleted_absent_defaultedIn &&rhs) = default;
+
+
+ int data[150];
+};
+
+Large_deleted_absent_defaultedIn::Large_deleted_absent_defaultedIn (void)
+{
+ data[0] = 2;
+ data[149] = 2;
+}
+
+
+
+Large_deleted_absent_defaultedIn Large_deleted_absent_defaultedIn_var; /* global var */
+
+template int cbv<Large_deleted_absent_defaultedIn> (Large_deleted_absent_defaultedIn arg);
+/*** Class derived from Small_deleted_absent_defaultedIn ***/
+class Derived_deleted_absent_defaultedIn : public Small_deleted_absent_defaultedIn {
+public:
+};
+
+Derived_deleted_absent_defaultedIn Derived_deleted_absent_defaultedIn_var; /* global var */
+
+template int cbv<Derived_deleted_absent_defaultedIn> (Derived_deleted_absent_defaultedIn arg);
+/*** Class that contains Small_deleted_absent_defaultedIn ***/
+class Container_deleted_absent_defaultedIn {
+public:
+ Small_deleted_absent_defaultedIn item;
+};
+
+Container_deleted_absent_defaultedIn Container_deleted_absent_defaultedIn_var; /* global var */
+
+template int cbv_container<Container_deleted_absent_defaultedIn> (Container_deleted_absent_defaultedIn arg);
+/*** C++ class Small_deleted_absent_defaultedOut ***/
+class Small_deleted_absent_defaultedOut {
+public:
+ Small_deleted_absent_defaultedOut (void);
+ Small_deleted_absent_defaultedOut (const Small_deleted_absent_defaultedOut &rhs) = delete;
+ Small_deleted_absent_defaultedOut (Small_deleted_absent_defaultedOut &&rhs);
+
+
+ int data[2];
+};
+
+Small_deleted_absent_defaultedOut::Small_deleted_absent_defaultedOut (void)
+{
+ data[0] = 2;
+ data[1] = 2;
+}
+
+Small_deleted_absent_defaultedOut::Small_deleted_absent_defaultedOut (Small_deleted_absent_defaultedOut &&rhs) = default;
+
+
+Small_deleted_absent_defaultedOut Small_deleted_absent_defaultedOut_var; /* global var */
+
+template int cbv<Small_deleted_absent_defaultedOut> (Small_deleted_absent_defaultedOut arg);
+/*** C++ class Large_deleted_absent_defaultedOut ***/
+class Large_deleted_absent_defaultedOut {
+public:
+ Large_deleted_absent_defaultedOut (void);
+ Large_deleted_absent_defaultedOut (const Large_deleted_absent_defaultedOut &rhs) = delete;
+ Large_deleted_absent_defaultedOut (Large_deleted_absent_defaultedOut &&rhs);
+
+
+ int data[150];
+};
+
+Large_deleted_absent_defaultedOut::Large_deleted_absent_defaultedOut (void)
+{
+ data[0] = 2;
+ data[149] = 2;
+}
+
+Large_deleted_absent_defaultedOut::Large_deleted_absent_defaultedOut (Large_deleted_absent_defaultedOut &&rhs) = default;
+
+
+Large_deleted_absent_defaultedOut Large_deleted_absent_defaultedOut_var; /* global var */
+
+template int cbv<Large_deleted_absent_defaultedOut> (Large_deleted_absent_defaultedOut arg);
+/*** Class derived from Small_deleted_absent_defaultedOut ***/
+class Derived_deleted_absent_defaultedOut : public Small_deleted_absent_defaultedOut {
+public:
+};
+
+Derived_deleted_absent_defaultedOut Derived_deleted_absent_defaultedOut_var; /* global var */
+
+template int cbv<Derived_deleted_absent_defaultedOut> (Derived_deleted_absent_defaultedOut arg);
+/*** Class that contains Small_deleted_absent_defaultedOut ***/
+class Container_deleted_absent_defaultedOut {
+public:
+ Small_deleted_absent_defaultedOut item;
+};
+
+Container_deleted_absent_defaultedOut Container_deleted_absent_defaultedOut_var; /* global var */
+
+template int cbv_container<Container_deleted_absent_defaultedOut> (Container_deleted_absent_defaultedOut arg);
+/*** C++ class Small_deleted_absent_deleted ***/
+class Small_deleted_absent_deleted {
+public:
+ Small_deleted_absent_deleted (void);
+ Small_deleted_absent_deleted (const Small_deleted_absent_deleted &rhs) = delete;
+ Small_deleted_absent_deleted (Small_deleted_absent_deleted &&rhs) = delete;
+
+
+ int data[2];
+};
+
+Small_deleted_absent_deleted::Small_deleted_absent_deleted (void)
+{
+ data[0] = 2;
+ data[1] = 2;
+}
+
+
+
+Small_deleted_absent_deleted Small_deleted_absent_deleted_var; /* global var */
+
+template int cbv<Small_deleted_absent_deleted> (Small_deleted_absent_deleted arg);
+/*** C++ class Large_deleted_absent_deleted ***/
+class Large_deleted_absent_deleted {
+public:
+ Large_deleted_absent_deleted (void);
+ Large_deleted_absent_deleted (const Large_deleted_absent_deleted &rhs) = delete;
+ Large_deleted_absent_deleted (Large_deleted_absent_deleted &&rhs) = delete;
+
+
+ int data[150];
+};
+
+Large_deleted_absent_deleted::Large_deleted_absent_deleted (void)
+{
+ data[0] = 2;
+ data[149] = 2;
+}
+
+
+
+Large_deleted_absent_deleted Large_deleted_absent_deleted_var; /* global var */
+
+template int cbv<Large_deleted_absent_deleted> (Large_deleted_absent_deleted arg);
+/*** Class derived from Small_deleted_absent_deleted ***/
+class Derived_deleted_absent_deleted : public Small_deleted_absent_deleted {
+public:
+};
+
+Derived_deleted_absent_deleted Derived_deleted_absent_deleted_var; /* global var */
+
+template int cbv<Derived_deleted_absent_deleted> (Derived_deleted_absent_deleted arg);
+/*** Class that contains Small_deleted_absent_deleted ***/
+class Container_deleted_absent_deleted {
+public:
+ Small_deleted_absent_deleted item;
+};
+
+Container_deleted_absent_deleted Container_deleted_absent_deleted_var; /* global var */
+
+template int cbv_container<Container_deleted_absent_deleted> (Container_deleted_absent_deleted arg);
+/*** C++ class Small_deleted_explicit_absent ***/
+class Small_deleted_explicit_absent {
+public:
+ Small_deleted_explicit_absent (void);
+ Small_deleted_explicit_absent (const Small_deleted_explicit_absent &rhs) = delete;
+ ~Small_deleted_explicit_absent (void);
+
+
+ int data[2];
+};
+
+Small_deleted_explicit_absent::Small_deleted_explicit_absent (void)
+{
+ data[0] = 2;
+ data[1] = 2;
+}
+
+Small_deleted_explicit_absent::~Small_deleted_explicit_absent (void)
+{
+ data[0] = 3;
+ data[1] = 3;
+ tracer = 5;
+}
+
+
+Small_deleted_explicit_absent Small_deleted_explicit_absent_var; /* global var */
+
+template int cbv<Small_deleted_explicit_absent> (Small_deleted_explicit_absent arg);
+/*** C++ class Large_deleted_explicit_absent ***/
+class Large_deleted_explicit_absent {
+public:
+ Large_deleted_explicit_absent (void);
+ Large_deleted_explicit_absent (const Large_deleted_explicit_absent &rhs) = delete;
+ ~Large_deleted_explicit_absent (void);
+
+
+ int data[150];
+};
+
+Large_deleted_explicit_absent::Large_deleted_explicit_absent (void)
+{
+ data[0] = 2;
+ data[149] = 2;
+}
+
+Large_deleted_explicit_absent::~Large_deleted_explicit_absent (void)
+{
+ data[0] = 3;
+ data[149] = 3;
+ tracer = 5;
+}
+
+
+Large_deleted_explicit_absent Large_deleted_explicit_absent_var; /* global var */
+
+template int cbv<Large_deleted_explicit_absent> (Large_deleted_explicit_absent arg);
+/*** Class derived from Small_deleted_explicit_absent ***/
+class Derived_deleted_explicit_absent : public Small_deleted_explicit_absent {
+public:
+};
+
+Derived_deleted_explicit_absent Derived_deleted_explicit_absent_var; /* global var */
+
+template int cbv<Derived_deleted_explicit_absent> (Derived_deleted_explicit_absent arg);
+/*** Class that contains Small_deleted_explicit_absent ***/
+class Container_deleted_explicit_absent {
+public:
+ Small_deleted_explicit_absent item;
+};
+
+Container_deleted_explicit_absent Container_deleted_explicit_absent_var; /* global var */
+
+template int cbv_container<Container_deleted_explicit_absent> (Container_deleted_explicit_absent arg);
+/*** C++ class Small_deleted_explicit_explicit ***/
+class Small_deleted_explicit_explicit {
+public:
+ Small_deleted_explicit_explicit (void);
+ Small_deleted_explicit_explicit (const Small_deleted_explicit_explicit &rhs) = delete;
+ ~Small_deleted_explicit_explicit (void);
+ Small_deleted_explicit_explicit (Small_deleted_explicit_explicit &&rhs);
+
+
+ int data[2];
+};
+
+Small_deleted_explicit_explicit::Small_deleted_explicit_explicit (void)
+{
+ data[0] = 2;
+ data[1] = 2;
+}
+
+Small_deleted_explicit_explicit::~Small_deleted_explicit_explicit (void)
+{
+ data[0] = 3;
+ data[1] = 3;
+ tracer = 5;
+}
+Small_deleted_explicit_explicit::Small_deleted_explicit_explicit (Small_deleted_explicit_explicit &&rhs)
+{
+ data[0] = 3;
+ data[1] = 3;
+ tracer = 5;
+}
+
+
+Small_deleted_explicit_explicit Small_deleted_explicit_explicit_var; /* global var */
+
+template int cbv<Small_deleted_explicit_explicit> (Small_deleted_explicit_explicit arg);
+/*** C++ class Large_deleted_explicit_explicit ***/
+class Large_deleted_explicit_explicit {
+public:
+ Large_deleted_explicit_explicit (void);
+ Large_deleted_explicit_explicit (const Large_deleted_explicit_explicit &rhs) = delete;
+ ~Large_deleted_explicit_explicit (void);
+ Large_deleted_explicit_explicit (Large_deleted_explicit_explicit &&rhs);
+
+
+ int data[150];
+};
+
+Large_deleted_explicit_explicit::Large_deleted_explicit_explicit (void)
+{
+ data[0] = 2;
+ data[149] = 2;
+}
+
+Large_deleted_explicit_explicit::~Large_deleted_explicit_explicit (void)
+{
+ data[0] = 3;
+ data[149] = 3;
+ tracer = 5;
+}
+Large_deleted_explicit_explicit::Large_deleted_explicit_explicit (Large_deleted_explicit_explicit &&rhs)
+{
+ data[0] = 3;
+ data[149] = 3;
+ tracer = 5;
+}
+
+
+Large_deleted_explicit_explicit Large_deleted_explicit_explicit_var; /* global var */
+
+template int cbv<Large_deleted_explicit_explicit> (Large_deleted_explicit_explicit arg);
+/*** Class derived from Small_deleted_explicit_explicit ***/
+class Derived_deleted_explicit_explicit : public Small_deleted_explicit_explicit {
+public:
+};
+
+Derived_deleted_explicit_explicit Derived_deleted_explicit_explicit_var; /* global var */
+
+template int cbv<Derived_deleted_explicit_explicit> (Derived_deleted_explicit_explicit arg);
+/*** Class that contains Small_deleted_explicit_explicit ***/
+class Container_deleted_explicit_explicit {
+public:
+ Small_deleted_explicit_explicit item;
+};
+
+Container_deleted_explicit_explicit Container_deleted_explicit_explicit_var; /* global var */
+
+template int cbv_container<Container_deleted_explicit_explicit> (Container_deleted_explicit_explicit arg);
+/*** C++ class Small_deleted_explicit_defaultedIn ***/
+class Small_deleted_explicit_defaultedIn {
+public:
+ Small_deleted_explicit_defaultedIn (void);
+ Small_deleted_explicit_defaultedIn (const Small_deleted_explicit_defaultedIn &rhs) = delete;
+ ~Small_deleted_explicit_defaultedIn (void);
+ Small_deleted_explicit_defaultedIn (Small_deleted_explicit_defaultedIn &&rhs) = default;
+
+
+ int data[2];
+};
+
+Small_deleted_explicit_defaultedIn::Small_deleted_explicit_defaultedIn (void)
+{
+ data[0] = 2;
+ data[1] = 2;
+}
+
+Small_deleted_explicit_defaultedIn::~Small_deleted_explicit_defaultedIn (void)
+{
+ data[0] = 3;
+ data[1] = 3;
+ tracer = 5;
+}
+
+
+Small_deleted_explicit_defaultedIn Small_deleted_explicit_defaultedIn_var; /* global var */
+
+template int cbv<Small_deleted_explicit_defaultedIn> (Small_deleted_explicit_defaultedIn arg);
+/*** C++ class Large_deleted_explicit_defaultedIn ***/
+class Large_deleted_explicit_defaultedIn {
+public:
+ Large_deleted_explicit_defaultedIn (void);
+ Large_deleted_explicit_defaultedIn (const Large_deleted_explicit_defaultedIn &rhs) = delete;
+ ~Large_deleted_explicit_defaultedIn (void);
+ Large_deleted_explicit_defaultedIn (Large_deleted_explicit_defaultedIn &&rhs) = default;
+
+
+ int data[150];
+};
+
+Large_deleted_explicit_defaultedIn::Large_deleted_explicit_defaultedIn (void)
+{
+ data[0] = 2;
+ data[149] = 2;
+}
+
+Large_deleted_explicit_defaultedIn::~Large_deleted_explicit_defaultedIn (void)
+{
+ data[0] = 3;
+ data[149] = 3;
+ tracer = 5;
+}
+
+
+Large_deleted_explicit_defaultedIn Large_deleted_explicit_defaultedIn_var; /* global var */
+
+template int cbv<Large_deleted_explicit_defaultedIn> (Large_deleted_explicit_defaultedIn arg);
+/*** Class derived from Small_deleted_explicit_defaultedIn ***/
+class Derived_deleted_explicit_defaultedIn : public Small_deleted_explicit_defaultedIn {
+public:
+};
+
+Derived_deleted_explicit_defaultedIn Derived_deleted_explicit_defaultedIn_var; /* global var */
+
+template int cbv<Derived_deleted_explicit_defaultedIn> (Derived_deleted_explicit_defaultedIn arg);
+/*** Class that contains Small_deleted_explicit_defaultedIn ***/
+class Container_deleted_explicit_defaultedIn {
+public:
+ Small_deleted_explicit_defaultedIn item;
+};
+
+Container_deleted_explicit_defaultedIn Container_deleted_explicit_defaultedIn_var; /* global var */
+
+template int cbv_container<Container_deleted_explicit_defaultedIn> (Container_deleted_explicit_defaultedIn arg);
+/*** C++ class Small_deleted_explicit_defaultedOut ***/
+class Small_deleted_explicit_defaultedOut {
+public:
+ Small_deleted_explicit_defaultedOut (void);
+ Small_deleted_explicit_defaultedOut (const Small_deleted_explicit_defaultedOut &rhs) = delete;
+ ~Small_deleted_explicit_defaultedOut (void);
+ Small_deleted_explicit_defaultedOut (Small_deleted_explicit_defaultedOut &&rhs);
+
+
+ int data[2];
+};
+
+Small_deleted_explicit_defaultedOut::Small_deleted_explicit_defaultedOut (void)
+{
+ data[0] = 2;
+ data[1] = 2;
+}
+
+Small_deleted_explicit_defaultedOut::~Small_deleted_explicit_defaultedOut (void)
+{
+ data[0] = 3;
+ data[1] = 3;
+ tracer = 5;
+}
+Small_deleted_explicit_defaultedOut::Small_deleted_explicit_defaultedOut (Small_deleted_explicit_defaultedOut &&rhs) = default;
+
+
+Small_deleted_explicit_defaultedOut Small_deleted_explicit_defaultedOut_var; /* global var */
+
+template int cbv<Small_deleted_explicit_defaultedOut> (Small_deleted_explicit_defaultedOut arg);
+/*** C++ class Large_deleted_explicit_defaultedOut ***/
+class Large_deleted_explicit_defaultedOut {
+public:
+ Large_deleted_explicit_defaultedOut (void);
+ Large_deleted_explicit_defaultedOut (const Large_deleted_explicit_defaultedOut &rhs) = delete;
+ ~Large_deleted_explicit_defaultedOut (void);
+ Large_deleted_explicit_defaultedOut (Large_deleted_explicit_defaultedOut &&rhs);
+
+
+ int data[150];
+};
+
+Large_deleted_explicit_defaultedOut::Large_deleted_explicit_defaultedOut (void)
+{
+ data[0] = 2;
+ data[149] = 2;
+}
+
+Large_deleted_explicit_defaultedOut::~Large_deleted_explicit_defaultedOut (void)
+{
+ data[0] = 3;
+ data[149] = 3;
+ tracer = 5;
+}
+Large_deleted_explicit_defaultedOut::Large_deleted_explicit_defaultedOut (Large_deleted_explicit_defaultedOut &&rhs) = default;
+
+
+Large_deleted_explicit_defaultedOut Large_deleted_explicit_defaultedOut_var; /* global var */
+
+template int cbv<Large_deleted_explicit_defaultedOut> (Large_deleted_explicit_defaultedOut arg);
+/*** Class derived from Small_deleted_explicit_defaultedOut ***/
+class Derived_deleted_explicit_defaultedOut : public Small_deleted_explicit_defaultedOut {
+public:
+};
+
+Derived_deleted_explicit_defaultedOut Derived_deleted_explicit_defaultedOut_var; /* global var */
+
+template int cbv<Derived_deleted_explicit_defaultedOut> (Derived_deleted_explicit_defaultedOut arg);
+/*** Class that contains Small_deleted_explicit_defaultedOut ***/
+class Container_deleted_explicit_defaultedOut {
+public:
+ Small_deleted_explicit_defaultedOut item;
+};
+
+Container_deleted_explicit_defaultedOut Container_deleted_explicit_defaultedOut_var; /* global var */
+
+template int cbv_container<Container_deleted_explicit_defaultedOut> (Container_deleted_explicit_defaultedOut arg);
+/*** C++ class Small_deleted_explicit_deleted ***/
+class Small_deleted_explicit_deleted {
+public:
+ Small_deleted_explicit_deleted (void);
+ Small_deleted_explicit_deleted (const Small_deleted_explicit_deleted &rhs) = delete;
+ ~Small_deleted_explicit_deleted (void);
+ Small_deleted_explicit_deleted (Small_deleted_explicit_deleted &&rhs) = delete;
+
+
+ int data[2];
+};
+
+Small_deleted_explicit_deleted::Small_deleted_explicit_deleted (void)
+{
+ data[0] = 2;
+ data[1] = 2;
+}
+
+Small_deleted_explicit_deleted::~Small_deleted_explicit_deleted (void)
+{
+ data[0] = 3;
+ data[1] = 3;
+ tracer = 5;
+}
+
+
+Small_deleted_explicit_deleted Small_deleted_explicit_deleted_var; /* global var */
+
+template int cbv<Small_deleted_explicit_deleted> (Small_deleted_explicit_deleted arg);
+/*** C++ class Large_deleted_explicit_deleted ***/
+class Large_deleted_explicit_deleted {
+public:
+ Large_deleted_explicit_deleted (void);
+ Large_deleted_explicit_deleted (const Large_deleted_explicit_deleted &rhs) = delete;
+ ~Large_deleted_explicit_deleted (void);
+ Large_deleted_explicit_deleted (Large_deleted_explicit_deleted &&rhs) = delete;
+
+
+ int data[150];
+};
+
+Large_deleted_explicit_deleted::Large_deleted_explicit_deleted (void)
+{
+ data[0] = 2;
+ data[149] = 2;
+}
+
+Large_deleted_explicit_deleted::~Large_deleted_explicit_deleted (void)
+{
+ data[0] = 3;
+ data[149] = 3;
+ tracer = 5;
+}
+
+
+Large_deleted_explicit_deleted Large_deleted_explicit_deleted_var; /* global var */
+
+template int cbv<Large_deleted_explicit_deleted> (Large_deleted_explicit_deleted arg);
+/*** Class derived from Small_deleted_explicit_deleted ***/
+class Derived_deleted_explicit_deleted : public Small_deleted_explicit_deleted {
+public:
+};
+
+Derived_deleted_explicit_deleted Derived_deleted_explicit_deleted_var; /* global var */
+
+template int cbv<Derived_deleted_explicit_deleted> (Derived_deleted_explicit_deleted arg);
+/*** Class that contains Small_deleted_explicit_deleted ***/
+class Container_deleted_explicit_deleted {
+public:
+ Small_deleted_explicit_deleted item;
+};
+
+Container_deleted_explicit_deleted Container_deleted_explicit_deleted_var; /* global var */
+
+template int cbv_container<Container_deleted_explicit_deleted> (Container_deleted_explicit_deleted arg);
+/*** C++ class Small_deleted_defaultedIn_absent ***/
+class Small_deleted_defaultedIn_absent {
+public:
+ Small_deleted_defaultedIn_absent (void);
+ Small_deleted_defaultedIn_absent (const Small_deleted_defaultedIn_absent &rhs) = delete;
+ ~Small_deleted_defaultedIn_absent (void) = default;
+
+
+ int data[2];
+};
+
+Small_deleted_defaultedIn_absent::Small_deleted_defaultedIn_absent (void)
+{
+ data[0] = 2;
+ data[1] = 2;
+}
+
+
+
+Small_deleted_defaultedIn_absent Small_deleted_defaultedIn_absent_var; /* global var */
+
+template int cbv<Small_deleted_defaultedIn_absent> (Small_deleted_defaultedIn_absent arg);
+/*** C++ class Large_deleted_defaultedIn_absent ***/
+class Large_deleted_defaultedIn_absent {
+public:
+ Large_deleted_defaultedIn_absent (void);
+ Large_deleted_defaultedIn_absent (const Large_deleted_defaultedIn_absent &rhs) = delete;
+ ~Large_deleted_defaultedIn_absent (void) = default;
+
+
+ int data[150];
+};
+
+Large_deleted_defaultedIn_absent::Large_deleted_defaultedIn_absent (void)
+{
+ data[0] = 2;
+ data[149] = 2;
+}
+
+
+
+Large_deleted_defaultedIn_absent Large_deleted_defaultedIn_absent_var; /* global var */
+
+template int cbv<Large_deleted_defaultedIn_absent> (Large_deleted_defaultedIn_absent arg);
+/*** Class derived from Small_deleted_defaultedIn_absent ***/
+class Derived_deleted_defaultedIn_absent : public Small_deleted_defaultedIn_absent {
+public:
+};
+
+Derived_deleted_defaultedIn_absent Derived_deleted_defaultedIn_absent_var; /* global var */
+
+template int cbv<Derived_deleted_defaultedIn_absent> (Derived_deleted_defaultedIn_absent arg);
+/*** Class that contains Small_deleted_defaultedIn_absent ***/
+class Container_deleted_defaultedIn_absent {
+public:
+ Small_deleted_defaultedIn_absent item;
+};
+
+Container_deleted_defaultedIn_absent Container_deleted_defaultedIn_absent_var; /* global var */
+
+template int cbv_container<Container_deleted_defaultedIn_absent> (Container_deleted_defaultedIn_absent arg);
+/*** C++ class Small_deleted_defaultedIn_explicit ***/
+class Small_deleted_defaultedIn_explicit {
+public:
+ Small_deleted_defaultedIn_explicit (void);
+ Small_deleted_defaultedIn_explicit (const Small_deleted_defaultedIn_explicit &rhs) = delete;
+ ~Small_deleted_defaultedIn_explicit (void) = default;
+ Small_deleted_defaultedIn_explicit (Small_deleted_defaultedIn_explicit &&rhs);
+
+
+ int data[2];
+};
+
+Small_deleted_defaultedIn_explicit::Small_deleted_defaultedIn_explicit (void)
+{
+ data[0] = 2;
+ data[1] = 2;
+}
+
+Small_deleted_defaultedIn_explicit::Small_deleted_defaultedIn_explicit (Small_deleted_defaultedIn_explicit &&rhs)
+{
+ data[0] = 3;
+ data[1] = 3;
+ tracer = 5;
+}
+
+
+Small_deleted_defaultedIn_explicit Small_deleted_defaultedIn_explicit_var; /* global var */
+
+template int cbv<Small_deleted_defaultedIn_explicit> (Small_deleted_defaultedIn_explicit arg);
+/*** C++ class Large_deleted_defaultedIn_explicit ***/
+class Large_deleted_defaultedIn_explicit {
+public:
+ Large_deleted_defaultedIn_explicit (void);
+ Large_deleted_defaultedIn_explicit (const Large_deleted_defaultedIn_explicit &rhs) = delete;
+ ~Large_deleted_defaultedIn_explicit (void) = default;
+ Large_deleted_defaultedIn_explicit (Large_deleted_defaultedIn_explicit &&rhs);
+
+
+ int data[150];
+};
+
+Large_deleted_defaultedIn_explicit::Large_deleted_defaultedIn_explicit (void)
+{
+ data[0] = 2;
+ data[149] = 2;
+}
+
+Large_deleted_defaultedIn_explicit::Large_deleted_defaultedIn_explicit (Large_deleted_defaultedIn_explicit &&rhs)
+{
+ data[0] = 3;
+ data[149] = 3;
+ tracer = 5;
+}
+
+
+Large_deleted_defaultedIn_explicit Large_deleted_defaultedIn_explicit_var; /* global var */
+
+template int cbv<Large_deleted_defaultedIn_explicit> (Large_deleted_defaultedIn_explicit arg);
+/*** Class derived from Small_deleted_defaultedIn_explicit ***/
+class Derived_deleted_defaultedIn_explicit : public Small_deleted_defaultedIn_explicit {
+public:
+};
+
+Derived_deleted_defaultedIn_explicit Derived_deleted_defaultedIn_explicit_var; /* global var */
+
+template int cbv<Derived_deleted_defaultedIn_explicit> (Derived_deleted_defaultedIn_explicit arg);
+/*** Class that contains Small_deleted_defaultedIn_explicit ***/
+class Container_deleted_defaultedIn_explicit {
+public:
+ Small_deleted_defaultedIn_explicit item;
+};
+
+Container_deleted_defaultedIn_explicit Container_deleted_defaultedIn_explicit_var; /* global var */
+
+template int cbv_container<Container_deleted_defaultedIn_explicit> (Container_deleted_defaultedIn_explicit arg);
+/*** C++ class Small_deleted_defaultedIn_defaultedIn ***/
+class Small_deleted_defaultedIn_defaultedIn {
+public:
+ Small_deleted_defaultedIn_defaultedIn (void);
+ Small_deleted_defaultedIn_defaultedIn (const Small_deleted_defaultedIn_defaultedIn &rhs) = delete;
+ ~Small_deleted_defaultedIn_defaultedIn (void) = default;
+ Small_deleted_defaultedIn_defaultedIn (Small_deleted_defaultedIn_defaultedIn &&rhs) = default;
+
+
+ int data[2];
+};
+
+Small_deleted_defaultedIn_defaultedIn::Small_deleted_defaultedIn_defaultedIn (void)
+{
+ data[0] = 2;
+ data[1] = 2;
+}
+
+
+
+Small_deleted_defaultedIn_defaultedIn Small_deleted_defaultedIn_defaultedIn_var; /* global var */
+
+template int cbv<Small_deleted_defaultedIn_defaultedIn> (Small_deleted_defaultedIn_defaultedIn arg);
+/*** C++ class Large_deleted_defaultedIn_defaultedIn ***/
+class Large_deleted_defaultedIn_defaultedIn {
+public:
+ Large_deleted_defaultedIn_defaultedIn (void);
+ Large_deleted_defaultedIn_defaultedIn (const Large_deleted_defaultedIn_defaultedIn &rhs) = delete;
+ ~Large_deleted_defaultedIn_defaultedIn (void) = default;
+ Large_deleted_defaultedIn_defaultedIn (Large_deleted_defaultedIn_defaultedIn &&rhs) = default;
+
+
+ int data[150];
+};
+
+Large_deleted_defaultedIn_defaultedIn::Large_deleted_defaultedIn_defaultedIn (void)
+{
+ data[0] = 2;
+ data[149] = 2;
+}
+
+
+
+Large_deleted_defaultedIn_defaultedIn Large_deleted_defaultedIn_defaultedIn_var; /* global var */
+
+template int cbv<Large_deleted_defaultedIn_defaultedIn> (Large_deleted_defaultedIn_defaultedIn arg);
+/*** Class derived from Small_deleted_defaultedIn_defaultedIn ***/
+class Derived_deleted_defaultedIn_defaultedIn : public Small_deleted_defaultedIn_defaultedIn {
+public:
+};
+
+Derived_deleted_defaultedIn_defaultedIn Derived_deleted_defaultedIn_defaultedIn_var; /* global var */
+
+template int cbv<Derived_deleted_defaultedIn_defaultedIn> (Derived_deleted_defaultedIn_defaultedIn arg);
+/*** Class that contains Small_deleted_defaultedIn_defaultedIn ***/
+class Container_deleted_defaultedIn_defaultedIn {
+public:
+ Small_deleted_defaultedIn_defaultedIn item;
+};
+
+Container_deleted_defaultedIn_defaultedIn Container_deleted_defaultedIn_defaultedIn_var; /* global var */
+
+template int cbv_container<Container_deleted_defaultedIn_defaultedIn> (Container_deleted_defaultedIn_defaultedIn arg);
+/*** C++ class Small_deleted_defaultedIn_defaultedOut ***/
+class Small_deleted_defaultedIn_defaultedOut {
+public:
+ Small_deleted_defaultedIn_defaultedOut (void);
+ Small_deleted_defaultedIn_defaultedOut (const Small_deleted_defaultedIn_defaultedOut &rhs) = delete;
+ ~Small_deleted_defaultedIn_defaultedOut (void) = default;
+ Small_deleted_defaultedIn_defaultedOut (Small_deleted_defaultedIn_defaultedOut &&rhs);
+
+
+ int data[2];
+};
+
+Small_deleted_defaultedIn_defaultedOut::Small_deleted_defaultedIn_defaultedOut (void)
+{
+ data[0] = 2;
+ data[1] = 2;
+}
+
+Small_deleted_defaultedIn_defaultedOut::Small_deleted_defaultedIn_defaultedOut (Small_deleted_defaultedIn_defaultedOut &&rhs) = default;
+
+
+Small_deleted_defaultedIn_defaultedOut Small_deleted_defaultedIn_defaultedOut_var; /* global var */
+
+template int cbv<Small_deleted_defaultedIn_defaultedOut> (Small_deleted_defaultedIn_defaultedOut arg);
+/*** C++ class Large_deleted_defaultedIn_defaultedOut ***/
+class Large_deleted_defaultedIn_defaultedOut {
+public:
+ Large_deleted_defaultedIn_defaultedOut (void);
+ Large_deleted_defaultedIn_defaultedOut (const Large_deleted_defaultedIn_defaultedOut &rhs) = delete;
+ ~Large_deleted_defaultedIn_defaultedOut (void) = default;
+ Large_deleted_defaultedIn_defaultedOut (Large_deleted_defaultedIn_defaultedOut &&rhs);
+
+
+ int data[150];
+};
+
+Large_deleted_defaultedIn_defaultedOut::Large_deleted_defaultedIn_defaultedOut (void)
+{
+ data[0] = 2;
+ data[149] = 2;
+}
+
+Large_deleted_defaultedIn_defaultedOut::Large_deleted_defaultedIn_defaultedOut (Large_deleted_defaultedIn_defaultedOut &&rhs) = default;
+
+
+Large_deleted_defaultedIn_defaultedOut Large_deleted_defaultedIn_defaultedOut_var; /* global var */
+
+template int cbv<Large_deleted_defaultedIn_defaultedOut> (Large_deleted_defaultedIn_defaultedOut arg);
+/*** Class derived from Small_deleted_defaultedIn_defaultedOut ***/
+class Derived_deleted_defaultedIn_defaultedOut : public Small_deleted_defaultedIn_defaultedOut {
+public:
+};
+
+Derived_deleted_defaultedIn_defaultedOut Derived_deleted_defaultedIn_defaultedOut_var; /* global var */
+
+template int cbv<Derived_deleted_defaultedIn_defaultedOut> (Derived_deleted_defaultedIn_defaultedOut arg);
+/*** Class that contains Small_deleted_defaultedIn_defaultedOut ***/
+class Container_deleted_defaultedIn_defaultedOut {
+public:
+ Small_deleted_defaultedIn_defaultedOut item;
+};
+
+Container_deleted_defaultedIn_defaultedOut Container_deleted_defaultedIn_defaultedOut_var; /* global var */
+
+template int cbv_container<Container_deleted_defaultedIn_defaultedOut> (Container_deleted_defaultedIn_defaultedOut arg);
+/*** C++ class Small_deleted_defaultedIn_deleted ***/
+class Small_deleted_defaultedIn_deleted {
+public:
+ Small_deleted_defaultedIn_deleted (void);
+ Small_deleted_defaultedIn_deleted (const Small_deleted_defaultedIn_deleted &rhs) = delete;
+ ~Small_deleted_defaultedIn_deleted (void) = default;
+ Small_deleted_defaultedIn_deleted (Small_deleted_defaultedIn_deleted &&rhs) = delete;
+
+
+ int data[2];
+};
+
+Small_deleted_defaultedIn_deleted::Small_deleted_defaultedIn_deleted (void)
+{
+ data[0] = 2;
+ data[1] = 2;
+}
+
+
+
+Small_deleted_defaultedIn_deleted Small_deleted_defaultedIn_deleted_var; /* global var */
+
+template int cbv<Small_deleted_defaultedIn_deleted> (Small_deleted_defaultedIn_deleted arg);
+/*** C++ class Large_deleted_defaultedIn_deleted ***/
+class Large_deleted_defaultedIn_deleted {
+public:
+ Large_deleted_defaultedIn_deleted (void);
+ Large_deleted_defaultedIn_deleted (const Large_deleted_defaultedIn_deleted &rhs) = delete;
+ ~Large_deleted_defaultedIn_deleted (void) = default;
+ Large_deleted_defaultedIn_deleted (Large_deleted_defaultedIn_deleted &&rhs) = delete;
+
+
+ int data[150];
+};
+
+Large_deleted_defaultedIn_deleted::Large_deleted_defaultedIn_deleted (void)
+{
+ data[0] = 2;
+ data[149] = 2;
+}
+
+
+
+Large_deleted_defaultedIn_deleted Large_deleted_defaultedIn_deleted_var; /* global var */
+
+template int cbv<Large_deleted_defaultedIn_deleted> (Large_deleted_defaultedIn_deleted arg);
+/*** Class derived from Small_deleted_defaultedIn_deleted ***/
+class Derived_deleted_defaultedIn_deleted : public Small_deleted_defaultedIn_deleted {
+public:
+};
+
+Derived_deleted_defaultedIn_deleted Derived_deleted_defaultedIn_deleted_var; /* global var */
+
+template int cbv<Derived_deleted_defaultedIn_deleted> (Derived_deleted_defaultedIn_deleted arg);
+/*** Class that contains Small_deleted_defaultedIn_deleted ***/
+class Container_deleted_defaultedIn_deleted {
+public:
+ Small_deleted_defaultedIn_deleted item;
+};
+
+Container_deleted_defaultedIn_deleted Container_deleted_defaultedIn_deleted_var; /* global var */
+
+template int cbv_container<Container_deleted_defaultedIn_deleted> (Container_deleted_defaultedIn_deleted arg);
+/*** C++ class Small_deleted_defaultedOut_absent ***/
+class Small_deleted_defaultedOut_absent {
+public:
+ Small_deleted_defaultedOut_absent (void);
+ Small_deleted_defaultedOut_absent (const Small_deleted_defaultedOut_absent &rhs) = delete;
+ ~Small_deleted_defaultedOut_absent (void);
+
+
+ int data[2];
+};
+
+Small_deleted_defaultedOut_absent::Small_deleted_defaultedOut_absent (void)
+{
+ data[0] = 2;
+ data[1] = 2;
+}
+
+Small_deleted_defaultedOut_absent::~Small_deleted_defaultedOut_absent (void) = default;
+
+
+Small_deleted_defaultedOut_absent Small_deleted_defaultedOut_absent_var; /* global var */
+
+template int cbv<Small_deleted_defaultedOut_absent> (Small_deleted_defaultedOut_absent arg);
+/*** C++ class Large_deleted_defaultedOut_absent ***/
+class Large_deleted_defaultedOut_absent {
+public:
+ Large_deleted_defaultedOut_absent (void);
+ Large_deleted_defaultedOut_absent (const Large_deleted_defaultedOut_absent &rhs) = delete;
+ ~Large_deleted_defaultedOut_absent (void);
+
+
+ int data[150];
+};
+
+Large_deleted_defaultedOut_absent::Large_deleted_defaultedOut_absent (void)
+{
+ data[0] = 2;
+ data[149] = 2;
+}
+
+Large_deleted_defaultedOut_absent::~Large_deleted_defaultedOut_absent (void) = default;
+
+
+Large_deleted_defaultedOut_absent Large_deleted_defaultedOut_absent_var; /* global var */
+
+template int cbv<Large_deleted_defaultedOut_absent> (Large_deleted_defaultedOut_absent arg);
+/*** Class derived from Small_deleted_defaultedOut_absent ***/
+class Derived_deleted_defaultedOut_absent : public Small_deleted_defaultedOut_absent {
+public:
+};
+
+Derived_deleted_defaultedOut_absent Derived_deleted_defaultedOut_absent_var; /* global var */
+
+template int cbv<Derived_deleted_defaultedOut_absent> (Derived_deleted_defaultedOut_absent arg);
+/*** Class that contains Small_deleted_defaultedOut_absent ***/
+class Container_deleted_defaultedOut_absent {
+public:
+ Small_deleted_defaultedOut_absent item;
+};
+
+Container_deleted_defaultedOut_absent Container_deleted_defaultedOut_absent_var; /* global var */
+
+template int cbv_container<Container_deleted_defaultedOut_absent> (Container_deleted_defaultedOut_absent arg);
+/*** C++ class Small_deleted_defaultedOut_explicit ***/
+class Small_deleted_defaultedOut_explicit {
public:
- Obj ();
- Obj (const Obj &);
- ~Obj ();
- int var[2];
+ Small_deleted_defaultedOut_explicit (void);
+ Small_deleted_defaultedOut_explicit (const Small_deleted_defaultedOut_explicit &rhs) = delete;
+ ~Small_deleted_defaultedOut_explicit (void);
+ Small_deleted_defaultedOut_explicit (Small_deleted_defaultedOut_explicit &&rhs);
+
+
+ int data[2];
};
-int foo (Obj arg)
+Small_deleted_defaultedOut_explicit::Small_deleted_defaultedOut_explicit (void)
+{
+ data[0] = 2;
+ data[1] = 2;
+}
+
+Small_deleted_defaultedOut_explicit::~Small_deleted_defaultedOut_explicit (void) = default;
+Small_deleted_defaultedOut_explicit::Small_deleted_defaultedOut_explicit (Small_deleted_defaultedOut_explicit &&rhs)
{
- return arg.var[0] + arg.var[1];
+ data[0] = 3;
+ data[1] = 3;
+ tracer = 5;
}
-Obj::Obj ()
+
+Small_deleted_defaultedOut_explicit Small_deleted_defaultedOut_explicit_var; /* global var */
+
+template int cbv<Small_deleted_defaultedOut_explicit> (Small_deleted_defaultedOut_explicit arg);
+/*** C++ class Large_deleted_defaultedOut_explicit ***/
+class Large_deleted_defaultedOut_explicit {
+public:
+ Large_deleted_defaultedOut_explicit (void);
+ Large_deleted_defaultedOut_explicit (const Large_deleted_defaultedOut_explicit &rhs) = delete;
+ ~Large_deleted_defaultedOut_explicit (void);
+ Large_deleted_defaultedOut_explicit (Large_deleted_defaultedOut_explicit &&rhs);
+
+
+ int data[150];
+};
+
+Large_deleted_defaultedOut_explicit::Large_deleted_defaultedOut_explicit (void)
{
- var[0] = 1;
- var[1] = 2;
+ data[0] = 2;
+ data[149] = 2;
}
-Obj::Obj (const Obj &obj)
+Large_deleted_defaultedOut_explicit::~Large_deleted_defaultedOut_explicit (void) = default;
+Large_deleted_defaultedOut_explicit::Large_deleted_defaultedOut_explicit (Large_deleted_defaultedOut_explicit &&rhs)
{
- var[0] = obj.var[0];
- var[1] = obj.var[1];
+ data[0] = 3;
+ data[149] = 3;
+ tracer = 5;
}
-Obj::~Obj ()
+
+Large_deleted_defaultedOut_explicit Large_deleted_defaultedOut_explicit_var; /* global var */
+
+template int cbv<Large_deleted_defaultedOut_explicit> (Large_deleted_defaultedOut_explicit arg);
+/*** Class derived from Small_deleted_defaultedOut_explicit ***/
+class Derived_deleted_defaultedOut_explicit : public Small_deleted_defaultedOut_explicit {
+public:
+};
+
+Derived_deleted_defaultedOut_explicit Derived_deleted_defaultedOut_explicit_var; /* global var */
+
+template int cbv<Derived_deleted_defaultedOut_explicit> (Derived_deleted_defaultedOut_explicit arg);
+/*** Class that contains Small_deleted_defaultedOut_explicit ***/
+class Container_deleted_defaultedOut_explicit {
+public:
+ Small_deleted_defaultedOut_explicit item;
+};
+
+Container_deleted_defaultedOut_explicit Container_deleted_defaultedOut_explicit_var; /* global var */
+
+template int cbv_container<Container_deleted_defaultedOut_explicit> (Container_deleted_defaultedOut_explicit arg);
+/*** C++ class Small_deleted_defaultedOut_defaultedIn ***/
+class Small_deleted_defaultedOut_defaultedIn {
+public:
+ Small_deleted_defaultedOut_defaultedIn (void);
+ Small_deleted_defaultedOut_defaultedIn (const Small_deleted_defaultedOut_defaultedIn &rhs) = delete;
+ ~Small_deleted_defaultedOut_defaultedIn (void);
+ Small_deleted_defaultedOut_defaultedIn (Small_deleted_defaultedOut_defaultedIn &&rhs) = default;
+
+
+ int data[2];
+};
+
+Small_deleted_defaultedOut_defaultedIn::Small_deleted_defaultedOut_defaultedIn (void)
{
+ data[0] = 2;
+ data[1] = 2;
+}
+
+Small_deleted_defaultedOut_defaultedIn::~Small_deleted_defaultedOut_defaultedIn (void) = default;
+
+
+Small_deleted_defaultedOut_defaultedIn Small_deleted_defaultedOut_defaultedIn_var; /* global var */
+
+template int cbv<Small_deleted_defaultedOut_defaultedIn> (Small_deleted_defaultedOut_defaultedIn arg);
+/*** C++ class Large_deleted_defaultedOut_defaultedIn ***/
+class Large_deleted_defaultedOut_defaultedIn {
+public:
+ Large_deleted_defaultedOut_defaultedIn (void);
+ Large_deleted_defaultedOut_defaultedIn (const Large_deleted_defaultedOut_defaultedIn &rhs) = delete;
+ ~Large_deleted_defaultedOut_defaultedIn (void);
+ Large_deleted_defaultedOut_defaultedIn (Large_deleted_defaultedOut_defaultedIn &&rhs) = default;
+
+
+ int data[150];
+};
+Large_deleted_defaultedOut_defaultedIn::Large_deleted_defaultedOut_defaultedIn (void)
+{
+ data[0] = 2;
+ data[149] = 2;
}
-struct Derived : public Obj
+Large_deleted_defaultedOut_defaultedIn::~Large_deleted_defaultedOut_defaultedIn (void) = default;
+
+
+Large_deleted_defaultedOut_defaultedIn Large_deleted_defaultedOut_defaultedIn_var; /* global var */
+
+template int cbv<Large_deleted_defaultedOut_defaultedIn> (Large_deleted_defaultedOut_defaultedIn arg);
+/*** Class derived from Small_deleted_defaultedOut_defaultedIn ***/
+class Derived_deleted_defaultedOut_defaultedIn : public Small_deleted_defaultedOut_defaultedIn {
+public:
+};
+
+Derived_deleted_defaultedOut_defaultedIn Derived_deleted_defaultedOut_defaultedIn_var; /* global var */
+
+template int cbv<Derived_deleted_defaultedOut_defaultedIn> (Derived_deleted_defaultedOut_defaultedIn arg);
+/*** Class that contains Small_deleted_defaultedOut_defaultedIn ***/
+class Container_deleted_defaultedOut_defaultedIn {
+public:
+ Small_deleted_defaultedOut_defaultedIn item;
+};
+
+Container_deleted_defaultedOut_defaultedIn Container_deleted_defaultedOut_defaultedIn_var; /* global var */
+
+template int cbv_container<Container_deleted_defaultedOut_defaultedIn> (Container_deleted_defaultedOut_defaultedIn arg);
+/*** C++ class Small_deleted_defaultedOut_defaultedOut ***/
+class Small_deleted_defaultedOut_defaultedOut {
+public:
+ Small_deleted_defaultedOut_defaultedOut (void);
+ Small_deleted_defaultedOut_defaultedOut (const Small_deleted_defaultedOut_defaultedOut &rhs) = delete;
+ ~Small_deleted_defaultedOut_defaultedOut (void);
+ Small_deleted_defaultedOut_defaultedOut (Small_deleted_defaultedOut_defaultedOut &&rhs);
+
+
+ int data[2];
+};
+
+Small_deleted_defaultedOut_defaultedOut::Small_deleted_defaultedOut_defaultedOut (void)
{
- int other;
+ data[0] = 2;
+ data[1] = 2;
+}
+
+Small_deleted_defaultedOut_defaultedOut::~Small_deleted_defaultedOut_defaultedOut (void) = default;
+Small_deleted_defaultedOut_defaultedOut::Small_deleted_defaultedOut_defaultedOut (Small_deleted_defaultedOut_defaultedOut &&rhs) = default;
+
+
+Small_deleted_defaultedOut_defaultedOut Small_deleted_defaultedOut_defaultedOut_var; /* global var */
+
+template int cbv<Small_deleted_defaultedOut_defaultedOut> (Small_deleted_defaultedOut_defaultedOut arg);
+/*** C++ class Large_deleted_defaultedOut_defaultedOut ***/
+class Large_deleted_defaultedOut_defaultedOut {
+public:
+ Large_deleted_defaultedOut_defaultedOut (void);
+ Large_deleted_defaultedOut_defaultedOut (const Large_deleted_defaultedOut_defaultedOut &rhs) = delete;
+ ~Large_deleted_defaultedOut_defaultedOut (void);
+ Large_deleted_defaultedOut_defaultedOut (Large_deleted_defaultedOut_defaultedOut &&rhs);
+
+
+ int data[150];
};
-int blap (Derived arg)
+Large_deleted_defaultedOut_defaultedOut::Large_deleted_defaultedOut_defaultedOut (void)
{
- return foo (arg);
+ data[0] = 2;
+ data[149] = 2;
}
-struct Container
+Large_deleted_defaultedOut_defaultedOut::~Large_deleted_defaultedOut_defaultedOut (void) = default;
+Large_deleted_defaultedOut_defaultedOut::Large_deleted_defaultedOut_defaultedOut (Large_deleted_defaultedOut_defaultedOut &&rhs) = default;
+
+
+Large_deleted_defaultedOut_defaultedOut Large_deleted_defaultedOut_defaultedOut_var; /* global var */
+
+template int cbv<Large_deleted_defaultedOut_defaultedOut> (Large_deleted_defaultedOut_defaultedOut arg);
+/*** Class derived from Small_deleted_defaultedOut_defaultedOut ***/
+class Derived_deleted_defaultedOut_defaultedOut : public Small_deleted_defaultedOut_defaultedOut {
+public:
+};
+
+Derived_deleted_defaultedOut_defaultedOut Derived_deleted_defaultedOut_defaultedOut_var; /* global var */
+
+template int cbv<Derived_deleted_defaultedOut_defaultedOut> (Derived_deleted_defaultedOut_defaultedOut arg);
+/*** Class that contains Small_deleted_defaultedOut_defaultedOut ***/
+class Container_deleted_defaultedOut_defaultedOut {
+public:
+ Small_deleted_defaultedOut_defaultedOut item;
+};
+
+Container_deleted_defaultedOut_defaultedOut Container_deleted_defaultedOut_defaultedOut_var; /* global var */
+
+template int cbv_container<Container_deleted_defaultedOut_defaultedOut> (Container_deleted_defaultedOut_defaultedOut arg);
+/*** C++ class Small_deleted_defaultedOut_deleted ***/
+class Small_deleted_defaultedOut_deleted {
+public:
+ Small_deleted_defaultedOut_deleted (void);
+ Small_deleted_defaultedOut_deleted (const Small_deleted_defaultedOut_deleted &rhs) = delete;
+ ~Small_deleted_defaultedOut_deleted (void);
+ Small_deleted_defaultedOut_deleted (Small_deleted_defaultedOut_deleted &&rhs) = delete;
+
+
+ int data[2];
+};
+
+Small_deleted_defaultedOut_deleted::Small_deleted_defaultedOut_deleted (void)
{
- Obj obj;
+ data[0] = 2;
+ data[1] = 2;
+}
+
+Small_deleted_defaultedOut_deleted::~Small_deleted_defaultedOut_deleted (void) = default;
+
+
+Small_deleted_defaultedOut_deleted Small_deleted_defaultedOut_deleted_var; /* global var */
+
+template int cbv<Small_deleted_defaultedOut_deleted> (Small_deleted_defaultedOut_deleted arg);
+/*** C++ class Large_deleted_defaultedOut_deleted ***/
+class Large_deleted_defaultedOut_deleted {
+public:
+ Large_deleted_defaultedOut_deleted (void);
+ Large_deleted_defaultedOut_deleted (const Large_deleted_defaultedOut_deleted &rhs) = delete;
+ ~Large_deleted_defaultedOut_deleted (void);
+ Large_deleted_defaultedOut_deleted (Large_deleted_defaultedOut_deleted &&rhs) = delete;
+
+
+ int data[150];
};
-int blip (Container arg)
+Large_deleted_defaultedOut_deleted::Large_deleted_defaultedOut_deleted (void)
{
- return foo (arg.obj);
+ data[0] = 2;
+ data[149] = 2;
}
-Obj global_obj;
-Derived global_derived;
-Container global_container;
+Large_deleted_defaultedOut_deleted::~Large_deleted_defaultedOut_deleted (void) = default;
+
+
+Large_deleted_defaultedOut_deleted Large_deleted_defaultedOut_deleted_var; /* global var */
+
+template int cbv<Large_deleted_defaultedOut_deleted> (Large_deleted_defaultedOut_deleted arg);
+/*** Class derived from Small_deleted_defaultedOut_deleted ***/
+class Derived_deleted_defaultedOut_deleted : public Small_deleted_defaultedOut_deleted {
+public:
+};
+
+Derived_deleted_defaultedOut_deleted Derived_deleted_defaultedOut_deleted_var; /* global var */
+
+template int cbv<Derived_deleted_defaultedOut_deleted> (Derived_deleted_defaultedOut_deleted arg);
+/*** Class that contains Small_deleted_defaultedOut_deleted ***/
+class Container_deleted_defaultedOut_deleted {
+public:
+ Small_deleted_defaultedOut_deleted item;
+};
+
+Container_deleted_defaultedOut_deleted Container_deleted_defaultedOut_deleted_var; /* global var */
+
+template int cbv_container<Container_deleted_defaultedOut_deleted> (Container_deleted_defaultedOut_deleted arg);
int
-main ()
+main (void)
{
- int bar = foo (global_obj);
- blap (global_derived);
- blip (global_container);
- return bar;
+ cbv<Small_absent_absent_absent> (Small_absent_absent_absent_var);
+ cbv<Large_absent_absent_absent> (Large_absent_absent_absent_var);
+ cbv<Derived_absent_absent_absent> (Derived_absent_absent_absent_var);
+ cbv_container<Container_absent_absent_absent> (Container_absent_absent_absent_var);
+ cbv<Small_absent_explicit_absent> (Small_absent_explicit_absent_var);
+ cbv<Large_absent_explicit_absent> (Large_absent_explicit_absent_var);
+ cbv<Derived_absent_explicit_absent> (Derived_absent_explicit_absent_var);
+ cbv_container<Container_absent_explicit_absent> (Container_absent_explicit_absent_var);
+ cbv<Small_absent_defaultedIn_absent> (Small_absent_defaultedIn_absent_var);
+ cbv<Large_absent_defaultedIn_absent> (Large_absent_defaultedIn_absent_var);
+ cbv<Derived_absent_defaultedIn_absent> (Derived_absent_defaultedIn_absent_var);
+ cbv_container<Container_absent_defaultedIn_absent> (Container_absent_defaultedIn_absent_var);
+ cbv<Small_absent_defaultedOut_absent> (Small_absent_defaultedOut_absent_var);
+ cbv<Large_absent_defaultedOut_absent> (Large_absent_defaultedOut_absent_var);
+ cbv<Derived_absent_defaultedOut_absent> (Derived_absent_defaultedOut_absent_var);
+ cbv_container<Container_absent_defaultedOut_absent> (Container_absent_defaultedOut_absent_var);
+ cbv<Small_explicit_absent_absent> (Small_explicit_absent_absent_var);
+ cbv<Large_explicit_absent_absent> (Large_explicit_absent_absent_var);
+ cbv<Derived_explicit_absent_absent> (Derived_explicit_absent_absent_var);
+ cbv_container<Container_explicit_absent_absent> (Container_explicit_absent_absent_var);
+ cbv<Small_explicit_absent_explicit> (Small_explicit_absent_explicit_var);
+ cbv<Large_explicit_absent_explicit> (Large_explicit_absent_explicit_var);
+ cbv<Derived_explicit_absent_explicit> (Derived_explicit_absent_explicit_var);
+ cbv_container<Container_explicit_absent_explicit> (Container_explicit_absent_explicit_var);
+ cbv<Small_explicit_absent_defaultedIn> (Small_explicit_absent_defaultedIn_var);
+ cbv<Large_explicit_absent_defaultedIn> (Large_explicit_absent_defaultedIn_var);
+ cbv<Derived_explicit_absent_defaultedIn> (Derived_explicit_absent_defaultedIn_var);
+ cbv_container<Container_explicit_absent_defaultedIn> (Container_explicit_absent_defaultedIn_var);
+ cbv<Small_explicit_absent_defaultedOut> (Small_explicit_absent_defaultedOut_var);
+ cbv<Large_explicit_absent_defaultedOut> (Large_explicit_absent_defaultedOut_var);
+ cbv<Derived_explicit_absent_defaultedOut> (Derived_explicit_absent_defaultedOut_var);
+ cbv_container<Container_explicit_absent_defaultedOut> (Container_explicit_absent_defaultedOut_var);
+ cbv<Small_explicit_absent_deleted> (Small_explicit_absent_deleted_var);
+ cbv<Large_explicit_absent_deleted> (Large_explicit_absent_deleted_var);
+ cbv<Derived_explicit_absent_deleted> (Derived_explicit_absent_deleted_var);
+ cbv_container<Container_explicit_absent_deleted> (Container_explicit_absent_deleted_var);
+ cbv<Small_explicit_explicit_absent> (Small_explicit_explicit_absent_var);
+ cbv<Large_explicit_explicit_absent> (Large_explicit_explicit_absent_var);
+ cbv<Derived_explicit_explicit_absent> (Derived_explicit_explicit_absent_var);
+ cbv_container<Container_explicit_explicit_absent> (Container_explicit_explicit_absent_var);
+ cbv<Small_explicit_explicit_explicit> (Small_explicit_explicit_explicit_var);
+ cbv<Large_explicit_explicit_explicit> (Large_explicit_explicit_explicit_var);
+ cbv<Derived_explicit_explicit_explicit> (Derived_explicit_explicit_explicit_var);
+ cbv_container<Container_explicit_explicit_explicit> (Container_explicit_explicit_explicit_var);
+ cbv<Small_explicit_explicit_defaultedIn> (Small_explicit_explicit_defaultedIn_var);
+ cbv<Large_explicit_explicit_defaultedIn> (Large_explicit_explicit_defaultedIn_var);
+ cbv<Derived_explicit_explicit_defaultedIn> (Derived_explicit_explicit_defaultedIn_var);
+ cbv_container<Container_explicit_explicit_defaultedIn> (Container_explicit_explicit_defaultedIn_var);
+ cbv<Small_explicit_explicit_defaultedOut> (Small_explicit_explicit_defaultedOut_var);
+ cbv<Large_explicit_explicit_defaultedOut> (Large_explicit_explicit_defaultedOut_var);
+ cbv<Derived_explicit_explicit_defaultedOut> (Derived_explicit_explicit_defaultedOut_var);
+ cbv_container<Container_explicit_explicit_defaultedOut> (Container_explicit_explicit_defaultedOut_var);
+ cbv<Small_explicit_explicit_deleted> (Small_explicit_explicit_deleted_var);
+ cbv<Large_explicit_explicit_deleted> (Large_explicit_explicit_deleted_var);
+ cbv<Derived_explicit_explicit_deleted> (Derived_explicit_explicit_deleted_var);
+ cbv_container<Container_explicit_explicit_deleted> (Container_explicit_explicit_deleted_var);
+ cbv<Small_explicit_defaultedIn_absent> (Small_explicit_defaultedIn_absent_var);
+ cbv<Large_explicit_defaultedIn_absent> (Large_explicit_defaultedIn_absent_var);
+ cbv<Derived_explicit_defaultedIn_absent> (Derived_explicit_defaultedIn_absent_var);
+ cbv_container<Container_explicit_defaultedIn_absent> (Container_explicit_defaultedIn_absent_var);
+ cbv<Small_explicit_defaultedIn_explicit> (Small_explicit_defaultedIn_explicit_var);
+ cbv<Large_explicit_defaultedIn_explicit> (Large_explicit_defaultedIn_explicit_var);
+ cbv<Derived_explicit_defaultedIn_explicit> (Derived_explicit_defaultedIn_explicit_var);
+ cbv_container<Container_explicit_defaultedIn_explicit> (Container_explicit_defaultedIn_explicit_var);
+ cbv<Small_explicit_defaultedIn_defaultedIn> (Small_explicit_defaultedIn_defaultedIn_var);
+ cbv<Large_explicit_defaultedIn_defaultedIn> (Large_explicit_defaultedIn_defaultedIn_var);
+ cbv<Derived_explicit_defaultedIn_defaultedIn> (Derived_explicit_defaultedIn_defaultedIn_var);
+ cbv_container<Container_explicit_defaultedIn_defaultedIn> (Container_explicit_defaultedIn_defaultedIn_var);
+ cbv<Small_explicit_defaultedIn_defaultedOut> (Small_explicit_defaultedIn_defaultedOut_var);
+ cbv<Large_explicit_defaultedIn_defaultedOut> (Large_explicit_defaultedIn_defaultedOut_var);
+ cbv<Derived_explicit_defaultedIn_defaultedOut> (Derived_explicit_defaultedIn_defaultedOut_var);
+ cbv_container<Container_explicit_defaultedIn_defaultedOut> (Container_explicit_defaultedIn_defaultedOut_var);
+ cbv<Small_explicit_defaultedIn_deleted> (Small_explicit_defaultedIn_deleted_var);
+ cbv<Large_explicit_defaultedIn_deleted> (Large_explicit_defaultedIn_deleted_var);
+ cbv<Derived_explicit_defaultedIn_deleted> (Derived_explicit_defaultedIn_deleted_var);
+ cbv_container<Container_explicit_defaultedIn_deleted> (Container_explicit_defaultedIn_deleted_var);
+ cbv<Small_explicit_defaultedOut_absent> (Small_explicit_defaultedOut_absent_var);
+ cbv<Large_explicit_defaultedOut_absent> (Large_explicit_defaultedOut_absent_var);
+ cbv<Derived_explicit_defaultedOut_absent> (Derived_explicit_defaultedOut_absent_var);
+ cbv_container<Container_explicit_defaultedOut_absent> (Container_explicit_defaultedOut_absent_var);
+ cbv<Small_explicit_defaultedOut_explicit> (Small_explicit_defaultedOut_explicit_var);
+ cbv<Large_explicit_defaultedOut_explicit> (Large_explicit_defaultedOut_explicit_var);
+ cbv<Derived_explicit_defaultedOut_explicit> (Derived_explicit_defaultedOut_explicit_var);
+ cbv_container<Container_explicit_defaultedOut_explicit> (Container_explicit_defaultedOut_explicit_var);
+ cbv<Small_explicit_defaultedOut_defaultedIn> (Small_explicit_defaultedOut_defaultedIn_var);
+ cbv<Large_explicit_defaultedOut_defaultedIn> (Large_explicit_defaultedOut_defaultedIn_var);
+ cbv<Derived_explicit_defaultedOut_defaultedIn> (Derived_explicit_defaultedOut_defaultedIn_var);
+ cbv_container<Container_explicit_defaultedOut_defaultedIn> (Container_explicit_defaultedOut_defaultedIn_var);
+ cbv<Small_explicit_defaultedOut_defaultedOut> (Small_explicit_defaultedOut_defaultedOut_var);
+ cbv<Large_explicit_defaultedOut_defaultedOut> (Large_explicit_defaultedOut_defaultedOut_var);
+ cbv<Derived_explicit_defaultedOut_defaultedOut> (Derived_explicit_defaultedOut_defaultedOut_var);
+ cbv_container<Container_explicit_defaultedOut_defaultedOut> (Container_explicit_defaultedOut_defaultedOut_var);
+ cbv<Small_explicit_defaultedOut_deleted> (Small_explicit_defaultedOut_deleted_var);
+ cbv<Large_explicit_defaultedOut_deleted> (Large_explicit_defaultedOut_deleted_var);
+ cbv<Derived_explicit_defaultedOut_deleted> (Derived_explicit_defaultedOut_deleted_var);
+ cbv_container<Container_explicit_defaultedOut_deleted> (Container_explicit_defaultedOut_deleted_var);
+ cbv<Small_defaultedIn_absent_absent> (Small_defaultedIn_absent_absent_var);
+ cbv<Large_defaultedIn_absent_absent> (Large_defaultedIn_absent_absent_var);
+ cbv<Derived_defaultedIn_absent_absent> (Derived_defaultedIn_absent_absent_var);
+ cbv_container<Container_defaultedIn_absent_absent> (Container_defaultedIn_absent_absent_var);
+ cbv<Small_defaultedIn_absent_explicit> (Small_defaultedIn_absent_explicit_var);
+ cbv<Large_defaultedIn_absent_explicit> (Large_defaultedIn_absent_explicit_var);
+ cbv<Derived_defaultedIn_absent_explicit> (Derived_defaultedIn_absent_explicit_var);
+ cbv_container<Container_defaultedIn_absent_explicit> (Container_defaultedIn_absent_explicit_var);
+ cbv<Small_defaultedIn_absent_defaultedIn> (Small_defaultedIn_absent_defaultedIn_var);
+ cbv<Large_defaultedIn_absent_defaultedIn> (Large_defaultedIn_absent_defaultedIn_var);
+ cbv<Derived_defaultedIn_absent_defaultedIn> (Derived_defaultedIn_absent_defaultedIn_var);
+ cbv_container<Container_defaultedIn_absent_defaultedIn> (Container_defaultedIn_absent_defaultedIn_var);
+ cbv<Small_defaultedIn_absent_defaultedOut> (Small_defaultedIn_absent_defaultedOut_var);
+ cbv<Large_defaultedIn_absent_defaultedOut> (Large_defaultedIn_absent_defaultedOut_var);
+ cbv<Derived_defaultedIn_absent_defaultedOut> (Derived_defaultedIn_absent_defaultedOut_var);
+ cbv_container<Container_defaultedIn_absent_defaultedOut> (Container_defaultedIn_absent_defaultedOut_var);
+ cbv<Small_defaultedIn_absent_deleted> (Small_defaultedIn_absent_deleted_var);
+ cbv<Large_defaultedIn_absent_deleted> (Large_defaultedIn_absent_deleted_var);
+ cbv<Derived_defaultedIn_absent_deleted> (Derived_defaultedIn_absent_deleted_var);
+ cbv_container<Container_defaultedIn_absent_deleted> (Container_defaultedIn_absent_deleted_var);
+ cbv<Small_defaultedIn_explicit_absent> (Small_defaultedIn_explicit_absent_var);
+ cbv<Large_defaultedIn_explicit_absent> (Large_defaultedIn_explicit_absent_var);
+ cbv<Derived_defaultedIn_explicit_absent> (Derived_defaultedIn_explicit_absent_var);
+ cbv_container<Container_defaultedIn_explicit_absent> (Container_defaultedIn_explicit_absent_var);
+ cbv<Small_defaultedIn_explicit_explicit> (Small_defaultedIn_explicit_explicit_var);
+ cbv<Large_defaultedIn_explicit_explicit> (Large_defaultedIn_explicit_explicit_var);
+ cbv<Derived_defaultedIn_explicit_explicit> (Derived_defaultedIn_explicit_explicit_var);
+ cbv_container<Container_defaultedIn_explicit_explicit> (Container_defaultedIn_explicit_explicit_var);
+ cbv<Small_defaultedIn_explicit_defaultedIn> (Small_defaultedIn_explicit_defaultedIn_var);
+ cbv<Large_defaultedIn_explicit_defaultedIn> (Large_defaultedIn_explicit_defaultedIn_var);
+ cbv<Derived_defaultedIn_explicit_defaultedIn> (Derived_defaultedIn_explicit_defaultedIn_var);
+ cbv_container<Container_defaultedIn_explicit_defaultedIn> (Container_defaultedIn_explicit_defaultedIn_var);
+ cbv<Small_defaultedIn_explicit_defaultedOut> (Small_defaultedIn_explicit_defaultedOut_var);
+ cbv<Large_defaultedIn_explicit_defaultedOut> (Large_defaultedIn_explicit_defaultedOut_var);
+ cbv<Derived_defaultedIn_explicit_defaultedOut> (Derived_defaultedIn_explicit_defaultedOut_var);
+ cbv_container<Container_defaultedIn_explicit_defaultedOut> (Container_defaultedIn_explicit_defaultedOut_var);
+ cbv<Small_defaultedIn_explicit_deleted> (Small_defaultedIn_explicit_deleted_var);
+ cbv<Large_defaultedIn_explicit_deleted> (Large_defaultedIn_explicit_deleted_var);
+ cbv<Derived_defaultedIn_explicit_deleted> (Derived_defaultedIn_explicit_deleted_var);
+ cbv_container<Container_defaultedIn_explicit_deleted> (Container_defaultedIn_explicit_deleted_var);
+ cbv<Small_defaultedIn_defaultedIn_absent> (Small_defaultedIn_defaultedIn_absent_var);
+ cbv<Large_defaultedIn_defaultedIn_absent> (Large_defaultedIn_defaultedIn_absent_var);
+ cbv<Derived_defaultedIn_defaultedIn_absent> (Derived_defaultedIn_defaultedIn_absent_var);
+ cbv_container<Container_defaultedIn_defaultedIn_absent> (Container_defaultedIn_defaultedIn_absent_var);
+ cbv<Small_defaultedIn_defaultedIn_explicit> (Small_defaultedIn_defaultedIn_explicit_var);
+ cbv<Large_defaultedIn_defaultedIn_explicit> (Large_defaultedIn_defaultedIn_explicit_var);
+ cbv<Derived_defaultedIn_defaultedIn_explicit> (Derived_defaultedIn_defaultedIn_explicit_var);
+ cbv_container<Container_defaultedIn_defaultedIn_explicit> (Container_defaultedIn_defaultedIn_explicit_var);
+ cbv<Small_defaultedIn_defaultedIn_defaultedIn> (Small_defaultedIn_defaultedIn_defaultedIn_var);
+ cbv<Large_defaultedIn_defaultedIn_defaultedIn> (Large_defaultedIn_defaultedIn_defaultedIn_var);
+ cbv<Derived_defaultedIn_defaultedIn_defaultedIn> (Derived_defaultedIn_defaultedIn_defaultedIn_var);
+ cbv_container<Container_defaultedIn_defaultedIn_defaultedIn> (Container_defaultedIn_defaultedIn_defaultedIn_var);
+ cbv<Small_defaultedIn_defaultedIn_defaultedOut> (Small_defaultedIn_defaultedIn_defaultedOut_var);
+ cbv<Large_defaultedIn_defaultedIn_defaultedOut> (Large_defaultedIn_defaultedIn_defaultedOut_var);
+ cbv<Derived_defaultedIn_defaultedIn_defaultedOut> (Derived_defaultedIn_defaultedIn_defaultedOut_var);
+ cbv_container<Container_defaultedIn_defaultedIn_defaultedOut> (Container_defaultedIn_defaultedIn_defaultedOut_var);
+ cbv<Small_defaultedIn_defaultedIn_deleted> (Small_defaultedIn_defaultedIn_deleted_var);
+ cbv<Large_defaultedIn_defaultedIn_deleted> (Large_defaultedIn_defaultedIn_deleted_var);
+ cbv<Derived_defaultedIn_defaultedIn_deleted> (Derived_defaultedIn_defaultedIn_deleted_var);
+ cbv_container<Container_defaultedIn_defaultedIn_deleted> (Container_defaultedIn_defaultedIn_deleted_var);
+ cbv<Small_defaultedIn_defaultedOut_absent> (Small_defaultedIn_defaultedOut_absent_var);
+ cbv<Large_defaultedIn_defaultedOut_absent> (Large_defaultedIn_defaultedOut_absent_var);
+ cbv<Derived_defaultedIn_defaultedOut_absent> (Derived_defaultedIn_defaultedOut_absent_var);
+ cbv_container<Container_defaultedIn_defaultedOut_absent> (Container_defaultedIn_defaultedOut_absent_var);
+ cbv<Small_defaultedIn_defaultedOut_explicit> (Small_defaultedIn_defaultedOut_explicit_var);
+ cbv<Large_defaultedIn_defaultedOut_explicit> (Large_defaultedIn_defaultedOut_explicit_var);
+ cbv<Derived_defaultedIn_defaultedOut_explicit> (Derived_defaultedIn_defaultedOut_explicit_var);
+ cbv_container<Container_defaultedIn_defaultedOut_explicit> (Container_defaultedIn_defaultedOut_explicit_var);
+ cbv<Small_defaultedIn_defaultedOut_defaultedIn> (Small_defaultedIn_defaultedOut_defaultedIn_var);
+ cbv<Large_defaultedIn_defaultedOut_defaultedIn> (Large_defaultedIn_defaultedOut_defaultedIn_var);
+ cbv<Derived_defaultedIn_defaultedOut_defaultedIn> (Derived_defaultedIn_defaultedOut_defaultedIn_var);
+ cbv_container<Container_defaultedIn_defaultedOut_defaultedIn> (Container_defaultedIn_defaultedOut_defaultedIn_var);
+ cbv<Small_defaultedIn_defaultedOut_defaultedOut> (Small_defaultedIn_defaultedOut_defaultedOut_var);
+ cbv<Large_defaultedIn_defaultedOut_defaultedOut> (Large_defaultedIn_defaultedOut_defaultedOut_var);
+ cbv<Derived_defaultedIn_defaultedOut_defaultedOut> (Derived_defaultedIn_defaultedOut_defaultedOut_var);
+ cbv_container<Container_defaultedIn_defaultedOut_defaultedOut> (Container_defaultedIn_defaultedOut_defaultedOut_var);
+ cbv<Small_defaultedIn_defaultedOut_deleted> (Small_defaultedIn_defaultedOut_deleted_var);
+ cbv<Large_defaultedIn_defaultedOut_deleted> (Large_defaultedIn_defaultedOut_deleted_var);
+ cbv<Derived_defaultedIn_defaultedOut_deleted> (Derived_defaultedIn_defaultedOut_deleted_var);
+ cbv_container<Container_defaultedIn_defaultedOut_deleted> (Container_defaultedIn_defaultedOut_deleted_var);
+ cbv<Small_defaultedOut_absent_absent> (Small_defaultedOut_absent_absent_var);
+ cbv<Large_defaultedOut_absent_absent> (Large_defaultedOut_absent_absent_var);
+ cbv<Derived_defaultedOut_absent_absent> (Derived_defaultedOut_absent_absent_var);
+ cbv_container<Container_defaultedOut_absent_absent> (Container_defaultedOut_absent_absent_var);
+ cbv<Small_defaultedOut_absent_explicit> (Small_defaultedOut_absent_explicit_var);
+ cbv<Large_defaultedOut_absent_explicit> (Large_defaultedOut_absent_explicit_var);
+ cbv<Derived_defaultedOut_absent_explicit> (Derived_defaultedOut_absent_explicit_var);
+ cbv_container<Container_defaultedOut_absent_explicit> (Container_defaultedOut_absent_explicit_var);
+ cbv<Small_defaultedOut_absent_defaultedIn> (Small_defaultedOut_absent_defaultedIn_var);
+ cbv<Large_defaultedOut_absent_defaultedIn> (Large_defaultedOut_absent_defaultedIn_var);
+ cbv<Derived_defaultedOut_absent_defaultedIn> (Derived_defaultedOut_absent_defaultedIn_var);
+ cbv_container<Container_defaultedOut_absent_defaultedIn> (Container_defaultedOut_absent_defaultedIn_var);
+ cbv<Small_defaultedOut_absent_defaultedOut> (Small_defaultedOut_absent_defaultedOut_var);
+ cbv<Large_defaultedOut_absent_defaultedOut> (Large_defaultedOut_absent_defaultedOut_var);
+ cbv<Derived_defaultedOut_absent_defaultedOut> (Derived_defaultedOut_absent_defaultedOut_var);
+ cbv_container<Container_defaultedOut_absent_defaultedOut> (Container_defaultedOut_absent_defaultedOut_var);
+ cbv<Small_defaultedOut_absent_deleted> (Small_defaultedOut_absent_deleted_var);
+ cbv<Large_defaultedOut_absent_deleted> (Large_defaultedOut_absent_deleted_var);
+ cbv<Derived_defaultedOut_absent_deleted> (Derived_defaultedOut_absent_deleted_var);
+ cbv_container<Container_defaultedOut_absent_deleted> (Container_defaultedOut_absent_deleted_var);
+ cbv<Small_defaultedOut_explicit_absent> (Small_defaultedOut_explicit_absent_var);
+ cbv<Large_defaultedOut_explicit_absent> (Large_defaultedOut_explicit_absent_var);
+ cbv<Derived_defaultedOut_explicit_absent> (Derived_defaultedOut_explicit_absent_var);
+ cbv_container<Container_defaultedOut_explicit_absent> (Container_defaultedOut_explicit_absent_var);
+ cbv<Small_defaultedOut_explicit_explicit> (Small_defaultedOut_explicit_explicit_var);
+ cbv<Large_defaultedOut_explicit_explicit> (Large_defaultedOut_explicit_explicit_var);
+ cbv<Derived_defaultedOut_explicit_explicit> (Derived_defaultedOut_explicit_explicit_var);
+ cbv_container<Container_defaultedOut_explicit_explicit> (Container_defaultedOut_explicit_explicit_var);
+ cbv<Small_defaultedOut_explicit_defaultedIn> (Small_defaultedOut_explicit_defaultedIn_var);
+ cbv<Large_defaultedOut_explicit_defaultedIn> (Large_defaultedOut_explicit_defaultedIn_var);
+ cbv<Derived_defaultedOut_explicit_defaultedIn> (Derived_defaultedOut_explicit_defaultedIn_var);
+ cbv_container<Container_defaultedOut_explicit_defaultedIn> (Container_defaultedOut_explicit_defaultedIn_var);
+ cbv<Small_defaultedOut_explicit_defaultedOut> (Small_defaultedOut_explicit_defaultedOut_var);
+ cbv<Large_defaultedOut_explicit_defaultedOut> (Large_defaultedOut_explicit_defaultedOut_var);
+ cbv<Derived_defaultedOut_explicit_defaultedOut> (Derived_defaultedOut_explicit_defaultedOut_var);
+ cbv_container<Container_defaultedOut_explicit_defaultedOut> (Container_defaultedOut_explicit_defaultedOut_var);
+ cbv<Small_defaultedOut_explicit_deleted> (Small_defaultedOut_explicit_deleted_var);
+ cbv<Large_defaultedOut_explicit_deleted> (Large_defaultedOut_explicit_deleted_var);
+ cbv<Derived_defaultedOut_explicit_deleted> (Derived_defaultedOut_explicit_deleted_var);
+ cbv_container<Container_defaultedOut_explicit_deleted> (Container_defaultedOut_explicit_deleted_var);
+ cbv<Small_defaultedOut_defaultedIn_absent> (Small_defaultedOut_defaultedIn_absent_var);
+ cbv<Large_defaultedOut_defaultedIn_absent> (Large_defaultedOut_defaultedIn_absent_var);
+ cbv<Derived_defaultedOut_defaultedIn_absent> (Derived_defaultedOut_defaultedIn_absent_var);
+ cbv_container<Container_defaultedOut_defaultedIn_absent> (Container_defaultedOut_defaultedIn_absent_var);
+ cbv<Small_defaultedOut_defaultedIn_explicit> (Small_defaultedOut_defaultedIn_explicit_var);
+ cbv<Large_defaultedOut_defaultedIn_explicit> (Large_defaultedOut_defaultedIn_explicit_var);
+ cbv<Derived_defaultedOut_defaultedIn_explicit> (Derived_defaultedOut_defaultedIn_explicit_var);
+ cbv_container<Container_defaultedOut_defaultedIn_explicit> (Container_defaultedOut_defaultedIn_explicit_var);
+ cbv<Small_defaultedOut_defaultedIn_defaultedIn> (Small_defaultedOut_defaultedIn_defaultedIn_var);
+ cbv<Large_defaultedOut_defaultedIn_defaultedIn> (Large_defaultedOut_defaultedIn_defaultedIn_var);
+ cbv<Derived_defaultedOut_defaultedIn_defaultedIn> (Derived_defaultedOut_defaultedIn_defaultedIn_var);
+ cbv_container<Container_defaultedOut_defaultedIn_defaultedIn> (Container_defaultedOut_defaultedIn_defaultedIn_var);
+ cbv<Small_defaultedOut_defaultedIn_defaultedOut> (Small_defaultedOut_defaultedIn_defaultedOut_var);
+ cbv<Large_defaultedOut_defaultedIn_defaultedOut> (Large_defaultedOut_defaultedIn_defaultedOut_var);
+ cbv<Derived_defaultedOut_defaultedIn_defaultedOut> (Derived_defaultedOut_defaultedIn_defaultedOut_var);
+ cbv_container<Container_defaultedOut_defaultedIn_defaultedOut> (Container_defaultedOut_defaultedIn_defaultedOut_var);
+ cbv<Small_defaultedOut_defaultedIn_deleted> (Small_defaultedOut_defaultedIn_deleted_var);
+ cbv<Large_defaultedOut_defaultedIn_deleted> (Large_defaultedOut_defaultedIn_deleted_var);
+ cbv<Derived_defaultedOut_defaultedIn_deleted> (Derived_defaultedOut_defaultedIn_deleted_var);
+ cbv_container<Container_defaultedOut_defaultedIn_deleted> (Container_defaultedOut_defaultedIn_deleted_var);
+ cbv<Small_defaultedOut_defaultedOut_absent> (Small_defaultedOut_defaultedOut_absent_var);
+ cbv<Large_defaultedOut_defaultedOut_absent> (Large_defaultedOut_defaultedOut_absent_var);
+ cbv<Derived_defaultedOut_defaultedOut_absent> (Derived_defaultedOut_defaultedOut_absent_var);
+ cbv_container<Container_defaultedOut_defaultedOut_absent> (Container_defaultedOut_defaultedOut_absent_var);
+ cbv<Small_defaultedOut_defaultedOut_explicit> (Small_defaultedOut_defaultedOut_explicit_var);
+ cbv<Large_defaultedOut_defaultedOut_explicit> (Large_defaultedOut_defaultedOut_explicit_var);
+ cbv<Derived_defaultedOut_defaultedOut_explicit> (Derived_defaultedOut_defaultedOut_explicit_var);
+ cbv_container<Container_defaultedOut_defaultedOut_explicit> (Container_defaultedOut_defaultedOut_explicit_var);
+ cbv<Small_defaultedOut_defaultedOut_defaultedIn> (Small_defaultedOut_defaultedOut_defaultedIn_var);
+ cbv<Large_defaultedOut_defaultedOut_defaultedIn> (Large_defaultedOut_defaultedOut_defaultedIn_var);
+ cbv<Derived_defaultedOut_defaultedOut_defaultedIn> (Derived_defaultedOut_defaultedOut_defaultedIn_var);
+ cbv_container<Container_defaultedOut_defaultedOut_defaultedIn> (Container_defaultedOut_defaultedOut_defaultedIn_var);
+ cbv<Small_defaultedOut_defaultedOut_defaultedOut> (Small_defaultedOut_defaultedOut_defaultedOut_var);
+ cbv<Large_defaultedOut_defaultedOut_defaultedOut> (Large_defaultedOut_defaultedOut_defaultedOut_var);
+ cbv<Derived_defaultedOut_defaultedOut_defaultedOut> (Derived_defaultedOut_defaultedOut_defaultedOut_var);
+ cbv_container<Container_defaultedOut_defaultedOut_defaultedOut> (Container_defaultedOut_defaultedOut_defaultedOut_var);
+ cbv<Small_defaultedOut_defaultedOut_deleted> (Small_defaultedOut_defaultedOut_deleted_var);
+ cbv<Large_defaultedOut_defaultedOut_deleted> (Large_defaultedOut_defaultedOut_deleted_var);
+ cbv<Derived_defaultedOut_defaultedOut_deleted> (Derived_defaultedOut_defaultedOut_deleted_var);
+ cbv_container<Container_defaultedOut_defaultedOut_deleted> (Container_defaultedOut_defaultedOut_deleted_var);
+
+
+ /* stop here */
+
+ return 0;
}
diff --git a/gdb/testsuite/gdb.cp/pass-by-ref.exp b/gdb/testsuite/gdb.cp/pass-by-ref.exp
index 94dd3455ee4..8051c5c26b1 100644
--- a/gdb/testsuite/gdb.cp/pass-by-ref.exp
+++ b/gdb/testsuite/gdb.cp/pass-by-ref.exp
@@ -14,20 +14,418 @@
# along with this program. If not, see <http://www.gnu.org/licenses/>.
# Check that GDB can call C++ functions whose parameters have
-# object type, but are passed by reference.
+# object type, and are either passed by value or implicitly by reference.
+#
+# Suppose F is a function that has a call-by-value parameter whose
+# type is class C. When calling F with an argument A, a copy of A should
+# be created and passed to F. If C is a trivially-copyable type, A can
+# be copied by a straightforward memory copy. However, roughly speaking,
+# if C has a user-defined copy constructor and/or a user-defined
+# destructor, the copy ctor should be used to initialize the copy of A
+# before calling F, and a reference to that copy is passed to F. After
+# the function returns, the destructor should be called to destruct the
+# copy. In this case, C is said to be a 'pass-by-reference' type.
+# Determining whether C is pass-by-ref depends on
+# how the copy ctor, destructor, and the move ctor of C are defined.
+# First of all, C is not copy constructible if its copy constructor is
+# explicitly or implicitly deleted. In this case, it would be illegal
+# to pass values of type C to a function. C is pass-by-value, if all of
+# its copy ctor, dtor, and move ctor are trivially defined.
+# Otherwise, it is pass-by-ref.
+#
+# To cover the many possible combinations, this test generates classes
+# that contain three special functions:
+# (1) a copy constructor,
+# (2) a destructor, and
+# (3) a move constructor.
+# A special function is in one of the following states:
+# * explicit: The function is explicitly defined by the user.
+# * defaultedIn: The function is defaulted inside the class decl,
+# using the 'default' keyword.
+# * defaultedOut: The function is declared inside the class decl,
+# and defaulted outside using the 'default' keyword.
+# * deleted: The function is explicitly deleted by the user,
+# using the 'delete' keyword.
+# * absent: The function is not declared by the user (i.e. it does not
+# exist in the source. The compiler generates (or deletes) the
+# definition in this case.
+#
+# The C++ ABI decides if a class is pass-by-value or pass-by-ref
+# (i.e. trivially copyable or not) first at the language level, based
+# on the state of the special functions. Then, at the target level, a
+# class may be determined to be pass-by-ref because of its size
+# (e.g. if it is too large to fit on registers). For this reason, this
+# test generates both a small and a large version for the same
+# combination of special function states.
+#
+# A class is not trivially-copyable if a base class or a field is not
+# trivially-copyable, even though the class definition itself seems
+# trivial. To test these cases, we also generate derived classes and
+# container classes.
+#
+# The companion test file pass-by-ref-2.exp also contains
+# manually-written cases.
+
+#
+# Flag to control whether to re-generate the source file
+#
+set GENERATE_SOURCE false
-if { [skip_cplus_tests] } { continue }
+if {[skip_cplus_tests]} {
+ untested "c++ test skipped"
+ continue
+}
standard_testfile .cc
-if {[prepare_for_testing "failed to prepare" $testfile $srcfile {debug c++}]} {
+# Some constant values used when generating the source
+
+set SMALL 2
+set LARGE 150
+set ORIGINAL 2
+set CUSTOM 3
+set ADDED 4
+set TRACE 5
+
+
+# Return 1 if the class whose special function states are STATES
+# is copyable. Otherwise return 0.
+
+proc is_copy_constructible { states } {
+ set cctor [lindex $states 0]
+ set dtor [lindex $states 1]
+ set mctor [lindex $states 2]
+
+ if {$cctor == "deleted" || ($cctor == "absent" && $mctor != "absent")} {
+ return 0
+ }
+ return 1
+}
+
+# Generate a declaration and an out-of-class definition for a function
+# with the provided signature. The STATE should be one of the following:
+# - explicit, defaultedIn, defaultedOut, deleted, absent
+
+proc generate_member_function { classname signature length state } {
+ set declaration ""
+ set definition ""
+
+ global CUSTOM
+ global TRACE
+
+ switch $state {
+ explicit {
+ set declaration "$signature;\n"
+ set definition "$classname\:\:$signature
+ {
+ data\[0\] = $CUSTOM;
+ data\[[expr $length - 1]\] = $CUSTOM;
+ tracer = $TRACE;
+ }\n"
+ }
+ defaultedIn {
+ set declaration "$signature = default;\n"
+ }
+ defaultedOut {
+ set declaration "$signature;\n"
+ set definition "$classname\:\:$signature = default;\n"
+ }
+ deleted {
+ set declaration "$signature = delete;\n"
+ }
+ default {
+ # function is not user-defined in this case
+ }
+ }
+
+ return [list $declaration $definition]
+}
+
+# Generate a C++ class with the given CLASSNAME and LENGTH-many
+# integer elements. The STATES is an array of 3 items
+# containing the desired state of the special functions
+# in this order:
+# copy constructor, destructor, move constructor
+
+proc generate_class { classname length states } {
+ set declarations ""
+ set definitions ""
+ set classname "${classname}_[join $states _]"
+
+ for {set i 0} {$i < [llength $states]} {incr i} {
+ set sig ""
+ switch $i {
+ 0 {set sig "$classname (const $classname \&rhs)"}
+ 1 {set sig "\~$classname (void)"}
+ 2 {set sig "$classname ($classname \&\&rhs)"}
+ }
+
+ set state [lindex $states $i]
+ set code [generate_member_function $classname $sig $length $state]
+ append declarations [lindex $code 0]
+ append definitions [lindex $code 1]
+ }
+
+ global ORIGINAL
+
+ return "
+ /*** C++ class $classname ***/
+ class ${classname} {
+ public:
+ $classname (void);
+ $declarations
+
+ int data\[$length\];
+ };
+
+ $classname\:\:$classname (void)
+ {
+ data\[0\] = $ORIGINAL;
+ data\[[expr $length - 1]\] = $ORIGINAL;
+ }
+
+ $definitions
+
+ $classname ${classname}_var; /* global var */
+
+ template int cbv<$classname> ($classname arg);"
+}
+
+# Generate a small C++ class
+
+proc generate_small_class { states } {
+ global SMALL
+ return [generate_class Small $SMALL $states];
+}
+
+# Generate a large C++ class
+
+proc generate_large_class { states } {
+ global LARGE
+ return [generate_class Large $LARGE $states];
+}
+
+# Generate a class that derives from a small class
+
+proc generate_derived_class { states } {
+ set base "Small_[join $states _]"
+ set classname "Derived_[join $states _]"
+
+ return "
+ /*** Class derived from $base ***/
+ class $classname : public $base {
+ public:
+ };
+
+ $classname ${classname}_var; /* global var */
+
+ template int cbv<$classname> ($classname arg);"
+}
+
+# Generate a class that contains a small class item
+
+proc generate_container_class { states } {
+ set contained "Small_[join $states _]"
+ set classname "Container_[join $states _]"
+
+ return "
+ /*** Class that contains $contained ***/
+ class $classname {
+ public:
+ $contained item;
+ };
+
+ $classname ${classname}_var; /* global var */
+
+ template int cbv_container<$classname> ($classname arg);"
+}
+
+# Generate useful statements that use a class in the debugee program
+
+proc generate_stmts { classprefix states {cbvfun "cbv"}} {
+ set classname "${classprefix}_[join $states _]"
+
+ # Having an explicit call to the cbv function in the debugee program
+ # ensures that the compiler will emit necessary function in the binary.
+ if {[is_copy_constructible $states]} {
+ set cbvcall "$cbvfun<$classname> (${classname}_var);\n"
+ } else {
+ set cbvcall ""
+ }
+
+ return "$cbvcall"
+}
+
+# Generate the complete debugee program
+
+proc generate_program { classes stmts } {
+ set copyright "/* This testcase is part of GDB, the GNU debugger.
+
+ Copyright 2007-2019 Free Software Foundation, Inc.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>. */"
+
+ global ADDED
+
+ return "$copyright
+
+ /*** THIS FILE IS GENERATED BY THE TEST. ***/
+ /* If you regenerate, auto-indent and delete-trailing-whitespace
+ before committing. */
+
+ static int tracer = 0;
+
+ /* The call-by-value function. */
+ template <class T>
+ int
+ cbv (T arg)
+ {
+ arg.data\[0\] += $ADDED; // intentionally modify the arg
+ return arg.data\[0\];
+ }
+
+ template <class T>
+ int
+ cbv_container (T arg)
+ {
+ arg.item.data\[0\] += $ADDED; // intentionally modify
+ return arg.item.data\[0\];
+ }
+
+ $classes
+
+ int
+ main (void)
+ {
+ $stmts
+
+ /* stop here */
+
+ return 0;
+ }"
+}
+
+# Compute all the combinations of special function states.
+# We do not contain the 'deleted' state for the destructor,
+# because it is illegal to have stack-allocated objects
+# whose destructor have been deleted. This case is covered
+# in pass-by-ref-2 via heap-allocated objects.
+
+set options_nodelete [list absent explicit defaultedIn defaultedOut]
+set options [concat $options_nodelete {deleted}]
+set all_combinations {}
+
+foreach cctor $options {
+ foreach dtor $options_nodelete {
+ foreach mctor $options {
+ lappend all_combinations [list $cctor $dtor $mctor]
+ }
+ }
+}
+
+if {$GENERATE_SOURCE} {
+ # Generate the classes and overwrite srcfile
+
+ set classes ""
+ set stmts ""
+
+ foreach state $all_combinations {
+ append classes [generate_small_class $state]
+ append stmts [generate_stmts "Small" $state]
+
+ append classes [generate_large_class $state]
+ append stmts [generate_stmts "Large" $state]
+
+ append classes [generate_derived_class $state]
+ append stmts [generate_stmts "Derived" $state]
+
+ append classes [generate_container_class $state]
+ append stmts [generate_stmts "Container" $state "cbv_container"]
+ }
+
+ # Generate the program code and compile
+ set program [generate_program $classes $stmts]
+ set testfolder [file dirname $testfile]
+ gdb_produce_source ${srcdir}/${subdir}/$srcfile $program
+}
+
+set options {debug c++ additional_flags=-std=c++11}
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile $options]} {
return -1
}
-if ![runto_main] then {
+if {![runto_main]} {
+ untested "failed to run to main"
return -1
}
-gdb_test "print foo (global_obj)" " = 3" "call function in obj"
-gdb_test "print blap (global_derived)" " = 3" "call function in derived"
-gdb_test "print blip (global_container)" " = 3" "call function in container"
+set bp_location [gdb_get_line_number "stop here"]
+gdb_breakpoint $bp_location
+gdb_continue_to_breakpoint "end of main" ".*return .*;"
+
+# Do the checks for a given class whose name is prefixed with PREFIX,
+# and whose special functions have the states given in STATES.
+# The name of the call-by-value function and the expression to access
+# the data field can be specified explicitly if the default values
+# do not work.
+
+proc test_for_class { prefix states cbvfun data_field length} {
+ set name "${prefix}_[join $states _]"
+
+ set cctor [lindex $states 0]
+ set dtor [lindex $states 1]
+ set mctor [lindex $states 2]
+
+ global ORIGINAL
+ global CUSTOM
+ global ADDED
+ global TRACE
+
+ with_test_prefix $name {
+ if {[is_copy_constructible $states]} {
+ set expected [expr {$ORIGINAL + $ADDED}]
+ if {$cctor == "explicit"} {
+ set expected [expr {$CUSTOM + $ADDED}]
+ }
+ if {$dtor == "explicit"} {
+ gdb_test "print tracer = 0" " = 0" "reset the tracer"
+ }
+ gdb_test "print ${cbvfun}<$name> (${name}_var)" " = $expected" \
+ "call '$cbvfun'"
+ gdb_test "print ${name}_var.${data_field}\[0\]" " = $ORIGINAL" \
+ "cbv argument should not change (item 0)"
+ if {$length > 1} {
+ set last_index [expr $length - 1]
+ gdb_test "print ${name}_var.${data_field}\[$last_index\]" \
+ " = $ORIGINAL" \
+ "cbv argument should not change (item $last_index)"
+ }
+ if {$dtor == "explicit"} {
+ gdb_test "print tracer" " = $TRACE" \
+ "destructor should be called"
+ }
+ } else {
+ gdb_test "print ${cbvfun}<$name> (${name}_var)" \
+ ".* cannot be evaluated .* '${name}' is not copy constructible" \
+ "calling '$cbvfun' should be refused"
+ }
+ }
+}
+
+foreach state $all_combinations {
+ test_for_class "Small" $state "cbv" "data" $SMALL
+ test_for_class "Large" $state "cbv" "data" $LARGE
+ test_for_class "Derived" $state "cbv" "data" 1
+ test_for_class "Container" $state "cbv_container" "item.data" 1
+}
--
2.21.0
^ permalink raw reply [flat|nested] 19+ messages in thread
* [PATCH 5/8] infcall: move assertions in 'call_function_by_hand_dummy' to an earlier spot
2019-04-23 14:32 [PATCH 0/8] Fix inferior call for C++ pass-by-reference arguments Tankut Baris Aktemur
` (5 preceding siblings ...)
2019-04-23 14:32 ` [PATCH 7/8] infcall: handle pass-by-reference arguments appropriately Tankut Baris Aktemur
@ 2019-04-23 14:33 ` Tankut Baris Aktemur
2019-04-23 14:33 ` [PATCH 8/8] testsuite, cp: increase the coverage of testing pass-by-ref arguments Tankut Baris Aktemur
` (2 subsequent siblings)
9 siblings, 0 replies; 19+ messages in thread
From: Tankut Baris Aktemur @ 2019-04-23 14:33 UTC (permalink / raw)
To: gdb-patches
This is a refactoring that performs type assertions on the callee
function at the beginning of 'call_function_by_hand_dummy' rather
than at a later point.
gdb/ChangeLog:
* infcall.c (call_function_by_hand_dummy): Refactor.
---
gdb/infcall.c | 41 +++++++++++++++++++++--------------------
1 file changed, 21 insertions(+), 20 deletions(-)
diff --git a/gdb/infcall.c b/gdb/infcall.c
index fd0fef185d5..e562790bd0d 100644
--- a/gdb/infcall.c
+++ b/gdb/infcall.c
@@ -767,6 +767,27 @@ call_function_by_hand_dummy (struct value *function,
if (!gdbarch_push_dummy_call_p (gdbarch))
error (_("This target does not support function calls."));
+ /* Find the function type and do a sanity check. */
+ type *ftype;
+ type *values_type;
+ CORE_ADDR funaddr = find_function_addr (function, &values_type, &ftype);
+
+ if (values_type == NULL)
+ values_type = default_return_type;
+ if (values_type == NULL)
+ {
+ const char *name = get_function_name (funaddr,
+ name_buf, sizeof (name_buf));
+ error (_("'%s' has unknown return type; "
+ "cast the call to its declared return type"),
+ name);
+ }
+
+ values_type = check_typedef (values_type);
+
+ if (args.size () < TYPE_NFIELDS (ftype))
+ error (_("Too few arguments in function call."));
+
/* A holder for the inferior status.
This is only needed while we're preparing the inferior function call. */
infcall_control_state_up inf_status (save_infcall_control_state ());
@@ -872,23 +893,6 @@ call_function_by_hand_dummy (struct value *function,
}
}
- type *ftype;
- type *values_type;
- CORE_ADDR funaddr = find_function_addr (function, &values_type, &ftype);
-
- if (values_type == NULL)
- values_type = default_return_type;
- if (values_type == NULL)
- {
- const char *name = get_function_name (funaddr,
- name_buf, sizeof (name_buf));
- error (_("'%s' has unknown return type; "
- "cast the call to its declared return type"),
- name);
- }
-
- values_type = check_typedef (values_type);
-
/* Are we returning a value using a structure return? */
if (gdbarch_return_in_first_hidden_param_p (gdbarch, values_type))
@@ -966,9 +970,6 @@ call_function_by_hand_dummy (struct value *function,
internal_error (__FILE__, __LINE__, _("bad switch"));
}
- if (args.size () < TYPE_NFIELDS (ftype))
- error (_("Too few arguments in function call."));
-
for (int i = args.size () - 1; i >= 0; i--)
{
int prototyped;
--
2.21.0
^ permalink raw reply [flat|nested] 19+ messages in thread
* Re: [PATCH 1/8] gdb: recognize new DWARF attributes: defaulted, deleted, calling conv.
2019-04-23 14:32 ` [PATCH 1/8] gdb: recognize new DWARF attributes: defaulted, deleted, calling conv Tankut Baris Aktemur
@ 2019-04-23 21:40 ` Andrew Burgess
0 siblings, 0 replies; 19+ messages in thread
From: Andrew Burgess @ 2019-04-23 21:40 UTC (permalink / raw)
To: Tankut Baris Aktemur; +Cc: gdb-patches
* Tankut Baris Aktemur <tankut.baris.aktemur@intel.com> [2019-04-23 16:31:47 +0200]:
> Extend GDB's internal representation of types to include the
> DW_AT_calling_convention, DW_AT_defaulted, and DW_AT_deleted attributes
> that were introduced in DWARF5.
>
> gdb/ChangeLog:
>
> * dwarf2read.c (dwarf2_add_member_fn): Read the DW_AT_defaulted
> and DW_AT_deleted attributes of a function.
> (read_structure_type): Read the DW_AT_calling_convention attribute
> of a type.
> * gdbtypes.h (struct fn_field)<defaulted>: New field to store the
> DW_AT_defaulted attribute.
> (struct fn_field)<is_deleted>: New field to store the DW_AT_deleted
> attribute.
> (struct cplus_struct_type)<calling_convention>: New field to store
> the DW_AT_calling_convention attribute.
> (TYPE_FN_FIELD_DEFAULTED): New macro.
> (TYPE_FN_FIELD_DELETED): New macro.
> (TYPE_CPLUS_CALLING_CONVENTION): New macro.
> * gdbtypes.c: (dump_fn_fieldlists): Update for the changes made
> to the .h file.
> (print_cplus_stuff): Likewise.
This looks good to me, with a couple of requests for extended
comments, see below...
>
> ---
> gdb/dwarf2read.c | 20 ++++++++++++++++++++
> gdb/gdbtypes.c | 7 +++++++
> gdb/gdbtypes.h | 19 ++++++++++++++++++-
> 3 files changed, 45 insertions(+), 1 deletion(-)
>
> diff --git a/gdb/dwarf2read.c b/gdb/dwarf2read.c
> index 829b07f01ac..435f234f2c9 100644
> --- a/gdb/dwarf2read.c
> +++ b/gdb/dwarf2read.c
> @@ -15539,6 +15539,16 @@ dwarf2_add_member_fn (struct field_info *fip, struct die_info *die,
> if (attr && DW_UNSND (attr) != 0)
> fnp->is_artificial = 1;
>
> + /* Check for defaulted methods. */
> + attr = dwarf2_attr (die, DW_AT_defaulted, cu);
> + if (attr)
> + fnp->defaulted = DW_UNSND (attr);
> +
> + /* Check for deleted methods. */
> + attr = dwarf2_attr (die, DW_AT_deleted, cu);
> + if (attr && DW_UNSND (attr) != 0)
> + fnp->is_deleted = 1;
> +
> fnp->is_constructor = dwarf2_is_constructor (die, cu);
>
> /* Get index in virtual function table if it is a virtual member
> @@ -15859,6 +15869,16 @@ read_structure_type (struct die_info *die, struct dwarf2_cu *cu)
> if (cu->language == language_cplus && die->tag == DW_TAG_class_type)
> TYPE_DECLARED_CLASS (type) = 1;
>
> + /* Store the calling convention in the type if it's available in
> + the die. Otherwise the calling convention remains set to
> + the default value DW_CC_normal. */
> + attr = dwarf2_attr (die, DW_AT_calling_convention, cu);
> + if (attr)
> + {
> + ALLOCATE_CPLUS_STRUCT_TYPE (type);
> + TYPE_CPLUS_CALLING_CONVENTION (type) = DW_UNSND (attr);
> + }
> +
> attr = dwarf2_attr (die, DW_AT_byte_size, cu);
> if (attr)
> {
> diff --git a/gdb/gdbtypes.c b/gdb/gdbtypes.c
> index b3424d81be4..b32f13189a9 100644
> --- a/gdb/gdbtypes.c
> +++ b/gdb/gdbtypes.c
> @@ -4389,6 +4389,10 @@ dump_fn_fieldlists (struct type *type, int spaces)
> TYPE_FN_FIELD_PROTECTED (f, overload_idx));
> printfi_filtered (spaces + 8, "is_stub %d\n",
> TYPE_FN_FIELD_STUB (f, overload_idx));
> + printfi_filtered (spaces + 8, "defaulted %d\n",
> + TYPE_FN_FIELD_DEFAULTED (f, overload_idx));
> + printfi_filtered (spaces + 8, "is_deleted %d\n",
> + TYPE_FN_FIELD_DELETED (f, overload_idx));
> printfi_filtered (spaces + 8, "voffset %u\n",
> TYPE_FN_FIELD_VOFFSET (f, overload_idx));
> }
> @@ -4452,6 +4456,9 @@ print_cplus_stuff (struct type *type, int spaces)
> {
> dump_fn_fieldlists (type, spaces);
> }
> +
> + printfi_filtered (spaces, "calling_convention %d\n",
> + TYPE_CPLUS_CALLING_CONVENTION (type));
> }
>
> /* Print the contents of the TYPE's type_specific union, assuming that
> diff --git a/gdb/gdbtypes.h b/gdb/gdbtypes.h
> index 147a2de355e..3c7846a0e18 100644
> --- a/gdb/gdbtypes.h
> +++ b/gdb/gdbtypes.h
> @@ -915,6 +915,10 @@ struct fn_field
>
> struct type *fcontext;
>
> + /* * DW_AT_defaulted attribute. */
Taking inspiration from how 'calling_convention' is commented in the
'struct func_type', it would be nice if this comment mentioned what
values can be expected here, something like:
/* * The DW_AT_defaulted attribute for this function, the value is one
of the DW_DEFAULTED enum dwarf_defaulted_attribute constants. */
> +
> + unsigned int defaulted;
> +
> /* Attributes. */
>
> unsigned int is_const:1;
> @@ -932,9 +936,13 @@ struct fn_field
>
> unsigned int is_constructor : 1;
>
> + /* * True if this function is deleted, false otherwise. */
> +
> + unsigned int is_deleted : 1;
> +
> /* * Unused. */
>
> - unsigned int dummy:9;
> + unsigned int dummy:8;
>
> /* * Index into that baseclass's virtual function table, minus 2;
> else if static: VOFFSET_STATIC; else: 0. */
> @@ -1076,6 +1084,11 @@ struct cplus_struct_type
> classes. */
>
> struct symbol **template_arguments;
> +
> + /* * The calling convention for this type, fetched from the
> + DW_AT_calling_convention attribute. */
Similarly it would be nice to include a comment about which values are
valid here, something like:
/* * The calling convention for this type, fetched from the
DW_AT_calling_convention attribute. The value is one of the
DW_CC enum dwarf_calling_convention constants.*/
thanks,
Andrew
> +
> + unsigned calling_convention : 8;
> };
>
> /* * Struct used to store conversion rankings. */
> @@ -1405,6 +1418,8 @@ extern void set_type_vptr_basetype (struct type *, struct type *);
> ? (struct cplus_struct_type*)&cplus_struct_default \
> : TYPE_RAW_CPLUS_SPECIFIC(thistype))
> #define TYPE_RAW_CPLUS_SPECIFIC(thistype) TYPE_MAIN_TYPE(thistype)->type_specific.cplus_stuff
> +#define TYPE_CPLUS_CALLING_CONVENTION(thistype) \
> + TYPE_MAIN_TYPE(thistype)->type_specific.cplus_stuff->calling_convention
> #define TYPE_FLOATFORMAT(thistype) TYPE_MAIN_TYPE(thistype)->type_specific.floatformat
> #define TYPE_GNAT_SPECIFIC(thistype) TYPE_MAIN_TYPE(thistype)->type_specific.gnat_stuff
> #define TYPE_DESCRIPTIVE_TYPE(thistype) TYPE_GNAT_SPECIFIC(thistype)->descriptive_type
> @@ -1521,6 +1536,8 @@ extern void set_type_vptr_basetype (struct type *, struct type *);
> #define TYPE_FN_FIELD_VOFFSET(thisfn, n) ((thisfn)[n].voffset-2)
> #define TYPE_FN_FIELD_VIRTUAL_P(thisfn, n) ((thisfn)[n].voffset > 1)
> #define TYPE_FN_FIELD_STATIC_P(thisfn, n) ((thisfn)[n].voffset == VOFFSET_STATIC)
> +#define TYPE_FN_FIELD_DEFAULTED(thisfn, n) ((thisfn)[n].defaulted)
> +#define TYPE_FN_FIELD_DELETED(thisfn, n) ((thisfn)[n].is_deleted)
>
> /* Accessors for typedefs defined by a class. */
> #define TYPE_TYPEDEF_FIELD_ARRAY(thistype) \
> --
> 2.21.0
>
^ permalink raw reply [flat|nested] 19+ messages in thread
* RE: [PATCH 0/8] Fix inferior call for C++ pass-by-reference arguments
2019-04-23 14:32 [PATCH 0/8] Fix inferior call for C++ pass-by-reference arguments Tankut Baris Aktemur
` (7 preceding siblings ...)
2019-04-23 14:33 ` [PATCH 8/8] testsuite, cp: increase the coverage of testing pass-by-ref arguments Tankut Baris Aktemur
@ 2019-05-08 10:50 ` Aktemur, Tankut Baris
2019-05-21 10:33 ` [PING][PATCH " Tankut Baris Aktemur
9 siblings, 0 replies; 19+ messages in thread
From: Aktemur, Tankut Baris @ 2019-05-08 10:50 UTC (permalink / raw)
To: gdb-patches
> Subject: [PATCH 0/8] Fix inferior call for C++ pass-by-reference arguments
>
> Dear All,
>
> This is a set of patches to fix GDB's conformance to C++ ABI when
> invoking functions that have call-by-value arguments of aggregate
> types that should be implicitly passed by reference.
Hello,
I'd like to ping the review request for this patch, available also at
https://sourceware.org/ml/gdb-patches/2019-04/msg00461.html
So far, Patch 1/8 received a review (thank you, Andrew Burgess).
Regards,
-Baris
> To give some background information first, suppose we have a class 'K'
> and a function 'cbv' that has a call-by-value parameter of type 'K'.
>
> class K {
> public:
> K (const K &other) { ... }
> ~K (void) { ... }
> ...
> };
>
> int
> cbv (K k)
> {
> ... use k ...
> }
>
> int
> main (void)
> {
> K q1;
> ...
> cbv (q1);
> ...
> }
>
> When making a function call such as 'cbv(q1)', the caller needs to
> create a (temporary) copy of the argument 'q1', say 'q2', and pass
> 'q2' to 'cbv' as the argument. After the function call returns, the
> caller can discard 'q2'. However, because the type 'K' has a
> user-defined constructor and destructor, the caller cannot simply copy
> the contents of 'q1' to 'q2'; it has to initialize 'q2' via the copy
> constructor. Similarly, 'q2' has to be destroyed by invoking the
> user-defined destructor. For this reason, according to the C++ ABI,
> the caller first allocates a space for 'q2', initializes it using the
> copy constructor, and then passes the *address* of 'q2' to 'cbv'. The
> caller uses the same address to destruct 'q2' after the function call
> is complete. Although 'k' is declared as a call-by-value parameter,
> it is implicitly *pass-by-reference*.
>
> Had the type 'K' not have a user-defined copy constructor or a
> destructor, the caller could have cloned 'q1' to 'q2' by a
> straightforward memory copying operation. Such types are trivially
> copyable. In that case, 'K' would be a *pass-by-value* type.
>
> Present-day GDB has problems regarding pass-by-reference arguments
> when making inferior calls. In particular:
>
> - Relatively new DWARF attributes are not used for inferring whether
> a type is pass-by-reference or not. This leads to incorrect
> deductions and, in return, crashing inferior calls.
>
> - For a pass-by-reference argument, a copy of the argument is not
> made; the address of the argument itself is passed to the callee.
> Hence, no copy-constructor call or a destructor call takes place,
> as well.
>
> The proposed patch aims to fix these problems. Tested on the X86_64
> architecture with GCC 7.4.0 and 8.2.0. ChangeLog entries will be
> included in the patch when/if the patch is accepted.
>
> Best regards.
>
>
> Tankut Baris Aktemur (8):
> gdb: recognize new DWARF attributes: defaulted, deleted, calling conv.
> infcall, c++: allow more info to be computed for pass-by-reference
> values
> infcall, c++: collect more pass-by-reference information
> infcall: refactor 'call_function_by_hand_dummy'
> infcall: move assertions in 'call_function_by_hand_dummy' to an
> earlier spot
> infcall: remove unused parameter in 'value_arg_coerce'
> infcall: handle pass-by-reference arguments appropriately
> testsuite, cp: increase the coverage of testing pass-by-ref arguments
>
> gdb/arch-utils.c | 2 +-
> gdb/cp-abi.c | 6 +-
> gdb/cp-abi.h | 10 +-
> gdb/dwarf2read.c | 20 +
> gdb/gdbtypes.c | 7 +
> gdb/gdbtypes.h | 19 +-
> gdb/gnu-v3-abi.c | 268 +-
> gdb/infcall.c | 213 +-
> gdb/language.c | 27 +-
> gdb/language.h | 55 +-
> gdb/testsuite/gdb.cp/pass-by-ref-2.cc | 179 +
> gdb/testsuite/gdb.cp/pass-by-ref-2.exp | 85 +
> gdb/testsuite/gdb.cp/pass-by-ref.cc | 7368 +++++++++++++++++++++++-
> gdb/testsuite/gdb.cp/pass-by-ref.exp | 412 +-
> gdb/tic6x-tdep.c | 2 +-
> 15 files changed, 8514 insertions(+), 159 deletions(-)
> create mode 100644 gdb/testsuite/gdb.cp/pass-by-ref-2.cc
> create mode 100644 gdb/testsuite/gdb.cp/pass-by-ref-2.exp
>
> --
> 2.21.0
Intel Deutschland GmbH
Registered Address: Am Campeon 10-12, 85579 Neubiberg, Germany
Tel: +49 89 99 8853-0, www.intel.de
Managing Directors: Christin Eisenschmid, Gary Kershaw
Chairperson of the Supervisory Board: Nicole Lau
Registered Office: Munich
Commercial Register: Amtsgericht Muenchen HRB 186928
^ permalink raw reply [flat|nested] 19+ messages in thread
* [PING][PATCH 0/8] Fix inferior call for C++ pass-by-reference arguments
2019-04-23 14:32 [PATCH 0/8] Fix inferior call for C++ pass-by-reference arguments Tankut Baris Aktemur
` (8 preceding siblings ...)
2019-05-08 10:50 ` [PATCH 0/8] Fix inferior call for C++ pass-by-reference arguments Aktemur, Tankut Baris
@ 2019-05-21 10:33 ` Tankut Baris Aktemur
9 siblings, 0 replies; 19+ messages in thread
From: Tankut Baris Aktemur @ 2019-05-21 10:33 UTC (permalink / raw)
To: gdb-patches
On 23-04-19 16:31, Tankut Baris Aktemur wrote:
> Dear All,
>
> This is a set of patches to fix GDB's conformance to C++ ABI when
> invoking functions that have call-by-value arguments of aggregate
> types that should be implicitly passed by reference.
Hello,
I'd like to ping the review request for this patch, available also at
https://sourceware.org/ml/gdb-patches/2019-04/msg00461.html
Regards,
-Baris
> To give some background information first, suppose we have a class 'K'
> and a function 'cbv' that has a call-by-value parameter of type 'K'.
>
> class K {
> public:
> K (const K &other) { ... }
> ~K (void) { ... }
> ...
> };
>
> int
> cbv (K k)
> {
> ... use k ...
> }
>
> int
> main (void)
> {
> K q1;
> ...
> cbv (q1);
> ...
> }
>
> When making a function call such as 'cbv(q1)', the caller needs to
> create a (temporary) copy of the argument 'q1', say 'q2', and pass
> 'q2' to 'cbv' as the argument. After the function call returns, the
> caller can discard 'q2'. However, because the type 'K' has a
> user-defined constructor and destructor, the caller cannot simply copy
> the contents of 'q1' to 'q2'; it has to initialize 'q2' via the copy
> constructor. Similarly, 'q2' has to be destroyed by invoking the
> user-defined destructor. For this reason, according to the C++ ABI,
> the caller first allocates a space for 'q2', initializes it using the
> copy constructor, and then passes the *address* of 'q2' to 'cbv'. The
> caller uses the same address to destruct 'q2' after the function call
> is complete. Although 'k' is declared as a call-by-value parameter,
> it is implicitly *pass-by-reference*.
>
> Had the type 'K' not have a user-defined copy constructor or a
> destructor, the caller could have cloned 'q1' to 'q2' by a
> straightforward memory copying operation. Such types are trivially
> copyable. In that case, 'K' would be a *pass-by-value* type.
>
> Present-day GDB has problems regarding pass-by-reference arguments
> when making inferior calls. In particular:
>
> - Relatively new DWARF attributes are not used for inferring whether
> a type is pass-by-reference or not. This leads to incorrect
> deductions and, in return, crashing inferior calls.
>
> - For a pass-by-reference argument, a copy of the argument is not
> made; the address of the argument itself is passed to the callee.
> Hence, no copy-constructor call or a destructor call takes place,
> as well.
>
> The proposed patch aims to fix these problems. Tested on the X86_64
> architecture with GCC 7.4.0 and 8.2.0. ChangeLog entries will be
> included in the patch when/if the patch is accepted.
>
> Best regards.
>
>
> Tankut Baris Aktemur (8):
> gdb: recognize new DWARF attributes: defaulted, deleted, calling conv.
> infcall, c++: allow more info to be computed for pass-by-reference
> values
> infcall, c++: collect more pass-by-reference information
> infcall: refactor 'call_function_by_hand_dummy'
> infcall: move assertions in 'call_function_by_hand_dummy' to an
> earlier spot
> infcall: remove unused parameter in 'value_arg_coerce'
> infcall: handle pass-by-reference arguments appropriately
> testsuite, cp: increase the coverage of testing pass-by-ref arguments
>
> gdb/arch-utils.c | 2 +-
> gdb/cp-abi.c | 6 +-
> gdb/cp-abi.h | 10 +-
> gdb/dwarf2read.c | 20 +
> gdb/gdbtypes.c | 7 +
> gdb/gdbtypes.h | 19 +-
> gdb/gnu-v3-abi.c | 268 +-
> gdb/infcall.c | 213 +-
> gdb/language.c | 27 +-
> gdb/language.h | 55 +-
> gdb/testsuite/gdb.cp/pass-by-ref-2.cc | 179 +
> gdb/testsuite/gdb.cp/pass-by-ref-2.exp | 85 +
> gdb/testsuite/gdb.cp/pass-by-ref.cc | 7368 +++++++++++++++++++++++-
> gdb/testsuite/gdb.cp/pass-by-ref.exp | 412 +-
> gdb/tic6x-tdep.c | 2 +-
> 15 files changed, 8514 insertions(+), 159 deletions(-)
> create mode 100644 gdb/testsuite/gdb.cp/pass-by-ref-2.cc
> create mode 100644 gdb/testsuite/gdb.cp/pass-by-ref-2.exp
>
> --
> 2.21.0
>
^ permalink raw reply [flat|nested] 19+ messages in thread
* Re: [PATCH 2/8] infcall, c++: allow more info to be computed for pass-by-reference values
2019-04-23 14:32 ` [PATCH 2/8] infcall, c++: allow more info to be computed for pass-by-reference values Tankut Baris Aktemur
@ 2019-05-22 20:17 ` Andrew Burgess
2019-05-31 13:53 ` Aktemur, Tankut Baris
0 siblings, 1 reply; 19+ messages in thread
From: Andrew Burgess @ 2019-05-22 20:17 UTC (permalink / raw)
To: Tankut Baris Aktemur; +Cc: gdb-patches
* Tankut Baris Aktemur <tankut.baris.aktemur@intel.com> [2019-04-23 16:31:48 +0200]:
> In C++, call-by-value arguments that cannot be trivially copied are
> implicitly passed by reference. When making an infcall, GDB needs to
> find out if an argument is pass-by-reference or not, so that the correct
> semantics can be followed. This patch enriches the information computed
> by the language ops for pass-by-reference arguments. Instead of a plain
> binary result, the computed information now includes whether the
> argument is
> - copy constructible
> - destructible
> - trivially copyable
> - trivially copy constructible
> - trivially destructible
> and also
> - the full name of the copy constructor
> - the full name of the destructor
> in preparation for GDB's infcall mechanism to call the copy ctor and
> the destructor of a pass-by-ref argument appropriately. This
> information is stored in a struct named 'language_pass_by_ref_info'.
>
> gdb/ChangeLog:
>
> * language.h (struct language_pass_by_ref_info): New struct.
> (struct language_defn)<la_pass_by_reference>: Change the signature
> to return a language_pass_by_ref_info instead of an int.
> (language_pass_by_reference): Ditto.
> (default_pass_by_reference): Ditto.
> Adjust the users listed below.
> * arch-utils.c (default_return_in_first_hidden_param_p):
> Update.
> * cp-abi.c (cp_pass_by_reference): Update.
> * cp-abi.h (struct cp_abi_ops)<pass_by_reference>: Update.
> * gnu-v3-abi.c (gnuv3_pass_by_reference): Update.
> * infcall.c (call_function_by_hand_dummy): Update.
> * language.c (language_pass_by_reference): Update.
> (default_pass_by_reference): Update.
> * tic6x-tdep.c (tic6x_return_value): Update.
I have a little feedback given below, but otherwise this looks fine.
>
> ---
> gdb/arch-utils.c | 2 +-
> gdb/cp-abi.c | 6 ++++--
> gdb/cp-abi.h | 10 +++++----
> gdb/gnu-v3-abi.c | 49 ++++++++++++++++++++++++++++++------------
> gdb/infcall.c | 3 ++-
> gdb/language.c | 27 +++++++++++++++++-------
> gdb/language.h | 55 +++++++++++++++++++++++++++++++++++++++---------
> gdb/tic6x-tdep.c | 2 +-
> 8 files changed, 114 insertions(+), 40 deletions(-)
>
> diff --git a/gdb/arch-utils.c b/gdb/arch-utils.c
> index 43f5834b383..5ccabde45e3 100644
> --- a/gdb/arch-utils.c
> +++ b/gdb/arch-utils.c
> @@ -858,7 +858,7 @@ default_return_in_first_hidden_param_p (struct gdbarch *gdbarch,
> /* Usually, the return value's address is stored the in the "first hidden"
> parameter if the return value should be passed by reference, as
> specified in ABI. */
> - return language_pass_by_reference (type);
> + return !(language_pass_by_reference (type).trivially_copyable);
> }
>
> int default_insn_is_call (struct gdbarch *gdbarch, CORE_ADDR addr)
> diff --git a/gdb/cp-abi.c b/gdb/cp-abi.c
> index bbb74d42638..6503b4c160b 100644
> --- a/gdb/cp-abi.c
> +++ b/gdb/cp-abi.c
> @@ -220,11 +220,13 @@ cplus_typename_from_type_info (struct value *value)
> return (*current_cp_abi.get_typename_from_type_info) (value);
> }
>
> -int
> +/* See cp-abi.h. */
> +
> +struct language_pass_by_ref_info
> cp_pass_by_reference (struct type *type)
> {
> if ((current_cp_abi.pass_by_reference) == NULL)
> - return 0;
> + return default_pass_by_reference (type);
> return (*current_cp_abi.pass_by_reference) (type);
> }
>
> diff --git a/gdb/cp-abi.h b/gdb/cp-abi.h
> index 3cbf19cd511..0afba77aeb1 100644
> --- a/gdb/cp-abi.h
> +++ b/gdb/cp-abi.h
> @@ -207,9 +207,11 @@ extern std::string cplus_typename_from_type_info (struct value *value);
> CORE_ADDR cplus_skip_trampoline (struct frame_info *frame,
> CORE_ADDR stop_pc);
>
> -/* Return non-zero if an argument of type TYPE should be passed by
> - reference instead of value. */
> -extern int cp_pass_by_reference (struct type *type);
> +/* Fill in INFO with information about whether TYPE should be
> + passed (and returned) by reference at the language level. */
> +
> +extern struct language_pass_by_ref_info cp_pass_by_reference
> + (struct type *type);
>
> struct cp_abi_ops
> {
> @@ -246,7 +248,7 @@ struct cp_abi_ops
> struct type *(*get_type_from_type_info) (struct value *value);
> std::string (*get_typename_from_type_info) (struct value *value);
> CORE_ADDR (*skip_trampoline) (struct frame_info *, CORE_ADDR);
> - int (*pass_by_reference) (struct type *type);
> + struct language_pass_by_ref_info (*pass_by_reference) (struct type *type);
> };
>
>
> diff --git a/gdb/gnu-v3-abi.c b/gdb/gnu-v3-abi.c
> index 6407c9beb82..b39e5a5c585 100644
> --- a/gdb/gnu-v3-abi.c
> +++ b/gdb/gnu-v3-abi.c
> @@ -1228,7 +1228,7 @@ gnuv3_skip_trampoline (struct frame_info *frame, CORE_ADDR stop_pc)
> return real_stop_pc;
> }
>
> -/* Return nonzero if a type should be passed by reference.
> +/* Return pass-by-reference information for the given TYPE.
>
> The rule in the v3 ABI document comes from section 3.1.1. If the
> type has a non-trivial copy constructor or destructor, then the
> @@ -1246,22 +1246,33 @@ gnuv3_skip_trampoline (struct frame_info *frame, CORE_ADDR stop_pc)
>
> We don't do anything with the constructors or destructors,
> but we have to get the argument passing right anyway. */
> -static int
> +
> +static struct language_pass_by_ref_info
> gnuv3_pass_by_reference (struct type *type)
> {
> int fieldnum, fieldelem;
>
> type = check_typedef (type);
>
> + /* Start with the default values. */
> + struct language_pass_by_ref_info info
> + = default_pass_by_reference (type);
> +
> + /* FIXME: Currently, this implementation only fills in the
> + 'trivially-copyable' field. */
> +
> /* We're only interested in things that can have methods. */
> if (TYPE_CODE (type) != TYPE_CODE_STRUCT
> && TYPE_CODE (type) != TYPE_CODE_UNION)
> - return 0;
> + return info;
>
> /* A dynamic class has a non-trivial copy constructor.
> See c++98 section 12.8 Copying class objects [class.copy]. */
> if (gnuv3_dynamic_class (type))
> - return 1;
> + {
> + info.trivially_copyable = false;
> + return info;
> + }
>
> for (fieldnum = 0; fieldnum < TYPE_NFN_FIELDS (type); fieldnum++)
> for (fieldelem = 0; fieldelem < TYPE_FN_FIELDLIST_LENGTH (type, fieldnum);
> @@ -1278,7 +1289,10 @@ gnuv3_pass_by_reference (struct type *type)
>
> /* If we've found a destructor, we must pass this by reference. */
> if (name[0] == '~')
> - return 1;
> + {
> + info.trivially_copyable = false;
> + return info;
> + }
>
> /* If the mangled name of this method doesn't indicate that it
> is a constructor, we're not interested.
> @@ -1300,11 +1314,13 @@ gnuv3_pass_by_reference (struct type *type)
>
> if (TYPE_CODE (arg_type) == TYPE_CODE_REF)
> {
> - struct type *arg_target_type;
> -
> - arg_target_type = check_typedef (TYPE_TARGET_TYPE (arg_type));
> + struct type *arg_target_type
> + = check_typedef (TYPE_TARGET_TYPE (arg_type));
> if (class_types_same_p (arg_target_type, type))
> - return 1;
> + {
> + info.trivially_copyable = false;
> + return info;
> + }
> }
> }
> }
> @@ -1317,11 +1333,18 @@ gnuv3_pass_by_reference (struct type *type)
> about recursive loops here, since we are only looking at members
> of complete class type. Also ignore any static members. */
> for (fieldnum = 0; fieldnum < TYPE_NFIELDS (type); fieldnum++)
> - if (! field_is_static (&TYPE_FIELD (type, fieldnum))
> - && gnuv3_pass_by_reference (TYPE_FIELD_TYPE (type, fieldnum)))
> - return 1;
> + if (!field_is_static (&TYPE_FIELD (type, fieldnum)))
> + {
> + struct language_pass_by_ref_info field_info
> + = gnuv3_pass_by_reference (TYPE_FIELD_TYPE (type, fieldnum));
> + if (!field_info.trivially_copyable)
> + {
> + info.trivially_copyable = false;
> + return info;
> + }
> + }
>
> - return 0;
> + return info;
> }
>
> static void
> diff --git a/gdb/infcall.c b/gdb/infcall.c
> index c102b301e00..058871c369b 100644
> --- a/gdb/infcall.c
> +++ b/gdb/infcall.c
> @@ -970,7 +970,8 @@ call_function_by_hand_dummy (struct value *function,
> args[i] = value_arg_coerce (gdbarch, args[i],
> param_type, prototyped, &sp);
>
> - if (param_type != NULL && language_pass_by_reference (param_type))
> + if (param_type != NULL
> + && !(language_pass_by_reference (param_type).trivially_copyable))
> args[i] = value_addr (args[i]);
> }
>
> diff --git a/gdb/language.c b/gdb/language.c
> index 954e4c200f0..09ed44e1803 100644
> --- a/gdb/language.c
> +++ b/gdb/language.c
> @@ -650,21 +650,32 @@ language_class_name_from_physname (const struct language_defn *lang,
> return NULL;
> }
>
> -/* Return non-zero if TYPE should be passed (and returned) by
> - reference at the language level. */
> -int
> +/* Return information about whether TYPE should be passed
> + (and returned) by reference at the language level. */
> +
> +struct language_pass_by_ref_info
> language_pass_by_reference (struct type *type)
> {
> return current_language->la_pass_by_reference (type);
> }
>
> -/* Return zero; by default, types are passed by value at the language
> - level. The target ABI may pass or return some structs by reference
> - independent of this. */
> -int
> +/* Return INFO whose 'trivially_copyable' is set to true; by default,
> + types are passed by value at the language level. The target ABI may
> + pass or return some structs by reference independent of this. */
> +
This comment mentions how 'trivially_copyable' is initialised, but
doesn't really explain any of the other defaults.
Maybe the default field values should be moved out of this function
and into 'struct language_pass_by_reference', and this comment should
just explain that this returns a default struct and languages should
update it as appropriate.
> +struct language_pass_by_ref_info
> default_pass_by_reference (struct type *type)
> {
> - return 0;
> + struct language_pass_by_ref_info info;
> + info.copy_constructible = true;
> + info.destructible = true;
> + info.trivially_copyable = true;
> + info.trivially_copy_constructible = true;
> + info.trivially_destructible = true;
> + info.cctor_name = NULL;
> + info.dtor_name = NULL;
> +
> + return info;
> }
>
> /* Return the default string containing the list of characters
> diff --git a/gdb/language.h b/gdb/language.h
> index 3e0bc9d0d46..40d63dfe8a2 100644
> --- a/gdb/language.h
> +++ b/gdb/language.h
> @@ -128,6 +128,40 @@ struct language_arch_info
> struct type *bool_type_default;
> };
>
> +/* Pass-by-reference information for a call-by-value argument. */
> +
> +struct language_pass_by_ref_info
> +{
> + /* Name of the copy ctor function. Expected to be fully-qualified. */
> +
> + const char *cctor_name;
I think the blank lines are not needed between the comments and the
fields, see:
https://sourceware.org/gdb/wiki/Internals%20GDB-C-Coding-Standards#Document_every_global.2BAC8-static_entity
> +
> + /* Name of the destructor function. Expected to be fully-qualified. */
> +
> + const char *dtor_name;
> +
> + /* Is the type of the argument in question copy-constructible? */
> +
> + bool copy_constructible;
This comment doesn't seem very helpful. Could you expand on what true
or false value would mean here? I have the same question about all of
the fields below.
Also I think it might be worth inlining the default value here rather
than in 'default_pass_by_reference', so:
bool copy_constructible = true;
then you can extend the comment to explain why that default was
selected. I think doing this for all the fields in this struct would
be a good change.
> +
> + /* Is the type of the argument in question destructible? */
> +
> + bool destructible;
> +
> + /* Is the argument in question trivially copyable?
> + That is, is it pass-by-value? */
> +
> + bool trivially_copyable;
> +
> + /* Is the argument in question trivially copy constructible? */
> +
> + bool trivially_copy_constructible;
> +
> + /* Is the argument in question trivially destructible? */
> +
> + bool trivially_destructible;
> +};
> +
> /* Structure tying together assorted information about a language. */
>
> struct language_defn
> @@ -356,9 +390,10 @@ struct language_defn
> struct ui_file *stream,
> const struct value_print_options *options);
>
> - /* Return non-zero if TYPE should be passed (and returned) by
> - reference at the language level. */
> - int (*la_pass_by_reference) (struct type *type);
> + /* Return information about whether TYPE should be passed
> + (and returned) by reference at the language level. */
> + struct language_pass_by_ref_info (*la_pass_by_reference)
> + (struct type *type);
>
> /* Obtain a string from the inferior, storing it in a newly allocated
> buffer in BUFFER, which should be freed by the caller. If the
> @@ -612,14 +647,14 @@ extern void default_print_array_index (struct value *index_value,
> struct ui_file *stream,
> const struct value_print_options *options);
>
> -/* Return non-zero if TYPE should be passed (and returned) by
> - reference at the language level. */
> -int language_pass_by_reference (struct type *type);
> +/* Return information about whether TYPE should be passed
> + (and returned) by reference at the language level. */
> +struct language_pass_by_ref_info language_pass_by_reference (struct type *type);
>
> -/* Return zero; by default, types are passed by value at the language
> - level. The target ABI may pass or return some structs by reference
> - independent of this. */
> -int default_pass_by_reference (struct type *type);
> +/* Return INFO whose 'trivially_copyable' is set to true; by default,
> + types are passed by value at the language level. The target ABI may
> + pass or return some structs by reference independent of this. */
> +struct language_pass_by_ref_info default_pass_by_reference (struct type *type);
>
> /* The default implementation of la_print_typedef. */
> void default_print_typedef (struct type *type, struct symbol *new_symbol,
> diff --git a/gdb/tic6x-tdep.c b/gdb/tic6x-tdep.c
> index 61dc676de3b..73149f492f5 100644
> --- a/gdb/tic6x-tdep.c
> +++ b/gdb/tic6x-tdep.c
> @@ -793,7 +793,7 @@ tic6x_return_value (struct gdbarch *gdbarch, struct value *function,
> if (type != NULL)
> {
> type = check_typedef (type);
> - if (language_pass_by_reference (type))
> + if (!(language_pass_by_reference (type).trivially_copyable))
> return RETURN_VALUE_STRUCT_CONVENTION;
> }
> }
> --
> 2.21.0
>
Thanks,
Andrew
^ permalink raw reply [flat|nested] 19+ messages in thread
* Re: [PATCH 3/8] infcall, c++: collect more pass-by-reference information
2019-04-23 14:32 ` [PATCH 3/8] infcall, c++: collect more pass-by-reference information Tankut Baris Aktemur
@ 2019-05-22 20:34 ` Andrew Burgess
2019-05-31 13:56 ` Aktemur, Tankut Baris
0 siblings, 1 reply; 19+ messages in thread
From: Andrew Burgess @ 2019-05-22 20:34 UTC (permalink / raw)
To: Tankut Baris Aktemur; +Cc: gdb-patches
* Tankut Baris Aktemur <tankut.baris.aktemur@intel.com> [2019-04-23 16:31:49 +0200]:
> Walk through a given type to collect information about whether the type
> is copy constructible, destructible, trivially copyable, trivially copy
> constructible, trivially destructible. The previous algorithm returned
> only a boolean result about whether the type is trivially copyable.
> This patch computes more info. Additionally, it utilizes DWARF attributes
> that were previously not taken into account; namely,
> DW_AT_deleted, DW_AT_defaulted, and DW_AT_calling_convention.
>
> gdb/ChangeLog:
>
> * gnu-v3-abi.c (enum definition_style): New.
> (get_def_style): New.
> (is_user_provided_def): New.
> (is_implicit_def): New.
> (is_copy_or_move_constructor_type): New.
> (is_copy_constructor_type): New.
> (is_move_constructor_type): New.
> (gnuv3_pass_by_reference): Update.
I'm basically happy with this, a few formatting issues and questions
about comments below.
>
> ---
> gdb/gnu-v3-abi.c | 259 +++++++++++++++++++++++++++++++++++++----------
> 1 file changed, 208 insertions(+), 51 deletions(-)
>
> diff --git a/gdb/gnu-v3-abi.c b/gdb/gnu-v3-abi.c
> index b39e5a5c585..9069305626f 100644
> --- a/gdb/gnu-v3-abi.c
> +++ b/gdb/gnu-v3-abi.c
> @@ -23,6 +23,7 @@
> #include "cp-abi.h"
> #include "cp-support.h"
> #include "demangle.h"
> +#include "dwarf2.h"
> #include "objfiles.h"
> #include "valprint.h"
> #include "c-lang.h"
> @@ -1228,6 +1229,122 @@ gnuv3_skip_trampoline (struct frame_info *frame, CORE_ADDR stop_pc)
> return real_stop_pc;
> }
>
> +/* A member function is in one these states. */
> +
> +enum definition_style
> +{
> + DOES_NOT_EXIST_IN_SOURCE,
> + DEFAULTED_INSIDE,
> + DEFAULTED_OUTSIDE,
> + DELETED,
> + EXPLICIT,
> +};
> +
> +/* Return how the given field is defined. */
> +
> +static definition_style
> +get_def_style (struct fn_field *fn, int fieldelem)
> +{
> + if (TYPE_FN_FIELD_DELETED (fn, fieldelem))
> + return DELETED;
> +
> + if (TYPE_FN_FIELD_ARTIFICIAL (fn, fieldelem))
> + return DOES_NOT_EXIST_IN_SOURCE;
> +
> + switch (TYPE_FN_FIELD_DEFAULTED (fn, fieldelem))
> + {
> + case DW_DEFAULTED_no:
> + return EXPLICIT;
> + case DW_DEFAULTED_in_class:
> + return DEFAULTED_INSIDE;
> + case DW_DEFAULTED_out_of_class:
> + return DEFAULTED_OUTSIDE;
> + default:
> + break;
> + }
> +
> + return EXPLICIT;
> +}
> +
> +/* Helper functions to determine whether the given definition style
> + denotes that the definition is user-provided or implicit.
> + Being defaulted outside the class decl counts as an explicit
> + user-definition, while being defaulted inside is implicit. */
> +
> +static bool
> +is_user_provided_def (definition_style def)
> +{
> + return def == EXPLICIT || def == DEFAULTED_OUTSIDE;
> +}
> +
> +static bool
> +is_implicit_def (definition_style def)
> +{
> + return def == DOES_NOT_EXIST_IN_SOURCE || def == DEFAULTED_INSIDE;
> +}
> +
> +/* Helper function to decide if METHOD_TYPE is a copy/move
> + constructor type for CLASS_TYPE. EXPECTED is the expected
> + type code for the "right-hand-side" argument.
> + This function is supposed to be used by the IS_COPY_CONSTRUCTOR_TYPE
> + and IS_MOVE_CONSTRUCTOR_TYPE functions below. Normally, you should
> + not need to call this directly. */
> +
> +static bool
> +is_copy_or_move_constructor_type (struct type *class_type,
> + struct type *method_type,
> + type_code expected)
> +{
> + /* The method should take at least two arguments... */
> + if (TYPE_NFIELDS (method_type) < 2)
> + return false;
> +
> + /* ...and the second argument should be the same as the class
> + type, with the expected type code... */
> + struct type *arg_type = TYPE_FIELD_TYPE (method_type, 1);
> +
> + if (TYPE_CODE (arg_type) != expected)
> + return false;
> +
> + struct type *target = check_typedef (TYPE_TARGET_TYPE (arg_type));
> + if (!(class_types_same_p (target, class_type)))
> + return false;
> +
> + /* ...and the rest of the arguments should have default values. */
This comment threw me for a while I read this to mean that I couldn't
legally write something like:
struct A
{
int a;
A (const A &other, int arg);
};
which is daft, because obviously I can. Then I realised that that
isn't a copy constructor, it's just a constructor that takes an 'A&',
doh!
But, I wonder if the comment could be made clearer to help those of us
a bit slower on the uptake, maybe something like:
/* ...and if any of the remaining arguments don't have a default value
then this is not a copy or move constructor, but just a constructor. */
> + for (int i = 2; i < TYPE_NFIELDS (method_type); i++)
> + {
> + arg_type = TYPE_FIELD_TYPE (method_type, i);
> + /* FIXME taktemur/2019-04-23: As of this date, neither
> + clang++-7.0.0 nor g++-8.2.0 produce a DW_AT_default_value
> + attribute. GDB is also not set to read this attribute, yet.
> + Hence, we immediately return false if there are more than
> + 2 parameters. */
> + return false;
> + }
> +
> + return true;
> +}
> +
> +/* Return true if METHOD_TYPE is a copy ctor type for CLASS_TYPE. */
> +
> +static bool
> +is_copy_constructor_type (struct type *class_type,
> + struct type *method_type)
> +{
> + return is_copy_or_move_constructor_type (class_type, method_type,
> + TYPE_CODE_REF);
> +}
> +
> +/* Return true if METHOD_TYPE is a move ctor type for CLASS_TYPE. */
> +
> +static bool
> +is_move_constructor_type (struct type *class_type,
> + struct type *method_type)
> +{
> + return is_copy_or_move_constructor_type (class_type, method_type,
> + TYPE_CODE_RVALUE_REF);
> +}
> +
> /* Return pass-by-reference information for the given TYPE.
>
> The rule in the v3 ABI document comes from section 3.1.1. If the
> @@ -1236,16 +1353,15 @@ gnuv3_skip_trampoline (struct frame_info *frame, CORE_ADDR stop_pc)
> is one or perform the copy itself otherwise), pass the address of
> the copy, and then destroy the temporary (if necessary).
>
> - For return values with non-trivial copy constructors or
> + For return values with non-trivial copy/move constructors or
> destructors, space will be allocated in the caller, and a pointer
> will be passed as the first argument (preceding "this").
>
> We don't have a bulletproof mechanism for determining whether a
> - constructor or destructor is trivial. For GCC and DWARF2 debug
> - information, we can check the artificial flag.
> -
> - We don't do anything with the constructors or destructors,
> - but we have to get the argument passing right anyway. */
> + constructor or destructor is trivial. For GCC and DWARF5 debug
> + information, we can check the calling_convention attribute,
> + the 'artificial' flag, the 'defaulted' attribute, and the
> + 'deleted' attribute. */
>
> static struct language_pass_by_ref_info
> gnuv3_pass_by_reference (struct type *type)
> @@ -1258,22 +1374,39 @@ gnuv3_pass_by_reference (struct type *type)
> struct language_pass_by_ref_info info
> = default_pass_by_reference (type);
>
> - /* FIXME: Currently, this implementation only fills in the
> - 'trivially-copyable' field. */
> + bool has_cc_attr = false;
> + bool is_pass_by_value = false;
> + bool is_dynamic = false;
> + definition_style cctor_def = DOES_NOT_EXIST_IN_SOURCE;
> + definition_style dtor_def = DOES_NOT_EXIST_IN_SOURCE;
> + definition_style mctor_def = DOES_NOT_EXIST_IN_SOURCE;
>
> /* We're only interested in things that can have methods. */
> if (TYPE_CODE (type) != TYPE_CODE_STRUCT
> && TYPE_CODE (type) != TYPE_CODE_UNION)
> return info;
>
> + /* The compiler may have emitted the calling convention attribute. */
> + if (TYPE_CPLUS_CALLING_CONVENTION (type) == DW_CC_pass_by_value)
> + {
> + has_cc_attr = true;
> + is_pass_by_value = true;
> + /* Do not return immediately. We have to find out if this type
> + is copy_constructible and destructible. */
> + }
> +
> + if (TYPE_CPLUS_CALLING_CONVENTION (type) == DW_CC_pass_by_reference)
> + {
> + has_cc_attr = true;
> + is_pass_by_value = false;
> + }
> +
> /* A dynamic class has a non-trivial copy constructor.
> See c++98 section 12.8 Copying class objects [class.copy]. */
> if (gnuv3_dynamic_class (type))
> - {
> - info.trivially_copyable = false;
> - return info;
> - }
> + is_dynamic = true;
>
> + /* FIXME taktemur/2019-04-23: What if there are multiple cctors? */
Can such a situation arise? If you know how it could but don't know
how to handle it then can we expand the comment. If you don't think
such a situation could arise then lets delete this comment and add an
assertion below.
> for (fieldnum = 0; fieldnum < TYPE_NFN_FIELDS (type); fieldnum++)
> for (fieldelem = 0; fieldelem < TYPE_FN_FIELDLIST_LENGTH (type, fieldnum);
> fieldelem++)
> @@ -1282,49 +1415,53 @@ gnuv3_pass_by_reference (struct type *type)
> const char *name = TYPE_FN_FIELDLIST_NAME (type, fieldnum);
> struct type *fieldtype = TYPE_FN_FIELD_TYPE (fn, fieldelem);
>
> - /* If this function is marked as artificial, it is compiler-generated,
> - and we assume it is trivial. */
> - if (TYPE_FN_FIELD_ARTIFICIAL (fn, fieldelem))
> - continue;
> -
> - /* If we've found a destructor, we must pass this by reference. */
> if (name[0] == '~')
> {
> - info.trivially_copyable = false;
> - return info;
> + /* We've found a destructor. */
> + dtor_def = get_def_style (fn, fieldelem);
> + info.dtor_name = TYPE_FN_FIELD_PHYSNAME (fn, fieldelem);
Maybe we should have an error or at least a warning if
'info.dtor_name' is not nullptr before this assignment - this would
indicate multiple destructors, which seems weird, right?
> }
> -
> - /* If the mangled name of this method doesn't indicate that it
> - is a constructor, we're not interested.
> -
> - FIXME drow/2007-09-23: We could do this using the name of
> - the method and the name of the class instead of dealing
> - with the mangled name. We don't have a convenient function
> - to strip off both leading scope qualifiers and trailing
> - template arguments yet. */
> - if (!is_constructor_name (TYPE_FN_FIELD_PHYSNAME (fn, fieldelem))
> - && !TYPE_FN_FIELD_CONSTRUCTOR (fn, fieldelem))
> - continue;
> -
> - /* If this method takes two arguments, and the second argument is
> - a reference to this class, then it is a copy constructor. */
> - if (TYPE_NFIELDS (fieldtype) == 2)
> + else if (is_constructor_name (TYPE_FN_FIELD_PHYSNAME (fn, fieldelem))
> + || TYPE_FN_FIELD_CONSTRUCTOR (fn, fieldelem))
> {
> - struct type *arg_type = TYPE_FIELD_TYPE (fieldtype, 1);
> -
> - if (TYPE_CODE (arg_type) == TYPE_CODE_REF)
> + /* FIXME drow/2007-09-23: We could do this using the name of
> + the method and the name of the class instead of dealing
> + with the mangled name. We don't have a convenient function
> + to strip off both leading scope qualifiers and trailing
> + template arguments yet. */
> + if (is_copy_constructor_type (type, fieldtype))
> {
> - struct type *arg_target_type
> - = check_typedef (TYPE_TARGET_TYPE (arg_type));
> - if (class_types_same_p (arg_target_type, type))
> - {
> - info.trivially_copyable = false;
> - return info;
> - }
> + cctor_def = get_def_style (fn, fieldelem);
> + info.cctor_name = TYPE_FN_FIELD_PHYSNAME (fn, fieldelem);
This would be where we assert that we only have one cctor I think...
> }
> + else if (is_move_constructor_type (type, fieldtype))
> + mctor_def = get_def_style (fn, fieldelem);
> }
> }
>
> + bool cctor_implicitly_deleted
> + = mctor_def != DOES_NOT_EXIST_IN_SOURCE
> + && cctor_def == DOES_NOT_EXIST_IN_SOURCE;
I think this should be parenthesised like this:
bool cctor_implicitly_deleted
= (mctor_def != DOES_NOT_EXIST_IN_SOURCE
&& cctor_def == DOES_NOT_EXIST_IN_SOURCE);
My reference is:
https://www.gnu.org/prep/standards/standards.html#Formatting
> +
> + bool cctor_explicitly_deleted = cctor_def == DELETED;
> +
> + if (cctor_implicitly_deleted || cctor_explicitly_deleted)
> + info.copy_constructible = false;
> +
> + if (dtor_def == DELETED)
> + info.destructible = false;
> +
> + info.trivially_destructible = is_implicit_def (dtor_def);
> +
> + info.trivially_copy_constructible
> + = is_implicit_def (cctor_def)
> + && !is_dynamic;
Again extra ( ... ) needed I think.
> +
> + info.trivially_copyable
> + = info.trivially_copy_constructible
> + && info.trivially_destructible
> + && !is_user_provided_def (mctor_def);
And again.
> +
> /* Even if all the constructors and destructors were artificial, one
> of them may have invoked a non-artificial constructor or
> destructor in a base class. If any base class needs to be passed
> @@ -1335,15 +1472,35 @@ gnuv3_pass_by_reference (struct type *type)
> for (fieldnum = 0; fieldnum < TYPE_NFIELDS (type); fieldnum++)
> if (!field_is_static (&TYPE_FIELD (type, fieldnum)))
> {
> + struct type *field_type = TYPE_FIELD_TYPE (type, fieldnum);
> +
> + /* For arrays, make the decision based on the element type. */
> + if (TYPE_CODE (field_type) == TYPE_CODE_ARRAY)
> + field_type = field_type->main_type->target_type;
> +
> struct language_pass_by_ref_info field_info
> - = gnuv3_pass_by_reference (TYPE_FIELD_TYPE (type, fieldnum));
> + = gnuv3_pass_by_reference (field_type);
> +
> + if (!field_info.copy_constructible)
> + info.copy_constructible = false;
> + if (!field_info.destructible)
> + info.destructible = false;
> if (!field_info.trivially_copyable)
> - {
> - info.trivially_copyable = false;
> - return info;
> - }
> + info.trivially_copyable = false;
> + if (!field_info.trivially_copy_constructible)
> + info.trivially_copy_constructible = false;
> + if (!field_info.trivially_destructible)
> + info.trivially_destructible = false;
> }
>
> + /* Consistency check. */
> + if (has_cc_attr && info.trivially_copyable != is_pass_by_value)
> + {
> + /* DWARF CC attribute is not the same as the inferred value;
> + using the DWARF attribute. */
> + info.trivially_copyable = is_pass_by_value;
> + }
> +
> return info;
> }
>
> --
> 2.21.0
>
Thanks,
Andrew
^ permalink raw reply [flat|nested] 19+ messages in thread
* Re: [PATCH 2/8] infcall, c++: allow more info to be computed for pass-by-reference values
2019-05-22 20:17 ` Andrew Burgess
@ 2019-05-31 13:53 ` Aktemur, Tankut Baris
2019-06-23 19:06 ` Andrew Burgess
0 siblings, 1 reply; 19+ messages in thread
From: Aktemur, Tankut Baris @ 2019-05-31 13:53 UTC (permalink / raw)
To: Andrew Burgess; +Cc: gdb-patches
> > In C++, call-by-value arguments that cannot be trivially copied are
> > implicitly passed by reference. When making an infcall, GDB needs to
> > find out if an argument is pass-by-reference or not, so that the correct
> > semantics can be followed. This patch enriches the information computed
> > by the language ops for pass-by-reference arguments. Instead of a plain
> > binary result, the computed information now includes whether the
> > argument is
> > - copy constructible
> > - destructible
> > - trivially copyable
> > - trivially copy constructible
> > - trivially destructible
> > and also
> > - the full name of the copy constructor
> > - the full name of the destructor
> > in preparation for GDB's infcall mechanism to call the copy ctor and
> > the destructor of a pass-by-ref argument appropriately. This
> > information is stored in a struct named 'language_pass_by_ref_info'.
> >
>
> I have a little feedback given below, but otherwise this looks fine.
Thank you for your valuable feedback.
> > +
> > + /* Name of the destructor function. Expected to be fully-qualified. */
> > +
> > + const char *dtor_name;
> > +
> > + /* Is the type of the argument in question copy-constructible? */
> > +
> > + bool copy_constructible;
>
> This comment doesn't seem very helpful. Could you expand on what true
> or false value would mean here? I have the same question about all of
> the fields below.
>
> Also I think it might be worth inlining the default value here rather
> than in 'default_pass_by_reference', so:
>
> bool copy_constructible = true;
>
> then you can extend the comment to explain why that default was
> selected. I think doing this for all the fields in this struct would
> be a good change.
>
> > +
> > + /* Is the type of the argument in question destructible? */
> > +
> > + bool destructible;
> > +
> > + /* Is the argument in question trivially copyable?
> > + That is, is it pass-by-value? */
> > +
> > + bool trivially_copyable;
> > +
> > + /* Is the argument in question trivially copy constructible? */
> > +
> > + bool trivially_copy_constructible;
> > +
> > + /* Is the argument in question trivially destructible? */
> > +
> > + bool trivially_destructible;
> > +};
> > +
Does a definition like the one below look OK?
+/* In a language (particularly C++) a function argument of an aggregate
+ type (i.e. class/struct/union) may be implicitly passed by reference
+ even though it is declared a call-by-value argument in the source.
+ The struct below puts together necessary information for GDB to be
+ able to detect and carry out pass-by-reference semantics for a
+ particular type. This type is referred as T in the inlined comments
+ below.
+
+ The default values of the fields are chosen to give correct semantics
+ for primitive types and for simple aggregate types, such as
+
+ class T {
+ int x;
+ }; */
+
+struct language_pass_by_ref_info
+{
+ /* Name of the copy ctor function of T. Expected to be
+ fully-qualified. */
+ const char *cctor_name = nullptr;
+
+ /* Name of the destructor function of T. Expected to be
+ fully-qualified. */
+ const char *dtor_name = nullptr;
+
+ /* True if an argument of type T can be passed to a function by value
+ (i.e. not through an implicit reference). False, otherwise. */
+ bool trivially_copyable = true;
+
+ /* True if a copy of a value of type T can be initialized by
+ memcpy'ing the value bit-by-bit. False, otherwise.
+ E.g. If T has a user-defined copy ctor, this should be false. */
+ bool trivially_copy_constructible = true;
+
+ /* True if a value of type T can be destructed simply by reclaiming
+ the memory area occupied by the value. False, otherwise.
+ E.g. If T has a user-defined destructor, this should be false. */
+ bool trivially_destructible = true;
+
+ /* True if it is allowed to create a copy of a value of type T.
+ False, otherwise.
+ E.g. If T has a deleted copy ctor, this should be false. */
+ bool copy_constructible = true;
+
+ /* True if a value of type T can be destructed. False, otherwise.
+ E.g. If T has a deleted destructor, this should be false. */
+ bool destructible = true;
+};
+
Regards,
-Baris
Intel Deutschland GmbH
Registered Address: Am Campeon 10-12, 85579 Neubiberg, Germany
Tel: +49 89 99 8853-0, www.intel.de
Managing Directors: Christin Eisenschmid, Gary Kershaw
Chairperson of the Supervisory Board: Nicole Lau
Registered Office: Munich
Commercial Register: Amtsgericht Muenchen HRB 186928
^ permalink raw reply [flat|nested] 19+ messages in thread
* Re: [PATCH 3/8] infcall, c++: collect more pass-by-reference information
2019-05-22 20:34 ` Andrew Burgess
@ 2019-05-31 13:56 ` Aktemur, Tankut Baris
2019-06-23 19:23 ` Andrew Burgess
0 siblings, 1 reply; 19+ messages in thread
From: Aktemur, Tankut Baris @ 2019-05-31 13:56 UTC (permalink / raw)
To: Andrew Burgess; +Cc: gdb-patches
> > Walk through a given type to collect information about whether the type
> > is copy constructible, destructible, trivially copyable, trivially copy
> > constructible, trivially destructible. The previous algorithm returned
> > only a boolean result about whether the type is trivially copyable.
> > This patch computes more info. Additionally, it utilizes DWARF attributes
> > that were previously not taken into account; namely,
> > DW_AT_deleted, DW_AT_defaulted, and DW_AT_calling_convention.
>
> I'm basically happy with this, a few formatting issues and questions
> about comments below.
>
Thank you.
> >
> > + /* FIXME taktemur/2019-04-23: What if there are multiple cctors? */
>
> Can such a situation arise? If you know how it could but don't know
> how to handle it then can we expand the comment. If you don't think
> such a situation could arise then lets delete this comment and add an
> assertion below.
>
Such a situation can arise when there is a copy ctor that takes a
non-const &T and another that takes a const &T. I'm planning to
add the example below to the comment:
/* FIXME taktemur/2019-04-23: What if there are multiple copy ctors?
E.g.:
class C {
public:
C (C &c) { ... }
C (const C &c) { ... }
};
*/
The correct version shall be selected based on the type of the argument,
but I don't know how to express that in GDB.
> > for (fieldnum = 0; fieldnum < TYPE_NFN_FIELDS (type); fieldnum++)
> > for (fieldelem = 0; fieldelem < TYPE_FN_FIELDLIST_LENGTH (type, fieldnum);
> > fieldelem++)
> > @@ -1282,49 +1415,53 @@ gnuv3_pass_by_reference (struct type *type)
> > const char *name = TYPE_FN_FIELDLIST_NAME (type, fieldnum);
> > struct type *fieldtype = TYPE_FN_FIELD_TYPE (fn, fieldelem);
> >
> > - /* If this function is marked as artificial, it is compiler-generated,
> > - and we assume it is trivial. */
> > - if (TYPE_FN_FIELD_ARTIFICIAL (fn, fieldelem))
> > - continue;
> > -
> > - /* If we've found a destructor, we must pass this by reference. */
> > if (name[0] == '~')
> > {
> > - info.trivially_copyable = false;
> > - return info;
> > + /* We've found a destructor. */
> > + dtor_def = get_def_style (fn, fieldelem);
> > + info.dtor_name = TYPE_FN_FIELD_PHYSNAME (fn, fieldelem);
>
> Maybe we should have an error or at least a warning if
> 'info.dtor_name' is not nullptr before this assignment - this would
> indicate multiple destructors, which seems weird, right?
>
I believe the 'info.dtor_name' field can be nullptr even if a destructor
definition exists, if the destructor is inlined and hence its code does
not exist in the object file. (Such a case also requires special treatment
and is handled at the client side, in gdb/infcall.c in part 7/8 of this patch.)
So, I thought I should gdb_assert on 'dtor_def == DOES_NOT_EXIST_IN_SOURCE'
instead. Is this OK?
> > + if (is_copy_constructor_type (type, fieldtype))
> > {
> > - struct type *arg_target_type
> > - = check_typedef (TYPE_TARGET_TYPE (arg_type));
> > - if (class_types_same_p (arg_target_type, type))
> > - {
> > - info.trivially_copyable = false;
> > - return info;
> > - }
> > + cctor_def = get_def_style (fn, fieldelem);
> > + info.cctor_name = TYPE_FN_FIELD_PHYSNAME (fn, fieldelem);
>
> This would be where we assert that we only have one cctor I think...
>
Similarly, I'm planning to assert 'cctor_def == DOES_NOT_EXIST_IN_SOURCE'.
> > + bool cctor_implicitly_deleted
> > + = mctor_def != DOES_NOT_EXIST_IN_SOURCE
> > + && cctor_def == DOES_NOT_EXIST_IN_SOURCE;
>
> I think this should be parenthesised like this:
>
> bool cctor_implicitly_deleted
> = (mctor_def != DOES_NOT_EXIST_IN_SOURCE
> && cctor_def == DOES_NOT_EXIST_IN_SOURCE);
>
> My reference is:
> https://www.gnu.org/prep/standards/standards.html#Formatting
>
Thanks for the pointer. I'll address these formatting issues in the next update.
>
> Thanks,
> Andrew
Regards,
-Baris
Intel Deutschland GmbH
Registered Address: Am Campeon 10-12, 85579 Neubiberg, Germany
Tel: +49 89 99 8853-0, www.intel.de
Managing Directors: Christin Eisenschmid, Gary Kershaw
Chairperson of the Supervisory Board: Nicole Lau
Registered Office: Munich
Commercial Register: Amtsgericht Muenchen HRB 186928
^ permalink raw reply [flat|nested] 19+ messages in thread
* Re: [PATCH 2/8] infcall, c++: allow more info to be computed for pass-by-reference values
2019-05-31 13:53 ` Aktemur, Tankut Baris
@ 2019-06-23 19:06 ` Andrew Burgess
0 siblings, 0 replies; 19+ messages in thread
From: Andrew Burgess @ 2019-06-23 19:06 UTC (permalink / raw)
To: Aktemur, Tankut Baris; +Cc: gdb-patches
* Aktemur, Tankut Baris <tankut.baris.aktemur@intel.com> [2019-05-31 13:53:17 +0000]:
> > > In C++, call-by-value arguments that cannot be trivially copied are
> > > implicitly passed by reference. When making an infcall, GDB needs to
> > > find out if an argument is pass-by-reference or not, so that the correct
> > > semantics can be followed. This patch enriches the information computed
> > > by the language ops for pass-by-reference arguments. Instead of a plain
> > > binary result, the computed information now includes whether the
> > > argument is
> > > - copy constructible
> > > - destructible
> > > - trivially copyable
> > > - trivially copy constructible
> > > - trivially destructible
> > > and also
> > > - the full name of the copy constructor
> > > - the full name of the destructor
> > > in preparation for GDB's infcall mechanism to call the copy ctor and
> > > the destructor of a pass-by-ref argument appropriately. This
> > > information is stored in a struct named 'language_pass_by_ref_info'.
> > >
> >
> > I have a little feedback given below, but otherwise this looks fine.
>
> Thank you for your valuable feedback.
>
> > > +
> > > + /* Name of the destructor function. Expected to be fully-qualified. */
> > > +
> > > + const char *dtor_name;
> > > +
> > > + /* Is the type of the argument in question copy-constructible? */
> > > +
> > > + bool copy_constructible;
> >
> > This comment doesn't seem very helpful. Could you expand on what true
> > or false value would mean here? I have the same question about all of
> > the fields below.
> >
> > Also I think it might be worth inlining the default value here rather
> > than in 'default_pass_by_reference', so:
> >
> > bool copy_constructible = true;
> >
> > then you can extend the comment to explain why that default was
> > selected. I think doing this for all the fields in this struct would
> > be a good change.
> >
> > > +
> > > + /* Is the type of the argument in question destructible? */
> > > +
> > > + bool destructible;
> > > +
> > > + /* Is the argument in question trivially copyable?
> > > + That is, is it pass-by-value? */
> > > +
> > > + bool trivially_copyable;
> > > +
> > > + /* Is the argument in question trivially copy constructible? */
> > > +
> > > + bool trivially_copy_constructible;
> > > +
> > > + /* Is the argument in question trivially destructible? */
> > > +
> > > + bool trivially_destructible;
> > > +};
> > > +
>
> Does a definition like the one below look OK?
>
>
> +/* In a language (particularly C++) a function argument of an aggregate
> + type (i.e. class/struct/union) may be implicitly passed by reference
> + even though it is declared a call-by-value argument in the source.
> + The struct below puts together necessary information for GDB to be
> + able to detect and carry out pass-by-reference semantics for a
> + particular type. This type is referred as T in the inlined comments
> + below.
> +
> + The default values of the fields are chosen to give correct semantics
> + for primitive types and for simple aggregate types, such as
> +
> + class T {
> + int x;
> + }; */
> +
> +struct language_pass_by_ref_info
> +{
> + /* Name of the copy ctor function of T. Expected to be
> + fully-qualified. */
> + const char *cctor_name = nullptr;
> +
> + /* Name of the destructor function of T. Expected to be
> + fully-qualified. */
> + const char *dtor_name = nullptr;
> +
> + /* True if an argument of type T can be passed to a function by value
> + (i.e. not through an implicit reference). False, otherwise. */
> + bool trivially_copyable = true;
> +
> + /* True if a copy of a value of type T can be initialized by
> + memcpy'ing the value bit-by-bit. False, otherwise.
> + E.g. If T has a user-defined copy ctor, this should be false. */
> + bool trivially_copy_constructible = true;
> +
> + /* True if a value of type T can be destructed simply by reclaiming
> + the memory area occupied by the value. False, otherwise.
> + E.g. If T has a user-defined destructor, this should be false. */
> + bool trivially_destructible = true;
> +
> + /* True if it is allowed to create a copy of a value of type T.
> + False, otherwise.
> + E.g. If T has a deleted copy ctor, this should be false. */
> + bool copy_constructible = true;
> +
> + /* True if a value of type T can be destructed. False, otherwise.
> + E.g. If T has a deleted destructor, this should be false. */
> + bool destructible = true;
> +};
> +
This looks great.
Thanks,
Andrew
>
> Regards,
>
> -Baris
>
> Intel Deutschland GmbH
> Registered Address: Am Campeon 10-12, 85579 Neubiberg, Germany
> Tel: +49 89 99 8853-0, www.intel.de
> Managing Directors: Christin Eisenschmid, Gary Kershaw
> Chairperson of the Supervisory Board: Nicole Lau
> Registered Office: Munich
> Commercial Register: Amtsgericht Muenchen HRB 186928
>
^ permalink raw reply [flat|nested] 19+ messages in thread
* Re: [PATCH 3/8] infcall, c++: collect more pass-by-reference information
2019-05-31 13:56 ` Aktemur, Tankut Baris
@ 2019-06-23 19:23 ` Andrew Burgess
2019-06-24 7:28 ` Aktemur, Tankut Baris
0 siblings, 1 reply; 19+ messages in thread
From: Andrew Burgess @ 2019-06-23 19:23 UTC (permalink / raw)
To: Aktemur, Tankut Baris; +Cc: gdb-patches
* Aktemur, Tankut Baris <tankut.baris.aktemur@intel.com> [2019-05-31 13:55:58 +0000]:
> > > Walk through a given type to collect information about whether the type
> > > is copy constructible, destructible, trivially copyable, trivially copy
> > > constructible, trivially destructible. The previous algorithm returned
> > > only a boolean result about whether the type is trivially copyable.
> > > This patch computes more info. Additionally, it utilizes DWARF attributes
> > > that were previously not taken into account; namely,
> > > DW_AT_deleted, DW_AT_defaulted, and DW_AT_calling_convention.
> >
> > I'm basically happy with this, a few formatting issues and questions
> > about comments below.
> >
>
> Thank you.
>
> > >
> > > + /* FIXME taktemur/2019-04-23: What if there are multiple cctors? */
> >
> > Can such a situation arise? If you know how it could but don't know
> > how to handle it then can we expand the comment. If you don't think
> > such a situation could arise then lets delete this comment and add an
> > assertion below.
> >
>
> Such a situation can arise when there is a copy ctor that takes a
> non-const &T and another that takes a const &T. I'm planning to
> add the example below to the comment:
>
> /* FIXME taktemur/2019-04-23: What if there are multiple copy ctors?
> E.g.:
> class C {
> public:
> C (C &c) { ... }
> C (const C &c) { ... }
> };
> */
That would be great, I find information like this in comments very
helpful so thank you.
>
> The correct version shall be selected based on the type of the argument,
> but I don't know how to express that in GDB.
>
>
> > > for (fieldnum = 0; fieldnum < TYPE_NFN_FIELDS (type); fieldnum++)
> > > for (fieldelem = 0; fieldelem < TYPE_FN_FIELDLIST_LENGTH (type, fieldnum);
> > > fieldelem++)
> > > @@ -1282,49 +1415,53 @@ gnuv3_pass_by_reference (struct type *type)
> > > const char *name = TYPE_FN_FIELDLIST_NAME (type, fieldnum);
> > > struct type *fieldtype = TYPE_FN_FIELD_TYPE (fn, fieldelem);
> > >
> > > - /* If this function is marked as artificial, it is compiler-generated,
> > > - and we assume it is trivial. */
> > > - if (TYPE_FN_FIELD_ARTIFICIAL (fn, fieldelem))
> > > - continue;
> > > -
> > > - /* If we've found a destructor, we must pass this by reference. */
> > > if (name[0] == '~')
> > > {
> > > - info.trivially_copyable = false;
> > > - return info;
> > > + /* We've found a destructor. */
> > > + dtor_def = get_def_style (fn, fieldelem);
> > > + info.dtor_name = TYPE_FN_FIELD_PHYSNAME (fn, fieldelem);
> >
> > Maybe we should have an error or at least a warning if
> > 'info.dtor_name' is not nullptr before this assignment - this would
> > indicate multiple destructors, which seems weird, right?
> >
>
> I believe the 'info.dtor_name' field can be nullptr even if a destructor
> definition exists, if the destructor is inlined and hence its code does
> not exist in the object file. (Such a case also requires special treatment
> and is handled at the client side, in gdb/infcall.c in part 7/8 of this patch.)
> So, I thought I should gdb_assert on 'dtor_def == DOES_NOT_EXIST_IN_SOURCE'
> instead. Is this OK?
>
> > > + if (is_copy_constructor_type (type, fieldtype))
> > > {
> > > - struct type *arg_target_type
> > > - = check_typedef (TYPE_TARGET_TYPE (arg_type));
> > > - if (class_types_same_p (arg_target_type, type))
> > > - {
> > > - info.trivially_copyable = false;
> > > - return info;
> > > - }
> > > + cctor_def = get_def_style (fn, fieldelem);
> > > + info.cctor_name = TYPE_FN_FIELD_PHYSNAME (fn, fieldelem);
> >
> > This would be where we assert that we only have one cctor I think...
> >
>
> Similarly, I'm planning to assert 'cctor_def == DOES_NOT_EXIST_IN_SOURCE'.
>
OK, that sounds reasonable.
If nobody else reviews the remaining patches in this series then I
will get around to them soon I hope. I've been crazy busy the last
couple of weeks and am still trying to catch up on everything.
Thanks,
Andrew
> > > + bool cctor_implicitly_deleted
> > > + = mctor_def != DOES_NOT_EXIST_IN_SOURCE
> > > + && cctor_def == DOES_NOT_EXIST_IN_SOURCE;
> >
> > I think this should be parenthesised like this:
> >
> > bool cctor_implicitly_deleted
> > = (mctor_def != DOES_NOT_EXIST_IN_SOURCE
> > && cctor_def == DOES_NOT_EXIST_IN_SOURCE);
> >
> > My reference is:
> > https://www.gnu.org/prep/standards/standards.html#Formatting
> >
>
> Thanks for the pointer. I'll address these formatting issues in the next update.
>
> >
> > Thanks,
> > Andrew
>
> Regards,
> -Baris
>
> Intel Deutschland GmbH
> Registered Address: Am Campeon 10-12, 85579 Neubiberg, Germany
> Tel: +49 89 99 8853-0, www.intel.de
> Managing Directors: Christin Eisenschmid, Gary Kershaw
> Chairperson of the Supervisory Board: Nicole Lau
> Registered Office: Munich
> Commercial Register: Amtsgericht Muenchen HRB 186928
>
^ permalink raw reply [flat|nested] 19+ messages in thread
* RE: [PATCH 3/8] infcall, c++: collect more pass-by-reference information
2019-06-23 19:23 ` Andrew Burgess
@ 2019-06-24 7:28 ` Aktemur, Tankut Baris
0 siblings, 0 replies; 19+ messages in thread
From: Aktemur, Tankut Baris @ 2019-06-24 7:28 UTC (permalink / raw)
To: Andrew Burgess; +Cc: gdb-patches
* On Sunday, June 23, 2019 9:24 PM, Andrew Burgess wrote:
> * Aktemur, Tankut Baris <tankut.baris.aktemur@intel.com> [2019-05-31 13:55:58 +0000]:
>
> > > > Walk through a given type to collect information about whether the type
> > > > is copy constructible, destructible, trivially copyable, trivially copy
> > > > constructible, trivially destructible. The previous algorithm returned
> > > > only a boolean result about whether the type is trivially copyable.
> > > > This patch computes more info. Additionally, it utilizes DWARF attributes
> > > > that were previously not taken into account; namely,
> > > > DW_AT_deleted, DW_AT_defaulted, and DW_AT_calling_convention.
> > >
> > > I'm basically happy with this, a few formatting issues and questions
> > > about comments below.
> > >
> >
> > Thank you.
> >
> > > >
> > > > + /* FIXME taktemur/2019-04-23: What if there are multiple cctors? */
> > >
> > > Can such a situation arise? If you know how it could but don't know
> > > how to handle it then can we expand the comment. If you don't think
> > > such a situation could arise then lets delete this comment and add an
> > > assertion below.
> > >
> >
> > Such a situation can arise when there is a copy ctor that takes a
> > non-const &T and another that takes a const &T. I'm planning to
> > add the example below to the comment:
> >
> > /* FIXME taktemur/2019-04-23: What if there are multiple copy ctors?
> > E.g.:
> > class C {
> > public:
> > C (C &c) { ... }
> > C (const C &c) { ... }
> > };
> > */
>
> That would be great, I find information like this in comments very
> helpful so thank you.
>
> >
> > The correct version shall be selected based on the type of the argument,
> > but I don't know how to express that in GDB.
> >
> >
> > > > for (fieldnum = 0; fieldnum < TYPE_NFN_FIELDS (type); fieldnum++)
> > > > for (fieldelem = 0; fieldelem < TYPE_FN_FIELDLIST_LENGTH (type, fieldnum);
> > > > fieldelem++)
> > > > @@ -1282,49 +1415,53 @@ gnuv3_pass_by_reference (struct type *type)
> > > > const char *name = TYPE_FN_FIELDLIST_NAME (type, fieldnum);
> > > > struct type *fieldtype = TYPE_FN_FIELD_TYPE (fn, fieldelem);
> > > >
> > > > - /* If this function is marked as artificial, it is compiler-generated,
> > > > - and we assume it is trivial. */
> > > > - if (TYPE_FN_FIELD_ARTIFICIAL (fn, fieldelem))
> > > > - continue;
> > > > -
> > > > - /* If we've found a destructor, we must pass this by reference. */
> > > > if (name[0] == '~')
> > > > {
> > > > - info.trivially_copyable = false;
> > > > - return info;
> > > > + /* We've found a destructor. */
> > > > + dtor_def = get_def_style (fn, fieldelem);
> > > > + info.dtor_name = TYPE_FN_FIELD_PHYSNAME (fn, fieldelem);
> > >
> > > Maybe we should have an error or at least a warning if
> > > 'info.dtor_name' is not nullptr before this assignment - this would
> > > indicate multiple destructors, which seems weird, right?
> > >
> >
> > I believe the 'info.dtor_name' field can be nullptr even if a destructor
> > definition exists, if the destructor is inlined and hence its code does
> > not exist in the object file. (Such a case also requires special treatment
> > and is handled at the client side, in gdb/infcall.c in part 7/8 of this patch.)
> > So, I thought I should gdb_assert on 'dtor_def == DOES_NOT_EXIST_IN_SOURCE'
> > instead. Is this OK?
> >
> > > > + if (is_copy_constructor_type (type, fieldtype))
> > > > {
> > > > - struct type *arg_target_type
> > > > - = check_typedef (TYPE_TARGET_TYPE (arg_type));
> > > > - if (class_types_same_p (arg_target_type, type))
> > > > - {
> > > > - info.trivially_copyable = false;
> > > > - return info;
> > > > - }
> > > > + cctor_def = get_def_style (fn, fieldelem);
> > > > + info.cctor_name = TYPE_FN_FIELD_PHYSNAME (fn, fieldelem);
> > >
> > > This would be where we assert that we only have one cctor I think...
> > >
> >
> > Similarly, I'm planning to assert 'cctor_def == DOES_NOT_EXIST_IN_SOURCE'.
> >
>
> OK, that sounds reasonable.
>
> If nobody else reviews the remaining patches in this series then I
> will get around to them soon I hope. I've been crazy busy the last
> couple of weeks and am still trying to catch up on everything.
>
> Thanks,
> Andrew
>
Thank you! The remaining patches have not received a review so far.
I'll submit today a v2 of the series in which your comments have been addressed
in patches 1-3.
-Baris
> > > > + bool cctor_implicitly_deleted
> > > > + = mctor_def != DOES_NOT_EXIST_IN_SOURCE
> > > > + && cctor_def == DOES_NOT_EXIST_IN_SOURCE;
> > >
> > > I think this should be parenthesised like this:
> > >
> > > bool cctor_implicitly_deleted
> > > = (mctor_def != DOES_NOT_EXIST_IN_SOURCE
> > > && cctor_def == DOES_NOT_EXIST_IN_SOURCE);
> > >
> > > My reference is:
> > > https://www.gnu.org/prep/standards/standards.html#Formatting
> > >
> >
> > Thanks for the pointer. I'll address these formatting issues in the next update.
> >
> > >
> > > Thanks,
> > > Andrew
> >
> > Regards,
> > -Baris
> >
Intel Deutschland GmbH
Registered Address: Am Campeon 10-12, 85579 Neubiberg, Germany
Tel: +49 89 99 8853-0, www.intel.de
Managing Directors: Christin Eisenschmid, Gary Kershaw
Chairperson of the Supervisory Board: Nicole Lau
Registered Office: Munich
Commercial Register: Amtsgericht Muenchen HRB 186928
^ permalink raw reply [flat|nested] 19+ messages in thread
end of thread, other threads:[~2019-06-24 7:28 UTC | newest]
Thread overview: 19+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2019-04-23 14:32 [PATCH 0/8] Fix inferior call for C++ pass-by-reference arguments Tankut Baris Aktemur
2019-04-23 14:32 ` [PATCH 2/8] infcall, c++: allow more info to be computed for pass-by-reference values Tankut Baris Aktemur
2019-05-22 20:17 ` Andrew Burgess
2019-05-31 13:53 ` Aktemur, Tankut Baris
2019-06-23 19:06 ` Andrew Burgess
2019-04-23 14:32 ` [PATCH 3/8] infcall, c++: collect more pass-by-reference information Tankut Baris Aktemur
2019-05-22 20:34 ` Andrew Burgess
2019-05-31 13:56 ` Aktemur, Tankut Baris
2019-06-23 19:23 ` Andrew Burgess
2019-06-24 7:28 ` Aktemur, Tankut Baris
2019-04-23 14:32 ` [PATCH 6/8] infcall: remove unused parameter in 'value_arg_coerce' Tankut Baris Aktemur
2019-04-23 14:32 ` [PATCH 4/8] infcall: refactor 'call_function_by_hand_dummy' Tankut Baris Aktemur
2019-04-23 14:32 ` [PATCH 1/8] gdb: recognize new DWARF attributes: defaulted, deleted, calling conv Tankut Baris Aktemur
2019-04-23 21:40 ` Andrew Burgess
2019-04-23 14:32 ` [PATCH 7/8] infcall: handle pass-by-reference arguments appropriately Tankut Baris Aktemur
2019-04-23 14:33 ` [PATCH 5/8] infcall: move assertions in 'call_function_by_hand_dummy' to an earlier spot Tankut Baris Aktemur
2019-04-23 14:33 ` [PATCH 8/8] testsuite, cp: increase the coverage of testing pass-by-ref arguments Tankut Baris Aktemur
2019-05-08 10:50 ` [PATCH 0/8] Fix inferior call for C++ pass-by-reference arguments Aktemur, Tankut Baris
2019-05-21 10:33 ` [PING][PATCH " Tankut Baris Aktemur
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).