cxx-ada-virtual-diamond-layout

C++ Ada virtual-diamond base storage

The C++ Ada mapper uses complete virtual-base class types for shortened direct base subobjects in a virtual diamond.

StagedApplies in patchset orderStaged in 1.2.0

Bundle JSON Repository directory

Why this is staged.

Shortened as-base views for diamond legs depend on the virtual-base layout representation and share its C++ ABI coupling. Held out of the published patchset for separate upstream review.

Depends on

Where it applies.

How each patchset treats this bundle on each GCC major
PatchsetGCC 13GCC 14GCC 15GCC 16
1.2.0 (latest)Staged13.2.0Staged14.2.0Staged15.3.0Staged16.2.0
1.1.0Not applicable13.2.0Not applicable14.2.0Not applicable15.3.0Not applicable16.2.0
1.0.1Not applicable13.2.0Not applicable14.2.0Not applicable15.3.0Not applicable16.1.0
1.0.0Not applicable13.2.0Not applicable14.2.0Not applicable15.3.0Not applicable16.1.0

Explanation.

A complete C++ object with a virtual base contains that shared base, while the same class used as a nonvirtual base subobject does not. In a diamond, the mapper currently declares each direct base component using its larger complete Ada type, even though C++ allocated only its shortened as-base storage.

For example, on the supported 64-bit Itanium ABI targets each direct base is 16 bytes as a complete object but only 12 bytes inside Diamond:

struct Root { int root_value; };
struct Left : virtual Root { int left_value; };
struct Right : virtual Root { int right_value; };

struct Diamond : Left, Right
{
  int diamond_value;
};

The unpatched mapper uses the complete Left and Right types as components. Their duplicated virtual Root members make Ada's view larger than the C++ object and give the visible fields the wrong addresses:

type Diamond is limited record
   parent : aliased Left;
   field_2 : aliased Right;
   diamond_value : aliased int;
   field_4 : aliased Root;
end record
with Import => True,
     Convention => CPP;

The corrected output emits explicit storage-only views for the shortened base subobjects. They retain each direct field, omit the shared virtual base, and use an alignment that their 12-byte object size can satisfy:

type Left_As_Base is limited record
   left_value : aliased int;
end record
with Convention => C_Pass_By_Copy;
for Left_As_Base'Object_Size use 96;
for Left_As_Base'Alignment use 4;
for Left_As_Base use record
   left_value at 8 range 0 .. 31;
end record;

type Diamond is limited record
   parent : aliased Left_As_Base;
   field_2 : aliased Right_As_Base;
   diamond_value : aliased int;
   field_4 : aliased Root;
end record
with Import => True,
     Convention => CPP;

The executable regression runs at -O0 and -O2. C++ constructs a real diamond and reports its complete size, alignment, and four visible field offsets. Ada verifies those values, writes through both shortened base views, the direct member, and the single shared virtual base, and C++ reads all four values back. Polymorphic concrete secondary bases remain a separate facade boundary because Ada cannot express their inheritance graph.

Patch.

Variant gcc-13-14

Applies to 13.2.0, 14.2.0. Source flavors: linux, darwin_arm64.

+328 −2 2 files

SHA-256
6d7f7ef1f3010926319a3c312e7c3a5bb59a9a64870415d03cd72a12efcdfc64
Patch
bundles/cxx-ada-virtual-diamond-layout/patches/gcc-13-14.patch

Download the patch

