cxx-ada-profile-formal-type-names

C++ Ada profile formal/type names

A C++ formal parameter can hide a type used later in the generated Ada subprogram profile, causing GNAT to reject the binding.

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.

Ada formal parameters are visible throughout the rest of their subprogram profile. A parameter therefore cannot have the same case-insensitive name as a type used by a later parameter or by the result subtype.

This C++ uses all three affected forms: a constructor result, a function result, and a later formal parameter type:

struct Result { int value; };
struct Widget
{
  Widget (int widget);
  int value;
};

extern "C" Result *make_result (int result);
extern "C" int inspect (int result, Result *item);

The unpatched mapper checks a formal only against that formal's own type and produces illegal Ada profiles:

function New_Widget (widget : int) return Widget;
function make_result (result : int) return access Result;
function inspect (result : int; item : access Result) return int;

GNAT rejects these because widget hides Widget and result hides Result. The corrected mapper compares each formal's converted Ada name with every type from that point to the end of the profile, including the result, and prefixes only a colliding formal:

function New_Widget (the_widget : int) return Widget;
function make_result (the_result : int) return access Result;
function inspect (the_result : int; item : access Result) return int;

The executable regression runs at -O0 and -O2. Stock GCC must generate a binding that GNAT rejects with the profile visibility error. With the patch, Ada creates a C++ result object, passes it through the later-type profile, checks the computed value, and releases it through C++.

Patch.

Variant gcc-13-14

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

+91 −1 2 files

SHA-256
5b610371119c0263e5509fc35a66d05b2cf0379e6ae533c0e55befcdf7e06835
Patch
bundles/cxx-ada-profile-formal-type-names/patches/gcc-13-14.patch

Download the patch

gcc/c-family/c-ada-spec.cc +56−1modified
@@ -1680 +1680 @@dump_ada_import (pretty_printer *buffer, tree t, int spc)
16801680 pp_string (buffer, "\";");
16811681}
16821682
1683/* Return true if NAME and TYPE use the same Ada identifier. Strip anonymous
1684 pointer and reference layers because the generated profile names their
1685 designated type directly. */
1686
1687static bool
1688identifier_matches_type (tree name, tree type)
1689{
1690 if (!name || !type || type == error_mark_node)
1691 return false;
1692
1693 while ((TREE_CODE (type) == POINTER_TYPE
1694 || TREE_CODE (type) == REFERENCE_TYPE)
1695 && !TYPE_NAME (type))
1696 type = TREE_TYPE (type);
1697
1698 if (TREE_CODE (type) == FUNCTION_TYPE || !TYPE_NAME (type))
1699 return false;
1700
1701 tree type_name_node = TYPE_NAME (type);
1702 if (TREE_CODE (type_name_node) == TYPE_DECL)
1703 type_name_node = DECL_NAME (type_name_node);
1704 if (!type_name_node || TREE_CODE (type_name_node) != IDENTIFIER_NODE)
1705 return false;
1706
1707 char *decl_ada = to_ada_name (IDENTIFIER_POINTER (name), NULL);
1708 char *type_ada = to_ada_name (IDENTIFIER_POINTER (type_name_node), NULL);
1709 const bool matches = !strcasecmp (decl_ada, type_ada);
1710 free (decl_ada);
1711 free (type_ada);
1712 return matches;
1713}
1714
16831715/* Check whether T and its type have different names, and append "the_"
16841716 otherwise in BUFFER. */
16851717
@@ -1709 +1741 @@check_type_name_conflict (pretty_printer *buffer, tree t)
17091741 }
17101742}
17111743
1744/* Return true if PARAMETER would hide a type used by its own or a later
1745 profile element. Ada formal parameters are visible through the remainder
1746 of the profile, including its return type. */
1747
1748static bool
1749parameter_name_conflicts_with_profile (tree parameter, tree func,
1750 bool is_constructor)
1751{
1752 tree name = DECL_NAME (parameter);
1753 if (!name)
1754 return false;
1755
1756 for (tree arg = parameter; arg; arg = DECL_CHAIN (arg))
1757 if (identifier_matches_type (name, TREE_TYPE (arg)))
1758 return true;
1759
1760 tree return_type = is_constructor
1761 ? DECL_CONTEXT (func) : TREE_TYPE (TREE_TYPE (func));
1762 return identifier_matches_type (name, return_type);
1763}
1764
17121765/* Dump in BUFFER a function declaration FUNC in Ada syntax.
17131766 IS_METHOD indicates whether FUNC is a C++ method.
17141767 IS_CONSTRUCTOR whether FUNC is a C++ constructor.
@@ -1786 +1839 @@dump_ada_function_declaration (pretty_printer *buffer, tree func,
17861839 {
17871840 if (DECL_NAME (arg))
17881841 {
1789 check_type_name_conflict (buffer, arg);
1842 if (parameter_name_conflicts_with_profile (arg, func,
1843 is_constructor))
1844 pp_string (buffer, "the_");
17901845 pp_ada_tree_identifier (buffer, DECL_NAME (arg), NULL_TREE,
17911846 false);
17921847 pp_string (buffer, " : ");
gcc/testsuite/g++.dg/ada-spec/profile-formal-type-names.C +35−0new file
@@ -0 +1 @@
1/* { dg-do compile } */
2/* { dg-options "-fdump-ada-spec-slim" } */
3/* { dg-final { scan-file profile_formal_type_names_c.ads "function New_Widget \(the_widget : int\)" } } */
4/* { dg-final { scan-file profile_formal_type_names_c.ads "function make_result \(the_result : int\)" } } */
5/* { dg-final { scan-file profile_formal_type_names_c.ads "function inspect \(the_result : int; item : access Result\)" } } */
6
7struct Result
8{
9 int value;
10};
11
12struct Widget
13{
14 Widget (int widget);
15 int value;
16};
17
18Widget::Widget (int widget) : value (widget) {}
19
20extern "C" Result *make_result (int result)
21{
22 return new Result { result };
23}
24
25extern "C" int inspect (int result, Result *item)
26{
27 return result + item->value;
28}
29
30extern "C" void delete_result (Result *item)
31{
32 delete item;
33}
34
35/* { dg-final { cleanup-ada-spec } } */
36

