C++ Ada empty-class storage

/* { dg-do compile } */
/* { dg-require-effective-target lp64 } */
/* { dg-options "-std=c++20 -fdump-ada-spec-slim" } */
/* { dg-final { scan-file empty_class_storage_c.ads "for Empty'Size use 0;" } } */
/* { dg-final { scan-file empty_class_storage_c.ads "for Empty'Object_Size use 8;" } } */
/* { dg-final { scan-file-not empty_class_storage_c.ads "parent : aliased Empty_Base;" } } */
/* { dg-final { scan-file-not empty_class_storage_c.ads "ignored : aliased Empty;" } } */
/* { dg-final { scan-file empty_class_storage_c.ads "first : aliased Empty;" } } */
/* { dg-final { scan-file empty_class_storage_c.ads "second : aliased Empty;" } } */

struct Empty
{};

struct Empty_Base
{};

struct With_Empty_Base : Empty_Base
{
  int value;
};

struct With_Empty_Member
{
  Empty member;
  int value;
};

struct With_Empty_Array
{
  Empty values[3];
};

struct With_No_Unique_Address
{
  [[no_unique_address]] Empty ignored;
  int value;
};

struct With_Repeated_No_Unique_Address
{
  [[no_unique_address]] Empty first;
  [[no_unique_address]] Empty second;
};

struct Method_Empty
{
  Method_Empty ();
  void ping ();
};

Method_Empty::Method_Empty () {}
void Method_Empty::ping () {}

extern "C" unsigned long cpp_empty_size () { return sizeof (Empty); }
extern "C" unsigned long cpp_empty_align () { return alignof (Empty); }
extern "C" unsigned long cpp_method_empty_size ()
{
  return sizeof (Method_Empty);
}

extern "C" unsigned long
cpp_with_empty_base_size ()
{
  return sizeof (With_Empty_Base);
}

extern "C" unsigned long
cpp_with_empty_base_value_offset ()
{
  return __builtin_offsetof (With_Empty_Base, value);
}

extern "C" unsigned long
cpp_with_empty_member_size ()
{
  return sizeof (With_Empty_Member);
}

extern "C" unsigned long
cpp_with_empty_member_member_offset ()
{
  return __builtin_offsetof (With_Empty_Member, member);
}

extern "C" unsigned long
cpp_with_empty_member_value_offset ()
{
  return __builtin_offsetof (With_Empty_Member, value);
}

extern "C" unsigned long
cpp_with_empty_array_size ()
{
  return sizeof (With_Empty_Array);
}

extern "C" unsigned long
cpp_with_empty_array_values_offset ()
{
  return __builtin_offsetof (With_Empty_Array, values);
}

extern "C" unsigned long
cpp_with_no_unique_address_size ()
{
  return sizeof (With_No_Unique_Address);
}

extern "C" unsigned long
cpp_with_no_unique_address_value_offset ()
{
  return __builtin_offsetof (With_No_Unique_Address, value);
}

extern "C" unsigned long
cpp_with_no_unique_address_ignored_offset ()
{
  return __builtin_offsetof (With_No_Unique_Address, ignored);
}

extern "C" unsigned long
cpp_with_repeated_no_unique_address_size ()
{
  return sizeof (With_Repeated_No_Unique_Address);
}

extern "C" unsigned long
cpp_with_repeated_no_unique_address_first_offset ()
{
  return __builtin_offsetof (With_Repeated_No_Unique_Address, first);
}

extern "C" unsigned long
cpp_with_repeated_no_unique_address_second_offset ()
{
  return __builtin_offsetof (With_Repeated_No_Unique_Address, second);
}

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

with Ada.Text_IO;
with Empty_Class_Storage_C;
with Interfaces.C; use Interfaces.C;
with System;

procedure Empty_Class_Storage_Consumer is
   package Bindings renames Empty_Class_Storage_C;
   With_Base : Bindings.With_Empty_Base;
   With_Member : Bindings.With_Empty_Member;
   With_Array : Bindings.With_Empty_Array;
   With_NUA : Bindings.With_No_Unique_Address;
   With_Repeated_NUA : Bindings.With_Repeated_No_Unique_Address;

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

   procedure Report (Label : String; Matches : Boolean) is
   begin
      Ada.Text_IO.Put_Line (Label & (if Matches then " MATCH" else " MISMATCH"));
   end Report;