gcc/c-family/c-ada-spec.cc +214−2modified
@@ -2856 +2856 @@is_ada_record_field (tree field)
28562856 return DECL_NAME (field) || !is_tagged_type (TREE_TYPE (field));
28572857}
28582858
2859/* Return true if NODE needs a distinct storage type when used as a base
2860 subobject. A non-polymorphic class with virtual bases contains those bases
2861 as a complete object, but excludes them from its as-base size. */
2862
2863static bool
2864needs_virtual_as_base_type (tree node)
2865{
2866 if (!cpp_check || !RECORD_OR_UNION_TYPE_P (node) || is_tagged_type (node)
2867 || !cpp_check (node, HAS_VIRTUAL_BASE))
2868 return false;
2869
2870 const int data_size = cpp_check (node, GET_AS_BASE_SIZE);
2871 const HOST_WIDE_INT object_size = int_size_in_bytes (node);
2872 return data_size > 0 && object_size > data_size;
2873}
2874
2875/* Return true if FIELD stores only the as-base portion of a virtual-base
2876 class. The complete Ada type has a larger Object_Size and cannot be used
2877 for this component. */
2878
2879static bool
2880is_shortened_virtual_base_field (tree field)
2881{
2882 if (TREE_CODE (field) != FIELD_DECL || DECL_NAME (field)
2883 || !needs_virtual_as_base_type (TREE_TYPE (field))
2884 || !DECL_SIZE (field) || !tree_fits_uhwi_p (DECL_SIZE (field)))
2885 return false;
2886
2887 const HOST_WIDE_INT object_size = int_size_in_bytes (TREE_TYPE (field));
2888 return object_size > 0
2889 && tree_to_uhwi (DECL_SIZE (field))
2890 < (unsigned HOST_WIDE_INT) object_size * BITS_PER_UNIT;
2891}
2892
2893/* Dump FIELD's named type, selecting the shortened storage type when FIELD
2894 is a base subobject that excludes its type's virtual bases. */
2895
2896static void
2897dump_ada_record_field_type (pretty_printer *buffer, tree field)
2898{
2899 dump_ada_decl_name (buffer, TYPE_NAME (TREE_TYPE (field)), false);
2900 if (is_shortened_virtual_base_field (field))
2901 pp_string (buffer, "_As_Base");
2902}
2903
2904/* Return true if FIELD lies wholly inside NODE's C++ as-base size. */
2905
2906static bool
2907field_fits_as_base (tree node, tree field)
2908{
2909 const int data_size = cpp_check (node, GET_AS_BASE_SIZE);
2910 if (data_size < 0 || !is_ada_record_field (node, field)
2911 || !DECL_FIELD_OFFSET (field) || !DECL_FIELD_BIT_OFFSET (field)
2912 || !DECL_SIZE (field)
2913 || !tree_fits_uhwi_p (DECL_FIELD_OFFSET (field))
2914 || !tree_fits_uhwi_p (DECL_FIELD_BIT_OFFSET (field))
2915 || !tree_fits_uhwi_p (DECL_SIZE (field)))
2916 return false;
2917
2918 const unsigned HOST_WIDE_INT bitpos
2919 = tree_to_uhwi (DECL_FIELD_OFFSET (field)) * BITS_PER_UNIT
2920 + tree_to_uhwi (DECL_FIELD_BIT_OFFSET (field));
2921 const unsigned HOST_WIDE_INT size = tree_to_uhwi (DECL_SIZE (field));
2922 return size > 0 && bitpos + size
2923 <= (unsigned HOST_WIDE_INT) data_size * BITS_PER_UNIT;
2924}
2925
2926/* Return the strongest Ada alignment that divides NODE's as-base size. The
2927 complete C++ alignment can exceed that storage size because reusable tail
2928 padding is not part of a base subobject. */
2929
2930static unsigned int
2931virtual_as_base_alignment (tree node, unsigned int data_size)
2932{
2933 unsigned int alignment = TYPE_ALIGN (node) / BITS_PER_UNIT;
2934 while (alignment > 1 && data_size % alignment != 0)
2935 alignment >>= 1;
2936 return alignment;
2937}
2938
2939/* Dump a storage-only Ada type for NODE's C++ as-base representation. This
2940 keeps each direct field addressable while excluding shared virtual bases. */
2941
2942static void
2943dump_ada_virtual_as_base_type (pretty_printer *buffer, tree node, tree type,
2944 int spc)
2945{
2946 const unsigned int data_size = cpp_check (node, GET_AS_BASE_SIZE);
2947 int field_num = 0;
2948
2949 pp_newline (buffer);
2950 newline_and_indent (buffer, spc);
2951 pp_string (buffer, "type ");
2952 dump_ada_node (buffer, TYPE_NAME (node), type, spc, false, true);
2953 pp_string (buffer, "_As_Base is record");
2954 pp_newline (buffer);
2955
2956 for (tree field = TYPE_FIELDS (node); field; field = TREE_CHAIN (field))
2957 if (field_fits_as_base (node, field))
2958 {
2959 if (!DECL_NAME (field))
2960 {
2961 if (is_tagged_type (TREE_TYPE (field)))
2962 continue;
2963
2964 INDENT (spc + INDENT_INCR);
2965 if (field_num == 0)
2966 pp_string (buffer, "parent : ");
2967 else
2968 {
2969 char buf[32];
2970 sprintf (buf, "field_%d : ", field_num + 1);
2971 pp_string (buffer, buf);
2972 }
2973 dump_ada_record_field_type (buffer, field);
2974 pp_semicolon (buffer);
2975 pp_newline (buffer);
2976 field_num++;
2977 }
2978 else
2979 {
2980 INDENT (spc + INDENT_INCR);
2981 dump_ada_node (buffer, field, type, spc, false, true);
2982 pp_string (buffer, " : ");
2983 dump_ada_record_field_type (buffer, field);
2984 pp_string (buffer, "; -- ");
2985 dump_sloc (buffer, field);
2986 pp_newline (buffer);
2987 field_num++;
2988 }
2989 }
2990
2991 if (field_num == 0)
2992 {
2993 INDENT (spc + INDENT_INCR);
2994 pp_string (buffer, "null;");
2995 pp_newline (buffer);
2996 }
2997
2998 INDENT (spc);
2999 pp_string (buffer, "end record");
3000 newline_and_indent (buffer, spc);
3001 pp_string (buffer, "with Convention => C_Pass_By_Copy;");
3002
3003 newline_and_indent (buffer, spc);
3004 pp_string (buffer, "for ");
3005 dump_ada_node (buffer, TYPE_NAME (node), type, spc, false, true);
3006 pp_string (buffer, "_As_Base'Size use ");
3007 pp_wide_integer (buffer, (HOST_WIDE_INT) data_size * BITS_PER_UNIT);
3008 pp_semicolon (buffer);
3009
3010 newline_and_indent (buffer, spc);
3011 pp_string (buffer, "for ");
3012 dump_ada_node (buffer, TYPE_NAME (node), type, spc, false, true);
3013 pp_string (buffer, "_As_Base'Object_Size use ");
3014 pp_wide_integer (buffer, (HOST_WIDE_INT) data_size * BITS_PER_UNIT);
3015 pp_semicolon (buffer);
3016
3017 newline_and_indent (buffer, spc);
3018 pp_string (buffer, "for ");
3019 dump_ada_node (buffer, TYPE_NAME (node), type, spc, false, true);
3020 pp_string (buffer, "_As_Base'Alignment use ");
3021 pp_decimal_int (buffer, virtual_as_base_alignment (node, data_size));
3022 pp_semicolon (buffer);
3023
3024 newline_and_indent (buffer, spc);
3025 pp_string (buffer, "for ");
3026 dump_ada_node (buffer, TYPE_NAME (node), type, spc, false, true);
3027 pp_string (buffer, "_As_Base use record");
3028
3029 int repr_field_num = 0;
3030 for (tree field = TYPE_FIELDS (node); field; field = TREE_CHAIN (field))
3031 if (field_fits_as_base (node, field))
3032 {
3033 if (!DECL_NAME (field) && is_tagged_type (TREE_TYPE (field)))
3034 continue;
3035
3036 repr_field_num++;
3037 const unsigned HOST_WIDE_INT bitpos
3038 = tree_to_uhwi (DECL_FIELD_OFFSET (field)) * BITS_PER_UNIT
3039 + tree_to_uhwi (DECL_FIELD_BIT_OFFSET (field));
3040 const unsigned HOST_WIDE_INT position = bitpos / BITS_PER_UNIT;
3041 const unsigned HOST_WIDE_INT first_bit = bitpos % BITS_PER_UNIT;
3042 const unsigned HOST_WIDE_INT last_bit
3043 = first_bit + tree_to_uhwi (DECL_SIZE (field)) - 1;
3044
3045 newline_and_indent (buffer, spc + INDENT_INCR);
3046 if (DECL_NAME (field))
3047 dump_ada_decl_name (buffer, field, false);
3048 else if (repr_field_num == 1)
3049 pp_string (buffer, "parent");
3050 else
3051 {
3052 char buf[32];
3053 sprintf (buf, "field_%d", repr_field_num);
3054 pp_string (buffer, buf);
3055 }
3056 pp_string (buffer, " at ");
3057 pp_unsigned_wide_integer (buffer, position);
3058 pp_string (buffer, " range ");
3059 pp_unsigned_wide_integer (buffer, first_bit);
3060 pp_string (buffer, " .. ");
3061 pp_unsigned_wide_integer (buffer, last_bit);
3062 pp_semicolon (buffer);
3063 }
3064
3065 newline_and_indent (buffer, spc);
3066 pp_string (buffer, "end record;");
3067}
3068
28593069/* Dump the value and object sizes of an empty C++ class. Ada's value size is
28603070 zero so an empty base consumes no storage, while Object_Size preserves the
28613071 byte occupied by a complete C++ object. */
@@ -3929 +4133 @@dump_ada_structure (pretty_printer *buffer, tree node, tree type, bool nested,
39294133 sprintf (buf, "field_%d : aliased ", field_num + 1);
39304134 pp_string (buffer, buf);
39314135 }
3932 dump_ada_decl_name (buffer, TYPE_NAME (TREE_TYPE (tmp)),
3933 false);
4136 dump_ada_record_field_type (buffer, tmp);
39344137 pp_semicolon (buffer);
39354138 }
39364139
@@ -4056 +4259 @@dump_ada_structure (pretty_printer *buffer, tree node, tree type, bool nested,
40564259 pp_newline (buffer);
40574260 dump_ada_cpp_layout (buffer, node, type, spc,
40584261 cpp_check (node, HAS_VIRTUAL_BASE));
4262
4263 if (needs_virtual_as_base_type (node))
4264 dump_ada_virtual_as_base_type (buffer, node, type, spc);
40594265 }
40604266
40614267 /* Print the static fields of the structure, if any. */
gcc/testsuite/g++.dg/ada-spec/virtual-diamond-layout.C +114−0new file
@@ -0 +1 @@
1/* { dg-do compile } */
2/* { dg-require-effective-target lp64 } */
3/* { dg-options "-fdump-ada-spec-slim" } */
4/* { dg-final { scan-file virtual_diamond_layout_c.ads "type Diamond_Left_As_Base" } } */
5/* { dg-final { scan-file virtual_diamond_layout_c.ads "for Diamond_Left_As_Base'Object_Size use 96;" } } */
6/* { dg-final { scan-file virtual_diamond_layout_c.ads "type Diamond_Right_As_Base" } } */
7/* { dg-final { scan-file virtual_diamond_layout_c.ads "for Diamond_Right_As_Base'Object_Size use 96;" } } */
8/* { dg-final { scan-file virtual_diamond_layout_c.ads "parent : aliased Diamond_Left_As_Base;" } } */
9/* { dg-final { scan-file virtual_diamond_layout_c.ads "field_2 : aliased Diamond_Right_As_Base;" } } */
10
11struct Diamond_Root
12{
13 int root_value;
14};
15
16struct Diamond_Left : virtual Diamond_Root
17{
18 int left_value;
19};
20
21struct Diamond_Right : virtual Diamond_Root
22{
23 int right_value;
24};
25
26struct Diamond : Diamond_Left, Diamond_Right
27{
28 int diamond_value;
29 Diamond (int root, int left, int right, int diamond_arg);
30};
31
32Diamond::Diamond (int root, int left, int right, int diamond_arg)
33 : Diamond_Root {root}, Diamond_Left {}, Diamond_Right {},
34 diamond_value {diamond_arg}
35{
36 left_value = left;
37 right_value = right;
38}
39
40extern "C" unsigned long cpp_diamond_root_size ()
41{
42 return sizeof (Diamond_Root);
43}
44
45extern "C" unsigned long cpp_diamond_size ()
46{
47 return sizeof (Diamond);
48}
49
50extern "C" unsigned long cpp_diamond_alignment ()
51{
52 return alignof (Diamond);
53}
54
55extern "C" unsigned long cpp_diamond_left_offset ()
56{
57 Diamond object (0, 0, 0, 0);
58 return reinterpret_cast<char *> (&object.left_value)
59 - reinterpret_cast<char *> (&object);
60}
61
62extern "C" unsigned long cpp_diamond_right_offset ()
63{
64 Diamond object (0, 0, 0, 0);
65 return reinterpret_cast<char *> (&object.right_value)
66 - reinterpret_cast<char *> (&object);
67}
68
69extern "C" unsigned long cpp_diamond_value_offset ()
70{
71 Diamond object (0, 0, 0, 0);
72 return reinterpret_cast<char *> (&object.diamond_value)
73 - reinterpret_cast<char *> (&object);
74}
75
76extern "C" unsigned long cpp_diamond_root_offset ()
77{
78 Diamond object (0, 0, 0, 0);
79 return reinterpret_cast<char *> (&object.root_value)
80 - reinterpret_cast<char *> (&object);
81}
82
83extern "C" Diamond *cpp_diamond_create
84 (int root, int left, int right, int diamond_arg)
85{
86 return new Diamond (root, left, right, diamond_arg);
87}
88
89extern "C" void cpp_diamond_delete (Diamond *object)
90{
91 delete object;
92}
93
94extern "C" int cpp_diamond_root_value (const Diamond *object)
95{
96 return object->root_value;
97}
98
99extern "C" int cpp_diamond_left_value (const Diamond *object)
100{
101 return object->left_value;
102}
103
104extern "C" int cpp_diamond_right_value (const Diamond *object)
105{
106 return object->right_value;
107}
108
109extern "C" int cpp_diamond_value (const Diamond *object)
110{
111 return object->diamond_value;
112}
113
114/* { dg-final { cleanup-ada-spec } } */
115