Variant gcc-15-16

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

+91 −1 2 files

SHA-256
ee55fac0a61b8704e6286b09b0fae2f0a9c63cbf40e978759f715d0b25d376a5
Patch
bundles/cxx-ada-profile-formal-type-names/patches/gcc-15-16.patch

Download the patch

gcc/c-family/c-ada-spec.cc +56−1modified
@@ -1734 +1734 @@dump_ada_import (pretty_printer *pp, tree t, int spc)
17341734 pp_string (pp, "\";");
17351735}
17361736
1737/* Return true if NAME and TYPE use the same Ada identifier. Strip anonymous
1738 pointer and reference layers because the generated profile names their
1739 designated type directly. */
1740
1741static bool
1742identifier_matches_type (tree name, tree type)
1743{
1744 if (!name || !type || type == error_mark_node)
1745 return false;
1746
1747 while ((TREE_CODE (type) == POINTER_TYPE
1748 || TREE_CODE (type) == REFERENCE_TYPE)
1749 && !TYPE_NAME (type))
1750 type = TREE_TYPE (type);
1751
1752 if (TREE_CODE (type) == FUNCTION_TYPE || !TYPE_NAME (type))
1753 return false;
1754
1755 tree type_name_node = TYPE_NAME (type);
1756 if (TREE_CODE (type_name_node) == TYPE_DECL)
1757 type_name_node = DECL_NAME (type_name_node);
1758 if (!type_name_node || TREE_CODE (type_name_node) != IDENTIFIER_NODE)
1759 return false;
1760
1761 char *decl_ada = to_ada_name (IDENTIFIER_POINTER (name), NULL);
1762 char *type_ada = to_ada_name (IDENTIFIER_POINTER (type_name_node), NULL);
1763 const bool matches = !strcasecmp (decl_ada, type_ada);
1764 free (decl_ada);
1765 free (type_ada);
1766 return matches;
1767}
1768
17371769/* Check whether T and its type have different names, and append "the_"
17381770 otherwise in PP. */
17391771
@@ -1765 +1797 @@check_type_name_conflict (pretty_printer *pp, tree t)
17651797 }
17661798}
17671799
1800/* Return true if PARAMETER would hide a type used by its own or a later
1801 profile element. Ada formal parameters are visible through the remainder
1802 of the profile, including its return type. */
1803
1804static bool
1805parameter_name_conflicts_with_profile (tree parameter, tree func,
1806 bool is_constructor)
1807{
1808 tree name = DECL_NAME (parameter);
1809 if (!name)
1810 return false;
1811
1812 for (tree arg = parameter; arg; arg = DECL_CHAIN (arg))
1813 if (identifier_matches_type (name, TREE_TYPE (arg)))
1814 return true;
1815
1816 tree return_type = is_constructor
1817 ? DECL_CONTEXT (func) : TREE_TYPE (TREE_TYPE (func));
1818 return identifier_matches_type (name, return_type);
1819}
1820
17681821/* Dump in PP a function declaration FUNC in Ada syntax.
17691822 IS_METHOD indicates whether FUNC is a C++ method.
17701823 IS_CONSTRUCTOR whether FUNC is a C++ constructor.
@@ -1842 +1895 @@dump_ada_function_declaration (pretty_printer *pp, tree func,
18421895 {
18431896 if (DECL_NAME (arg))
18441897 {
1845 check_type_name_conflict (pp, arg);
1898 if (parameter_name_conflicts_with_profile (arg, func,
1899 is_constructor))
1900 pp_string (pp, "the_");
18461901 pp_ada_tree_identifier (pp, DECL_NAME (arg), NULL_TREE,
18471902 false);
18481903 pp_string (pp, " : ");
gcc/testsuite/g++.dg/ada-spec/profile-formal-type-names.C +35−0new file
@@ -0 +1 @@
1/* { dg-do compile } */
2/* { dg-options "-fdump-ada-spec-slim" } */
3/* { dg-final { scan-file profile_formal_type_names_c.ads "function New_Widget \(the_widget : int\)" } } */
4/* { dg-final { scan-file profile_formal_type_names_c.ads "function make_result \(the_result : int\)" } } */
5/* { dg-final { scan-file profile_formal_type_names_c.ads "function inspect \(the_result : int; item : access Result\)" } } */
6
7struct Result
8{
9 int value;
10};
11
12struct Widget
13{
14 Widget (int widget);
15 int value;
16};
17
18Widget::Widget (int widget) : value (widget) {}
19
20extern "C" Result *make_result (int result)
21{
22 return new Result { result };
23}
24
25extern "C" int inspect (int result, Result *item)
26{
27 return result + item->value;
28}
29
30extern "C" void delete_result (Result *item)
31{
32 delete item;
33}
34
35/* { dg-final { cleanup-ada-spec } } */
36

