cxx-ada-template-record-termination

C++ Ada template record termination

The C++ Ada spec dumper omits the terminating semicolon from trivial record declarations emitted for concrete class-template instances.

AcceptedApplies standaloneSince 1.2.0

Bundle JSON Repository directory

Where it applies.

How each patchset treats this bundle on each GCC major
PatchsetGCC 13GCC 14GCC 15GCC 16
1.2.0 (latest)Patchedgcc-13-1413.2.0Patchedgcc-13-1414.2.0Patchedgcc-15-1615.3.0Patchedgcc-15-1616.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.

dump_ada_template writes concrete class-template instances inside nested Ada packages. For trivial records, dump_ada_structure deliberately leaves the terminating semicolon to its caller, but the template caller did not add it. The resulting aspect ends at C_Pass_By_Copy and GNAT rejects the generated specification.

A minimal offending declaration is a trivial concrete template instance:

template <typename T>
struct Plain { T value; };

template struct Plain<int>;

The unpatched mapper produces an unterminated record declaration:

package Plain_int is
   type Plain is limited record
      value : aliased int;
   end record
   with Convention => C_Pass_By_Copy
end;

The corrected output terminates the representation aspect before the package continues:

package Plain_int is
   type Plain is limited record
      value : aliased int;
   end record
   with Convention => C_Pass_By_Copy;
end;

The patch terminates records only when the structure printer did not already do so while emitting methods or static fields. The executable regression covers the shared path with primary, partial-specialization, full-specialization, nested, constrained, and template-template instances.

Run it against an unpatched or patched compiler root:

./bundles/cxx-ada-template-record-termination/run-test.sh \
  TOOLCHAIN_ROOT GCC_VERSION unpatched
./bundles/cxx-ada-template-record-termination/run-test.sh \
  TOOLCHAIN_ROOT GCC_VERSION patched

Patch.

Variant gcc-13-14

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

+77 −0 2 files

SHA-256
d3e4f3784943166957eb53b8ec5031f91eedc4946b272e6122149625cf06a8ae
Patch
bundles/cxx-ada-template-record-termination/patches/gcc-13-14.patch

Download the patch

gcc/c-family/c-ada-spec.cc +2−0modified
@@ -1917 +1917 @@dump_ada_template (pretty_printer *buffer, tree t, int spc)
19171917 pp_string (buffer, " is limited ");
19181918
19191919 dump_ada_node (buffer, instance, t, spc, false, false);
1920 if (!has_nontrivial_methods (instance) && !has_static_fields (instance))
1921 pp_semicolon (buffer);
19201922 pp_newline (buffer);
19211923 spc -= INDENT_INCR;
19221924 newline_and_indent (buffer, spc);
gcc/testsuite/g++.dg/ada-spec/template-record-termination.C +75−0new file
@@ -0 +1 @@
1/* { dg-do compile } */
2/* { dg-options "-std=gnu++20 -fdump-ada-spec-slim" } */
3/* { dg-final { scan-file template_record_termination_c.ads "with Convention => C_Pass_By_Copy;" } } */
4
5template <typename T>
6struct Plain
7{
8 T value;
9};
10
11template struct Plain<int>;
12
13template <typename T, bool Select>
14struct Choice;
15
16template <typename T>
17struct Choice<T, false>
18{
19 T value;
20};
21
22template struct Choice<int, false>;
23
24template <typename T>
25struct Specialized
26{
27 T value;
28};
29
30template <>
31struct Specialized<bool>
32{
33 unsigned value;
34};
35
36using Bool_Specialized = Specialized<bool>;
37
38template <typename T>
39struct Outer
40{
41 template <typename U>
42 struct Inner
43 {
44 U value;
45 };
46};
47
48template struct Outer<int>;
49
50template <typename T>
51concept Integral_Sized = sizeof (T) >= sizeof (int);
52
53template <Integral_Sized T>
54struct Constrained
55{
56 T value;
57};
58
59template struct Constrained<int>;
60
61template <typename T>
62struct Item
63{
64 T value;
65};
66
67template <template <typename> class Container, typename T>
68struct Wrapper
69{
70 Container<T> item;
71};
72
73template struct Wrapper<Item, int>;
74
75/* { dg-final { cleanup-ada-spec } } */
76

Variant gcc-15-16

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

+77 −0 2 files

SHA-256
410ff115e39d1b6f9e3f5c31c3bebec41e2f10cf2d2641b0e78b1e2f0ba31ef7
Patch
bundles/cxx-ada-template-record-termination/patches/gcc-15-16.patch

Download the patch