Variant gcc-15-16

Applies to 15.3.0, 16.1.0, 16.2.0. Source flavors: linux, darwin_arm64.

+328 −2 2 files

SHA-256
d07a4f5152b50054991ce469f43e5afe2a09f6a9d777b19e0e3935d0ae6a7e08
Patch
bundles/cxx-ada-virtual-diamond-layout/patches/gcc-15-16.patch

Download the patch

gcc/c-family/c-ada-spec.cc +214−2modified
@@ -2924 +2924 @@is_ada_record_field (tree field)
29242924 return DECL_NAME (field) || !is_tagged_type (TREE_TYPE (field));
29252925}
29262926
2927/* Return true if NODE needs a distinct storage type when used as a base
2928 subobject. A non-polymorphic class with virtual bases contains those bases
2929 as a complete object, but excludes them from its as-base size. */
2930
2931static bool
2932needs_virtual_as_base_type (tree node)
2933{
2934 if (!cpp_check || !RECORD_OR_UNION_TYPE_P (node) || is_tagged_type (node)
2935 || !cpp_check (node, HAS_VIRTUAL_BASE))
2936 return false;
2937
2938 const int data_size = cpp_check (node, GET_AS_BASE_SIZE);
2939 const HOST_WIDE_INT object_size = int_size_in_bytes (node);
2940 return data_size > 0 && object_size > data_size;
2941}
2942
2943/* Return true if FIELD stores only the as-base portion of a virtual-base
2944 class. The complete Ada type has a larger Object_Size and cannot be used
2945 for this component. */
2946
2947static bool
2948is_shortened_virtual_base_field (tree field)
2949{
2950 if (TREE_CODE (field) != FIELD_DECL || DECL_NAME (field)
2951 || !needs_virtual_as_base_type (TREE_TYPE (field))
2952 || !DECL_SIZE (field) || !tree_fits_uhwi_p (DECL_SIZE (field)))
2953 return false;
2954
2955 const HOST_WIDE_INT object_size = int_size_in_bytes (TREE_TYPE (field));
2956 return object_size > 0
2957 && tree_to_uhwi (DECL_SIZE (field))
2958 < (unsigned HOST_WIDE_INT) object_size * BITS_PER_UNIT;
2959}
2960
2961/* Dump FIELD's named type, selecting the shortened storage type when FIELD
2962 is a base subobject that excludes its type's virtual bases. */
2963
2964static void
2965dump_ada_record_field_type (pretty_printer *pp, tree field)
2966{
2967 dump_ada_decl_name (pp, TYPE_NAME (TREE_TYPE (field)), false);
2968 if (is_shortened_virtual_base_field (field))
2969 pp_string (pp, "_As_Base");
2970}
2971
2972/* Return true if FIELD lies wholly inside NODE's C++ as-base size. */
2973
2974static bool
2975field_fits_as_base (tree node, tree field)
2976{
2977 const int data_size = cpp_check (node, GET_AS_BASE_SIZE);
2978 if (data_size < 0 || !is_ada_record_field (node, field)
2979 || !DECL_FIELD_OFFSET (field) || !DECL_FIELD_BIT_OFFSET (field)
2980 || !DECL_SIZE (field)
2981 || !tree_fits_uhwi_p (DECL_FIELD_OFFSET (field))
2982 || !tree_fits_uhwi_p (DECL_FIELD_BIT_OFFSET (field))
2983 || !tree_fits_uhwi_p (DECL_SIZE (field)))
2984 return false;
2985
2986 const unsigned HOST_WIDE_INT bitpos
2987 = tree_to_uhwi (DECL_FIELD_OFFSET (field)) * BITS_PER_UNIT
2988 + tree_to_uhwi (DECL_FIELD_BIT_OFFSET (field));
2989 const unsigned HOST_WIDE_INT size = tree_to_uhwi (DECL_SIZE (field));
2990 return size > 0 && bitpos + size
2991 <= (unsigned HOST_WIDE_INT) data_size * BITS_PER_UNIT;
2992}
2993
2994/* Return the strongest Ada alignment that divides NODE's as-base size. The
2995 complete C++ alignment can exceed that storage size because reusable tail
2996 padding is not part of a base subobject. */
2997
2998static unsigned int
2999virtual_as_base_alignment (tree node, unsigned int data_size)
3000{
3001 unsigned int alignment = TYPE_ALIGN (node) / BITS_PER_UNIT;
3002 while (alignment > 1 && data_size % alignment != 0)
3003 alignment >>= 1;
3004 return alignment;
3005}
3006
3007/* Dump a storage-only Ada type for NODE's C++ as-base representation. This
3008 keeps each direct field addressable while excluding shared virtual bases. */
3009
3010static void
3011dump_ada_virtual_as_base_type (pretty_printer *pp, tree node, tree type,
3012 int spc)
3013{
3014 const unsigned int data_size = cpp_check (node, GET_AS_BASE_SIZE);
3015 int field_num = 0;
3016
3017 pp_newline (pp);
3018 newline_and_indent (pp, spc);
3019 pp_string (pp, "type ");
3020 dump_ada_node (pp, TYPE_NAME (node), type, spc, false, true);
3021 pp_string (pp, "_As_Base is record");
3022 pp_newline (pp);
3023
3024 for (tree field = TYPE_FIELDS (node); field; field = TREE_CHAIN (field))
3025 if (field_fits_as_base (node, field))
3026 {
3027 if (!DECL_NAME (field))
3028 {
3029 if (is_tagged_type (TREE_TYPE (field)))
3030 continue;
3031
3032 INDENT (spc + INDENT_INCR);
3033 if (field_num == 0)
3034 pp_string (pp, "parent : ");
3035 else
3036 {
3037 char buf[32];
3038 sprintf (buf, "field_%d : ", field_num + 1);
3039 pp_string (pp, buf);
3040 }
3041 dump_ada_record_field_type (pp, field);
3042 pp_semicolon (pp);
3043 pp_newline (pp);
3044 field_num++;
3045 }
3046 else
3047 {
3048 INDENT (spc + INDENT_INCR);
3049 dump_ada_node (pp, field, type, spc, false, true);
3050 pp_string (pp, " : ");
3051 dump_ada_record_field_type (pp, field);
3052 pp_string (pp, "; -- ");
3053 dump_sloc (pp, field);
3054 pp_newline (pp);
3055 field_num++;
3056 }
3057 }
3058
3059 if (field_num == 0)
3060 {
3061 INDENT (spc + INDENT_INCR);
3062 pp_string (pp, "null;");
3063 pp_newline (pp);
3064 }
3065
3066 INDENT (spc);
3067 pp_string (pp, "end record");
3068 newline_and_indent (pp, spc);
3069 pp_string (pp, "with Convention => C_Pass_By_Copy;");
3070
3071 newline_and_indent (pp, spc);
3072 pp_string (pp, "for ");
3073 dump_ada_node (pp, TYPE_NAME (node), type, spc, false, true);
3074 pp_string (pp, "_As_Base'Size use ");
3075 pp_wide_integer (pp, (HOST_WIDE_INT) data_size * BITS_PER_UNIT);
3076 pp_semicolon (pp);
3077
3078 newline_and_indent (pp, spc);
3079 pp_string (pp, "for ");
3080 dump_ada_node (pp, TYPE_NAME (node), type, spc, false, true);
3081 pp_string (pp, "_As_Base'Object_Size use ");
3082 pp_wide_integer (pp, (HOST_WIDE_INT) data_size * BITS_PER_UNIT);
3083 pp_semicolon (pp);
3084
3085 newline_and_indent (pp, spc);
3086 pp_string (pp, "for ");
3087 dump_ada_node (pp, TYPE_NAME (node), type, spc, false, true);
3088 pp_string (pp, "_As_Base'Alignment use ");
3089 pp_decimal_int (pp, virtual_as_base_alignment (node, data_size));
3090 pp_semicolon (pp);
3091
3092 newline_and_indent (pp, spc);
3093 pp_string (pp, "for ");
3094 dump_ada_node (pp, TYPE_NAME (node), type, spc, false, true);
3095 pp_string (pp, "_As_Base use record");
3096
3097 int repr_field_num = 0;
3098 for (tree field = TYPE_FIELDS (node); field; field = TREE_CHAIN (field))
3099 if (field_fits_as_base (node, field))
3100 {
3101 if (!DECL_NAME (field) && is_tagged_type (TREE_TYPE (field)))
3102 continue;
3103
3104 repr_field_num++;
3105 const unsigned HOST_WIDE_INT bitpos
3106 = tree_to_uhwi (DECL_FIELD_OFFSET (field)) * BITS_PER_UNIT
3107 + tree_to_uhwi (DECL_FIELD_BIT_OFFSET (field));
3108 const unsigned HOST_WIDE_INT position = bitpos / BITS_PER_UNIT;
3109 const unsigned HOST_WIDE_INT first_bit = bitpos % BITS_PER_UNIT;
3110 const unsigned HOST_WIDE_INT last_bit
3111 = first_bit + tree_to_uhwi (DECL_SIZE (field)) - 1;
3112
3113 newline_and_indent (pp, spc + INDENT_INCR);
3114 if (DECL_NAME (field))
3115 dump_ada_decl_name (pp, field, false);
3116 else if (repr_field_num == 1)
3117 pp_string (pp, "parent");
3118 else
3119 {
3120 char buf[32];
3121 sprintf (buf, "field_%d", repr_field_num);
3122 pp_string (pp, buf);
3123 }
3124 pp_string (pp, " at ");
3125 pp_unsigned_wide_integer (pp, position);
3126 pp_string (pp, " range ");
3127 pp_unsigned_wide_integer (pp, first_bit);
3128 pp_string (pp, " .. ");
3129 pp_unsigned_wide_integer (pp, last_bit);
3130 pp_semicolon (pp);
3131 }
3132
3133 newline_and_indent (pp, spc);
3134 pp_string (pp, "end record;");
3135}
3136
29273137/* Dump the value and object sizes of an empty C++ class. Ada's value size is
29283138 zero so an empty base consumes no storage, while Object_Size preserves the
29293139 byte occupied by a complete C++ object. */
@@ -3992 +4196 @@dump_ada_structure (pretty_printer *pp, tree node, tree type, bool nested,
39924196 sprintf (buf, "field_%d : aliased ", field_num + 1);
39934197 pp_string (pp, buf);
39944198 }
3995 dump_ada_decl_name (pp, TYPE_NAME (TREE_TYPE (tmp)),
3996 false);
4199 dump_ada_record_field_type (pp, tmp);
39974200 pp_semicolon (pp);
39984201 }
39994202
@@ -4119 +4322 @@dump_ada_structure (pretty_printer *pp, tree node, tree type, bool nested,
41194322 pp_newline (pp);
41204323 dump_ada_cpp_layout (pp, node, type, spc,
41214324 cpp_check (node, HAS_VIRTUAL_BASE));
4325
4326 if (needs_virtual_as_base_type (node))
4327 dump_ada_virtual_as_base_type (pp, node, type, spc);
41224328 }
41234329
41244330 /* Print the static fields of the structure, if any. */
gcc/testsuite/g++.dg/ada-spec/virtual-diamond-layout.C +114−0new file
@@ -0 +1 @@
1/* { dg-do compile } */
2/* { dg-require-effective-target lp64 } */
3/* { dg-options "-fdump-ada-spec-slim" } */
4/* { dg-final { scan-file virtual_diamond_layout_c.ads "type Diamond_Left_As_Base" } } */
5/* { dg-final { scan-file virtual_diamond_layout_c.ads "for Diamond_Left_As_Base'Object_Size use 96;" } } */
6/* { dg-final { scan-file virtual_diamond_layout_c.ads "type Diamond_Right_As_Base" } } */
7/* { dg-final { scan-file virtual_diamond_layout_c.ads "for Diamond_Right_As_Base'Object_Size use 96;" } } */
8/* { dg-final { scan-file virtual_diamond_layout_c.ads "parent : aliased Diamond_Left_As_Base;" } } */
9/* { dg-final { scan-file virtual_diamond_layout_c.ads "field_2 : aliased Diamond_Right_As_Base;" } } */
10
11struct Diamond_Root
12{
13 int root_value;
14};
15
16struct Diamond_Left : virtual Diamond_Root
17{
18 int left_value;
19};
20
21struct Diamond_Right : virtual Diamond_Root
22{
23 int right_value;
24};
25
26struct Diamond : Diamond_Left, Diamond_Right
27{
28 int diamond_value;
29 Diamond (int root, int left, int right, int diamond_arg);
30};
31
32Diamond::Diamond (int root, int left, int right, int diamond_arg)
33 : Diamond_Root {root}, Diamond_Left {}, Diamond_Right {},
34 diamond_value {diamond_arg}
35{
36 left_value = left;
37 right_value = right;
38}
39
40extern "C" unsigned long cpp_diamond_root_size ()
41{
42 return sizeof (Diamond_Root);
43}
44
45extern "C" unsigned long cpp_diamond_size ()
46{
47 return sizeof (Diamond);
48}
49
50extern "C" unsigned long cpp_diamond_alignment ()
51{
52 return alignof (Diamond);
53}
54
55extern "C" unsigned long cpp_diamond_left_offset ()
56{
57 Diamond object (0, 0, 0, 0);
58 return reinterpret_cast<char *> (&object.left_value)
59 - reinterpret_cast<char *> (&object);
60}
61
62extern "C" unsigned long cpp_diamond_right_offset ()
63{
64 Diamond object (0, 0, 0, 0);
65 return reinterpret_cast<char *> (&object.right_value)
66 - reinterpret_cast<char *> (&object);
67}
68
69extern "C" unsigned long cpp_diamond_value_offset ()
70{
71 Diamond object (0, 0, 0, 0);
72 return reinterpret_cast<char *> (&object.diamond_value)
73 - reinterpret_cast<char *> (&object);
74}
75
76extern "C" unsigned long cpp_diamond_root_offset ()
77{
78 Diamond object (0, 0, 0, 0);
79 return reinterpret_cast<char *> (&object.root_value)
80 - reinterpret_cast<char *> (&object);
81}
82
83extern "C" Diamond *cpp_diamond_create
84 (int root, int left, int right, int diamond_arg)
85{
86 return new Diamond (root, left, right, diamond_arg);
87}
88
89extern "C" void cpp_diamond_delete (Diamond *object)
90{
91 delete object;
92}
93
94extern "C" int cpp_diamond_root_value (const Diamond *object)
95{
96 return object->root_value;
97}
98
99extern "C" int cpp_diamond_left_value (const Diamond *object)
100{
101 return object->left_value;
102}
103
104extern "C" int cpp_diamond_right_value (const Diamond *object)
105{
106 return object->right_value;
107}
108
109extern "C" int cpp_diamond_value (const Diamond *object)
110{
111 return object->diamond_value;
112}
113
114/* { dg-final { cleanup-ada-spec } } */
115