Tests.

Before the patch
GNAT rejects a constructor, result-returning function, and later-formal profile because an earlier formal hides an Ada type name.
After the patch
Only formals that hide their own or a later profile type receive a stable the_ prefix, and the generated binding compiles, links, and executes at -O0 and -O2.
profile-formal-type-names.C C++ · 35 lines 
/* { dg-do compile } */
/* { dg-options "-fdump-ada-spec-slim" } */
/* { dg-final { scan-file profile_formal_type_names_c.ads "function New_Widget \(the_widget : int\)" } } */
/* { dg-final { scan-file profile_formal_type_names_c.ads "function make_result \(the_result : int\)" } } */
/* { dg-final { scan-file profile_formal_type_names_c.ads "function inspect \(the_result : int; item : access Result\)" } } */

struct Result
{
  int value;
};

struct Widget
{
  Widget (int widget);
  int value;
};

Widget::Widget (int widget) : value (widget) {}

extern "C" Result *make_result (int result)
{
  return new Result { result };
}

extern "C" int inspect (int result, Result *item)
{
  return result + item->value;
}

extern "C" void delete_result (Result *item)
{
  delete item;
}

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

Download · View in repository

profile_formal_type_names_consumer.adb Ada · 15 lines 
with Ada.Text_IO;
with Profile_Formal_Type_Names_C;
with Interfaces.C; use Interfaces.C;