begin
   Report
     ("EMPTY",
      Bindings.Empty'Size = 0
      and then Bytes (Bindings.Empty'Object_Size) = Bindings.cpp_empty_size
      and then unsigned_long (Bindings.Empty'Alignment) =
        Bindings.cpp_empty_align);

   Report
     ("METHOD_EMPTY",
      Bytes (Bindings.Class_Method_Empty.Method_Empty'Object_Size) =
        Bindings.cpp_method_empty_size);

   Report
     ("EBO",
      Bytes (Bindings.With_Empty_Base'Object_Size) =
        Bindings.cpp_with_empty_base_size
      and then unsigned_long (With_Base.value'Position) =
        Bindings.cpp_with_empty_base_value_offset);

   Report
     ("MEMBER",
      Bytes (Bindings.With_Empty_Member'Object_Size) =
        Bindings.cpp_with_empty_member_size
      and then unsigned_long (With_Member.member'Position) =
        Bindings.cpp_with_empty_member_member_offset
      and then unsigned_long (With_Member.value'Position) =
        Bindings.cpp_with_empty_member_value_offset);

   Report
     ("ARRAY",
      Bytes (Bindings.With_Empty_Array'Object_Size) =
        Bindings.cpp_with_empty_array_size
      and then unsigned_long (With_Array.values'Position) =
        Bindings.cpp_with_empty_array_values_offset);

   Report
     ("NO_UNIQUE_ADDRESS",
      Bytes (Bindings.With_No_Unique_Address'Object_Size) =
        Bindings.cpp_with_no_unique_address_size
      and then unsigned_long (With_NUA.value'Position) =
        Bindings.cpp_with_no_unique_address_value_offset);

   Report
     ("REPEATED_NO_UNIQUE_ADDRESS",
      Bytes (Bindings.With_Repeated_No_Unique_Address'Object_Size) =
        Bindings.cpp_with_repeated_no_unique_address_size
      and then unsigned_long (With_Repeated_NUA.first'Position) =
        Bindings.cpp_with_repeated_no_unique_address_first_offset
      and then unsigned_long (With_Repeated_NUA.second'Position) =
        Bindings.cpp_with_repeated_no_unique_address_second_offset);
end Empty_Class_Storage_Consumer;

#!/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++"
[[ -x "$gxx" ]] || {
  echo "error: no g++ in $REGRESSION_TOOLCHAIN" >&2
  exit 1
}

cxx_fixture="$root/bundles/cxx-ada-empty-class-storage/tests/empty-class-storage.C"
ada_fixture="$root/bundles/cxx-ada-empty-class-storage/tests/empty_class_storage_consumer.adb"
work=$(mktemp -d "${TMPDIR:-/tmp}/gnat-cxx-ada-empty-storage.XXXXXX")
trap 'rm -rf "$work"' EXIT

for optimization in 0 2; do
  case_dir="$work/O$optimization"
  mkdir -p "$case_dir"
  cp "$cxx_fixture" "$ada_fixture" "$case_dir/"
  (
    cd "$case_dir"
    "${REGRESSION_ENV[@]}" "$gxx" -std=c++20 -c "-O$optimization" \
      -fdump-ada-spec-slim empty-class-storage.C
    "${REGRESSION_ENV[@]}" "$REGRESSION_GNATMAKE" -q -f \
      "-O$optimization" empty_class_storage_consumer.adb \
      -largs empty-class-storage.o -lstdc++
    "${REGRESSION_ENV[@]}" ./empty_class_storage_consumer
  ) >"$case_dir/output.log" 2>&1 || {
    cat "$case_dir/output.log"
    exit 1
  }

  spec="$case_dir/empty_class_storage_c.ads"
  if [[ "$state" == unpatched ]]; then
    grep -Fx "EMPTY MISMATCH" "$case_dir/output.log"
    grep -Fx "METHOD_EMPTY MATCH" "$case_dir/output.log"
    grep -Fx "EBO MATCH" "$case_dir/output.log"
    grep -Fx "MEMBER MISMATCH" "$case_dir/output.log"
    grep -Fx "ARRAY MATCH" "$case_dir/output.log"
    grep -Fx "NO_UNIQUE_ADDRESS MATCH" "$case_dir/output.log"
    grep -Fx "REPEATED_NO_UNIQUE_ADDRESS MISMATCH" "$case_dir/output.log"
    if grep -Fq "for Empty'Object_Size use" "$spec"; then
      echo "error: unpatched mapper unexpectedly emitted empty-class size" >&2
      exit 1
    fi
    echo "cxx-ada-empty-class-storage -O$optimization: expected mismatches (GCC $version)"
    continue
  fi

  grep -F "for Empty'Size use 0;" "$spec"
  grep -F "for Empty'Object_Size use 8;" "$spec"
  if grep -Fq "parent : aliased Empty_Base;" "$spec"; then
    echo "error: patched mapper retained an artificial empty base field" >&2
    exit 1
  fi
  if grep -Fq "ignored : aliased Empty;" "$spec"; then
    echo "error: patched mapper retained an overlapping no_unique_address field" >&2
    exit 1
  fi
  grep -F "first : aliased Empty;" "$spec"
  grep -F "second : aliased Empty;" "$spec"
  grep -Fx "EMPTY MATCH" "$case_dir/output.log"
  grep -Fx "METHOD_EMPTY MATCH" "$case_dir/output.log"
  grep -Fx "EBO MATCH" "$case_dir/output.log"
  grep -Fx "MEMBER MATCH" "$case_dir/output.log"
  grep -Fx "ARRAY MATCH" "$case_dir/output.log"
  grep -Fx "NO_UNIQUE_ADDRESS MATCH" "$case_dir/output.log"
  grep -Fx "REPEATED_NO_UNIQUE_ADDRESS MATCH" "$case_dir/output.log"
  echo "cxx-ada-empty-class-storage -O$optimization: patched (GCC $version)"
done