Tests.

Before the patch
Ada's complete base component types duplicate the virtual root and disagree with the C++ diamond size and visible field offsets.
After the patch
Shortened as-base storage types omit the shared virtual root while preserving both direct-base fields, and Ada and C++ agree at -O0 and -O2.
virtual-diamond-layout.C C++ · 114 lines 
/* { dg-do compile } */
/* { dg-require-effective-target lp64 } */
/* { dg-options "-fdump-ada-spec-slim" } */
/* { dg-final { scan-file virtual_diamond_layout_c.ads "type Diamond_Left_As_Base" } } */
/* { dg-final { scan-file virtual_diamond_layout_c.ads "for Diamond_Left_As_Base'Object_Size use 96;" } } */
/* { dg-final { scan-file virtual_diamond_layout_c.ads "type Diamond_Right_As_Base" } } */
/* { dg-final { scan-file virtual_diamond_layout_c.ads "for Diamond_Right_As_Base'Object_Size use 96;" } } */
/* { dg-final { scan-file virtual_diamond_layout_c.ads "parent : aliased Diamond_Left_As_Base;" } } */
/* { dg-final { scan-file virtual_diamond_layout_c.ads "field_2 : aliased Diamond_Right_As_Base;" } } */

struct Diamond_Root
{
  int root_value;
};