gcc/c-family/c-ada-spec.cc +2−0modified
@@ -1964 +1964 @@dump_ada_template (pretty_printer *pp, tree t, int spc)
19641964 pp_string (pp, " is limited ");
19651965
19661966 dump_ada_node (pp, instance, t, spc, false, false);
1967 if (!has_nontrivial_methods (instance) && !has_static_fields (instance))
1968 pp_semicolon (pp);
19671969 pp_newline (pp);
19681970 spc -= INDENT_INCR;
19691971 newline_and_indent (pp, spc);
gcc/testsuite/g++.dg/ada-spec/template-record-termination.C +75−0new file
@@ -0 +1 @@
1/* { dg-do compile } */
2/* { dg-options "-std=gnu++20 -fdump-ada-spec-slim" } */
3/* { dg-final { scan-file template_record_termination_c.ads "with Convention => C_Pass_By_Copy;" } } */
4
5template <typename T>
6struct Plain
7{
8 T value;
9};
10
11template struct Plain<int>;
12
13template <typename T, bool Select>
14struct Choice;
15
16template <typename T>
17struct Choice<T, false>
18{
19 T value;
20};
21
22template struct Choice<int, false>;
23
24template <typename T>
25struct Specialized
26{
27 T value;
28};
29
30template <>
31struct Specialized<bool>
32{
33 unsigned value;
34};
35
36using Bool_Specialized = Specialized<bool>;
37
38template <typename T>
39struct Outer
40{
41 template <typename U>
42 struct Inner
43 {
44 U value;
45 };
46};
47
48template struct Outer<int>;
49
50template <typename T>
51concept Integral_Sized = sizeof (T) >= sizeof (int);
52
53template <Integral_Sized T>
54struct Constrained
55{
56 T value;
57};
58
59template struct Constrained<int>;
60
61template <typename T>
62struct Item
63{
64 T value;
65};
66
67template <template <typename> class Container, typename T>
68struct Wrapper
69{
70 Container<T> item;
71};
72
73template struct Wrapper<Item, int>;
74
75/* { dg-final { cleanup-ada-spec } } */
76

Tests.

Before the patch
GNAT rejects the generated Ada specification at the unterminated C_Pass_By_Copy aspect.
After the patch
Every generated template record is terminated and the Ada consumer compiles at -O0 and -O2.
template-record-termination.C C++ · 75 lines 
/* { dg-do compile } */
/* { dg-options "-std=gnu++20 -fdump-ada-spec-slim" } */
/* { dg-final { scan-file template_record_termination_c.ads "with Convention => C_Pass_By_Copy;" } } */

template <typename T>
struct Plain
{
  T value;
};

template struct Plain<int>;

template <typename T, bool Select>
struct Choice;

template <typename T>
struct Choice<T, false>
{
  T value;
};

template struct Choice<int, false>;

template <typename T>
struct Specialized
{
  T value;
};

template <>
struct Specialized<bool>
{
  unsigned value;
};

using Bool_Specialized = Specialized<bool>;

template <typename T>
struct Outer
{
  template <typename U>
  struct Inner
  {
    U value;
  };
};

template struct Outer<int>;

template <typename T>
concept Integral_Sized = sizeof (T) >= sizeof (int);

template <Integral_Sized T>
struct Constrained
{
  T value;
};

template struct Constrained<int>;

template <typename T>
struct Item
{
  T value;
};

template <template <typename> class Container, typename T>
struct Wrapper
{
  Container<T> item;
};

template struct Wrapper<Item, int>;

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

Download · View in repository

template_record_termination_consumer.adb Ada · 6 lines 
with Template_Record_Termination_C;

procedure Template_Record_Termination_Consumer is
begin
   null;
end Template_Record_Termination_Consumer;

Download · View in repository

run-test.sh shell · 78 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++"
[[ -x "$gxx" ]] || {
  echo "error: no g++ in $REGRESSION_TOOLCHAIN" >&2
  exit 1
}

cxx_fixture="$root/bundles/cxx-ada-template-record-termination/tests/template-record-termination.C"
ada_fixture="$root/bundles/cxx-ada-template-record-termination/tests/template_record_termination_consumer.adb"
work=$(mktemp -d "${TMPDIR:-/tmp}/gnat-cxx-ada-template-record-test.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=gnu++20 -c "-O$optimization" \
      -fdump-ada-spec-slim template-record-termination.C
  )

  spec="$case_dir/template_record_termination_c.ads"
  [[ -f "$spec" ]] || {
    echo "error: g++ did not generate $spec" >&2
    exit 1
  }

  set +e
  (
    cd "$case_dir"
    "${REGRESSION_ENV[@]}" "$REGRESSION_GNATMAKE" -q -f \
      "-O$optimization" -c template_record_termination_consumer.adb
  ) >"$case_dir/build.log" 2>&1
  build_status=$?
  set -e

  if [[ "$state" == unpatched ]]; then
    [[ $build_status -ne 0 ]] || {
      echo "error: unpatched template record regression unexpectedly compiled at -O$optimization" >&2
      exit 1
    }
    grep -Eiq 'missing.*;|aspect.*requires|declaration expected' "$case_dir/build.log" || {
      cat "$case_dir/build.log"
      exit 1
    }
    echo "cxx-ada-template-record-termination -O$optimization: expected rejection (GCC $version)"
    continue
  fi

  [[ $build_status -eq 0 ]] || {
    cat "$case_dir/build.log"
    exit 1
  }
  count=$(grep -Fc "with Convention => C_Pass_By_Copy;" "$spec")
  [[ $count -eq 7 ]] || {
    echo "error: expected 7 terminated template records, found $count" >&2
    exit 1
  }
  echo "cxx-ada-template-record-termination -O$optimization: patched (GCC $version)"
done

Download · View in repository

Commands.

Apply the patch
patch --fuzz=0 -p1 -i bundles/cxx-ada-template-record-termination/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/template-record-termination.C
Regression tests
  • gcc/testsuite/g++.dg/ada-spec/template-record-termination.C
Before the patch
GNAT rejects the generated Ada specification at the unterminated C_Pass_By_Copy aspect.
After the patch
Every generated template record is terminated and the Ada consumer compiles 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 release identities. 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-template-record-termination/tests/template-record-termination.C
Fixture SHA-256
c8497f40d88ee08980eb6d7414f8a01c95e81161974093fee81d2adc6dde4f13
Test runner
bundles/cxx-ada-template-record-termination/run-test.sh