procedure Profile_Formal_Type_Names_Consumer is
   package Bindings renames Profile_Formal_Type_Names_C;
   Object : access Bindings.Result := Bindings.make_result (41);
begin
   if Object = null or else Bindings.inspect (7, Object) /= 48 then
      raise Program_Error with "profile formal/type collision changed result";
   end if;

   Bindings.delete_result (Object);
   Ada.Text_IO.Put_Line ("MATCH profile formal and type names");
end Profile_Formal_Type_Names_Consumer;

Download · View in repository

run-test.sh shell · 35 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 ]] || exit 2
gxx="$REGRESSION_TOOLCHAIN/bin/g++"
cxx="$root/bundles/cxx-ada-profile-formal-type-names/tests/profile-formal-type-names.C"
ada="$root/bundles/cxx-ada-profile-formal-type-names/tests/profile_formal_type_names_consumer.adb"
work=$(mktemp -d "${TMPDIR:-/tmp}/gnat-cxx-ada-profile-name.XXXXXX")
trap 'rm -rf "$work"' EXIT

for optimization in 0 2; do
  dir="$work/O$optimization"; mkdir -p "$dir"; cp "$cxx" "$ada" "$dir/"
  (cd "$dir"; "${REGRESSION_ENV[@]}" "$gxx" -c "-O$optimization" -fdump-ada-spec-slim profile-formal-type-names.C)
  if [[ "$state" == unpatched ]]; then
    set +e
    (cd "$dir"; "${REGRESSION_ENV[@]}" "$REGRESSION_GNATMAKE" -q -f -c profile_formal_type_names_consumer.adb) >"$dir/build.log" 2>&1
    status=$?; set -e
    [[ $status -ne 0 ]] || { echo "error: unpatched binding compiled" >&2; exit 1; }
    grep -Eiq 'formal parameter.*cannot be used before end of specification' "$dir/build.log"
    echo "cxx-ada-profile-formal-type-names -O$optimization: expected collision (GCC $version)"
  else
    (cd "$dir"; "${REGRESSION_ENV[@]}" "$REGRESSION_GNATMAKE" -q -f "-O$optimization" profile_formal_type_names_consumer.adb -largs profile-formal-type-names.o -lstdc++; "${REGRESSION_ENV[@]}" ./profile_formal_type_names_consumer) >"$dir/output.log" 2>&1 || { cat "$dir/output.log"; exit 1; }
    grep -F "function New_Widget (the_widget : int)" "$dir/profile_formal_type_names_c.ads"
    grep -F "function make_result (the_result : int)" "$dir/profile_formal_type_names_c.ads"
    grep -F "function inspect (the_result : int; item : access Result)" "$dir/profile_formal_type_names_c.ads"
    grep -Fx "MATCH profile formal and type names" "$dir/output.log"
    echo "cxx-ada-profile-formal-type-names -O$optimization: patched (GCC $version)"
  fi
done

Download · View in repository

Commands.

Apply the patch
patch --fuzz=0 -p1 -i bundles/cxx-ada-profile-formal-type-names/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/profile-formal-type-names.C
Regression tests
  • gcc/testsuite/g++.dg/ada-spec/profile-formal-type-names.C
Before the patch
GNAT rejects a constructor, result-returning function, and later-formal profile because an earlier formal hides an Ada type name.
After the patch
Only formals that hide their own or a later profile type receive a stable the_ prefix, and the generated binding compiles, links, and executes 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-profile-formal-type-names/tests/profile-formal-type-names.C
Fixture SHA-256
f8384a7b9c1d6edbf03e0c12c4a27bc6009a93f16696f2ef6e3b8d941d968576
Test runner
bundles/cxx-ada-profile-formal-type-names/run-test.sh