struct Diamond_Left : virtual Diamond_Root
{
  int left_value;
};

struct Diamond_Right : virtual Diamond_Root
{
  int right_value;
};

struct Diamond : Diamond_Left, Diamond_Right
{
  int diamond_value;
  Diamond (int root, int left, int right, int diamond_arg);
};

Diamond::Diamond (int root, int left, int right, int diamond_arg)
  : Diamond_Root {root}, Diamond_Left {}, Diamond_Right {},
    diamond_value {diamond_arg}
{
  left_value = left;
  right_value = right;
}

extern "C" unsigned long cpp_diamond_root_size ()
{
  return sizeof (Diamond_Root);
}

extern "C" unsigned long cpp_diamond_size ()
{
  return sizeof (Diamond);
}

extern "C" unsigned long cpp_diamond_alignment ()
{
  return alignof (Diamond);
}

extern "C" unsigned long cpp_diamond_left_offset ()
{
  Diamond object (0, 0, 0, 0);
  return reinterpret_cast<char *> (&object.left_value)
    - reinterpret_cast<char *> (&object);
}

extern "C" unsigned long cpp_diamond_right_offset ()
{
  Diamond object (0, 0, 0, 0);
  return reinterpret_cast<char *> (&object.right_value)
    - reinterpret_cast<char *> (&object);
}

extern "C" unsigned long cpp_diamond_value_offset ()
{
  Diamond object (0, 0, 0, 0);
  return reinterpret_cast<char *> (&object.diamond_value)
    - reinterpret_cast<char *> (&object);
}

extern "C" unsigned long cpp_diamond_root_offset ()
{
  Diamond object (0, 0, 0, 0);
  return reinterpret_cast<char *> (&object.root_value)
    - reinterpret_cast<char *> (&object);
}

extern "C" Diamond *cpp_diamond_create
  (int root, int left, int right, int diamond_arg)
{
  return new Diamond (root, left, right, diamond_arg);
}

extern "C" void cpp_diamond_delete (Diamond *object)
{
  delete object;
}

extern "C" int cpp_diamond_root_value (const Diamond *object)
{
  return object->root_value;
}

extern "C" int cpp_diamond_left_value (const Diamond *object)
{
  return object->left_value;
}

extern "C" int cpp_diamond_right_value (const Diamond *object)
{
  return object->right_value;
}

extern "C" int cpp_diamond_value (const Diamond *object)
{
  return object->diamond_value;
}

/* { dg-final { cleanup-ada-spec } } */

Download · View in repository

virtual_diamond_layout_consumer.adb Ada · 58 lines 
with Ada.Text_IO;
with Interfaces.C; use Interfaces.C;
with System;
with Virtual_Diamond_Layout_C;

procedure Virtual_Diamond_Layout_Consumer is
   package Bindings renames Virtual_Diamond_Layout_C;
   subtype Diamond is Bindings.Class_Diamond.Diamond;
   Object : access Diamond := Bindings.cpp_diamond_create (11, 22, 33, 44);

   function Bytes (Bits : Natural) return unsigned_long is
     (unsigned_long (Bits / System.Storage_Unit));

   Layout_Matches : constant Boolean :=
     Bytes (Diamond'Object_Size) = Bindings.cpp_diamond_size
     and then unsigned_long (Diamond'Alignment) =
       Bindings.cpp_diamond_alignment
     and then unsigned_long
       (Object.parent'Position + Object.parent.left_value'Position) =
       Bindings.cpp_diamond_left_offset
     and then unsigned_long
       (Object.field_2'Position + Object.field_2.right_value'Position) =
       Bindings.cpp_diamond_right_offset
     and then unsigned_long (Object.diamond_value'Position) =
       Bindings.cpp_diamond_value_offset
     and then unsigned_long (Object.field_4'Position) =
       Bindings.cpp_diamond_root_offset;
begin
   if Object = null
     or else Bytes (Bindings.Diamond_Root'Object_Size) /=
       Bindings.cpp_diamond_root_size
     or else Bindings.cpp_diamond_root_value (Object) /= 11
     or else Bindings.cpp_diamond_left_value (Object) /= 22
     or else Bindings.cpp_diamond_right_value (Object) /= 33
     or else Bindings.cpp_diamond_value (Object) /= 44
   then
      raise Program_Error with "C++ virtual diamond setup differs";
   end if;

   if not Layout_Matches then
      raise Program_Error with "C++ and Ada virtual diamond layouts differ";
   end if;

   Object.parent.left_value := 55;
   Object.field_2.right_value := 66;
   Object.diamond_value := 77;
   Object.field_4.root_value := 88;
   if Bindings.cpp_diamond_left_value (Object) /= 55
     or else Bindings.cpp_diamond_right_value (Object) /= 66
     or else Bindings.cpp_diamond_value (Object) /= 77
     or else Bindings.cpp_diamond_root_value (Object) /= 88
   then
      raise Program_Error with "Ada writes use the wrong diamond layout";
   end if;

   Bindings.cpp_diamond_delete (Object);
   Ada.Text_IO.Put_Line ("MATCH C++ Ada virtual diamond layout");
end Virtual_Diamond_Layout_Consumer;

Download · View in repository

run-test.sh shell · 83 lines 
#!/usr/bin/env bash
set -euo pipefail

if [[ $# -ne 3 ]]; then
  echo "usage: $0 TOOLCHAIN_ROOT GCC_VERSION unpatched|patched" >&2
  exit 2
fi

root=$(cd "$(dirname "${BASH_SOURCE[0]}")/../.." && pwd)
source "$root/scripts/regression-common.sh"
resolve_regression_toolchain "$1"
version=$2
state=$3
[[ "$state" == unpatched || "$state" == patched ]] || {
  echo "error: state must be unpatched or patched" >&2
  exit 2
}

gxx="$REGRESSION_TOOLCHAIN/bin/g++"
cxx="$root/bundles/cxx-ada-virtual-diamond-layout/tests/virtual-diamond-layout.C"
ada="$root/bundles/cxx-ada-virtual-diamond-layout/tests/virtual_diamond_layout_consumer.adb"
work=$(mktemp -d "${TMPDIR:-/tmp}/gnat-cxx-ada-virtual-diamond.XXXXXX")
trap 'rm -rf "$work"' EXIT

for optimization in 0 2; do
  case_dir="$work/O$optimization"
  mkdir -p "$case_dir"
  cp "$cxx" "$ada" "$case_dir/"
  (
    cd "$case_dir"
    "${REGRESSION_ENV[@]}" "$gxx" -c "-O$optimization" \
      -fdump-ada-spec-slim virtual-diamond-layout.C
  )

  spec="$case_dir/virtual_diamond_layout_c.ads"
  if [[ "$state" == unpatched ]]; then
    (
      cd "$case_dir"
      "${REGRESSION_ENV[@]}" "$REGRESSION_GNATMAKE" -q -f \
        "-O$optimization" virtual_diamond_layout_consumer.adb \
        -largs virtual-diamond-layout.o -lstdc++
    ) >"$case_dir/build.log" 2>&1
    set +e
    (
      cd "$case_dir"
      "${REGRESSION_ENV[@]}" ./virtual_diamond_layout_consumer
    ) >"$case_dir/output.log" 2>&1
    status=$?
    set -e
    [[ $status -ne 0 ]] || {
      echo "error: unpatched virtual diamond layout matched" >&2
      exit 1
    }
    grep -Fq 'C++ and Ada virtual diamond layouts differ' \
      "$case_dir/output.log"
    if grep -Fq "type Diamond_Left_As_Base" "$spec"; then
      echo "error: unpatched mapper unexpectedly emitted as-base storage" >&2
      exit 1
    fi
    echo "cxx-ada-virtual-diamond-layout -O$optimization: expected mismatch (GCC $version)"
    continue
  fi

  (
    cd "$case_dir"
    "${REGRESSION_ENV[@]}" "$REGRESSION_GNATMAKE" -q -f \
      "-O$optimization" virtual_diamond_layout_consumer.adb \
      -largs virtual-diamond-layout.o -lstdc++
    "${REGRESSION_ENV[@]}" ./virtual_diamond_layout_consumer
  ) >"$case_dir/output.log" 2>&1 || {
    cat "$case_dir/output.log"
    exit 1
  }

  grep -F "type Diamond_Left_As_Base" "$spec"
  grep -F "for Diamond_Left_As_Base'Object_Size use" "$spec"
  grep -F "type Diamond_Right_As_Base" "$spec"
  grep -F "for Diamond_Right_As_Base'Object_Size use" "$spec"
  grep -F "parent : aliased Diamond_Left_As_Base" "$spec"
  grep -F "field_2 : aliased Diamond_Right_As_Base" "$spec"
  grep -Fx "MATCH C++ Ada virtual diamond layout" "$case_dir/output.log"
  echo "cxx-ada-virtual-diamond-layout -O$optimization: patched (GCC $version)"
done

Download · View in repository

Commands.

Apply the patch
patch --fuzz=0 -p1 -i bundles/cxx-ada-virtual-diamond-layout/patches/VARIANT.patch
Build the compiler
PATH=/path/to/bootstrap/bin:$PATH ./scripts/build-gnat.sh SOURCE BUILD INSTALL
Run the regression
./scripts/run-regressions.sh INSTALL 1.2.0 GCC_MAJOR patched

Metadata.

Affected releases
  • 13.2.0
  • 14.2.0
  • 15.3.0
  • 16.1.0
  • 16.2.0
Known-good releases

None.

Files modified
  • gcc/c-family/c-ada-spec.cc
  • gcc/testsuite/g++.dg/ada-spec/virtual-diamond-layout.C
Regression tests
  • gcc/testsuite/g++.dg/ada-spec/virtual-diamond-layout.C
Before the patch
Ada's complete base component types duplicate the virtual root and disagree with the C++ diamond size and visible field offsets.
After the patch
Shortened as-base storage types omit the shared virtual root while preserving both direct-base fields, and Ada and C++ agree at -O0 and -O2.
Upstream issue
Pending GCC Bugzilla filing.
Upstream submission
Not yet filed or submitted upstream.
Provenance
Repository-authored GCC patch and executable regression; exact application verified locally against the pinned Darwin patchset inputs. Pinned FSF release application is required by Linux CI.
Licensing
GCC-derived compiler hunks remain GPL-3.0-or-later. The new test is proposed for the GCC testsuite under GCC project terms.
Repository fixture
bundles/cxx-ada-virtual-diamond-layout/tests/virtual-diamond-layout.C
Fixture SHA-256
7184d760ac39122366a2cf12ec337b417244147ac5303de2bc413aa344c9148e
Test runner
bundles/cxx-ada-virtual-diamond-layout/run-test.sh