cxx-ada-casefold-identity

C++ Ada casefold identity

The C++ Ada spec dumper emits case-distinct C++ identifiers as duplicate Ada identifiers.

AcceptedApplies in patchset orderSince 1.2.0

Bundle JSON Repository directory

Where it applies.

How each patchset treats this bundle on each exact GCC target
PatchsetGCC 1313.2.0GCC 1414.2.0GCC 1515.3.0GCC 1616.1.0GCC 1616.2.0
1.2.0 (latest)Patchedgcc-13-1413.2.0Patchedgcc-13-1414.2.0Patchedgcc-15-1615.3.0Not coveredPatchedgcc-15-1616.2.0
1.1.1Not applicable13.2.0Not applicable14.2.0Not applicable15.3.0Not applicable16.1.0Not applicable16.2.0
1.1.0Not applicable13.2.0Not applicable14.2.0Not applicable15.3.0Not coveredNot applicable16.2.0
1.0.1Not applicable13.2.0Not applicable14.2.0Not applicable15.3.0Not applicable16.1.0Not covered
1.0.0Not applicable13.2.0Not applicable14.2.0Not applicable15.3.0Not applicable16.1.0Not covered

Explanation.

Ada identifiers are case-insensitive, while C++ identifiers are case-sensitive. The mapper previously copied C++ casing without detecting collisions in the generated Ada scope.

For example:

struct Item { int value; };
struct ITEM { double value; };
int measure(Item);
int MEASURE(ITEM);

The unpatched output preserves spelling but loses identity in Ada:

type Item is record ... end record;
type ITEM is record ... end record;
function measure (arg1 : Item) return int;
function MEASURE (arg1 : ITEM) return int;

Both pairs are duplicate Ada identifiers. The corrected output assigns a stable, scope-local suffix to the later case variant and uses it in every reference:

type Item is record ... end record;
type ITEM_Case_2 is record ... end record;
function measure (arg1 : Item) return int;
function MEASURE_Case_2 (arg1 : ITEM_Case_2) return int;

The same rule covers records, functions, aliases, and fields. Identical names in different C++ scopes remain unchanged. The executable regression compiles the corrected Ada and calls both case-distinct C++ functions at -O0 and -O2.

Patch.

Variant gcc-13-14

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

+200 −4 2 files

SHA-256
d746f3f39368ecd57753d2a8d5d00108810bfcb3e6f1dc90d6f30e1af5b0f278
Patch
bundles/cxx-ada-casefold-identity/patches/gcc-13-14.patch

Download the patch

gcc/c-family/c-ada-spec.cc +166−4modified
@@ -701 +701 @@static tree *to_dump = NULL;
701701static int to_dump_count = 0;
702702static tree current_namespace = NULL_TREE;
703703
704enum ada_name_role
705{
706 ADA_NAME_SOURCE,
707 ADA_NAME_QUALIFIED_METHOD,
708 ADA_NAME_RENAMED_METHOD,
709 ADA_NAME_TEMPLATE_INSTANCE,
710 ADA_NAME_AS_BASE,
711 ADA_NAME_SYNTHETIC_FIELD,
712 ADA_NAME_FORMAL
713};
714
715static const char *allocate_ada_name (const char *, tree, ada_name_role,
716 tree, const char *, const char *);
717
704718static void pp_ada_namespace_name (pretty_printer *, tree);
705719
706720/* Return the innermost named C++ namespace containing NODE. Anonymous
@@ -1459 +1473 @@pp_ada_namespace_name (pretty_printer *pp, tree ns)
14591473 bool space_found = false;
14601474 char *name = to_ada_name (IDENTIFIER_POINTER (DECL_NAME (ns)),
14611475 &space_found);
1462 pp_string (pp, name);
1476 const char *allocated
1477 = allocate_ada_name (name, DECL_NAME (ns), ADA_NAME_SOURCE,
1478 DECL_CONTEXT (ns),
1479 LOCATION_FILE (decl_sloc (ns, false)), "_Case_");
1480 pp_string (pp, allocated);
14631481 free (name);
14641482}
14651483
@@ -1501 +1519 @@static bool package_prefix = true;
15011519static tree current_template = NULL_TREE;
15021520static tree current_template_instance = NULL_TREE;
15031521
1522struct allocated_ada_name
1523{
1524 hashval_t hash;
1525 tree identity;
1526 tree scope;
1527 const char *file;
1528 ada_name_role role;
1529 char *name;
1530
1531 ~allocated_ada_name () { free (name); }
1532};
1533
1534struct allocated_ada_name_hasher : delete_ptr_hash<allocated_ada_name>
1535{
1536 static inline hashval_t hash (allocated_ada_name *entry)
1537 { return entry->hash; }
1538 static inline bool equal (allocated_ada_name *a, allocated_ada_name *b)
1539 {
1540 return (a->identity == b->identity && a->scope == b->scope
1541 && a->file == b->file
1542 && a->role == b->role);
1543 }
1544};
1545
1546struct occupied_ada_name
1547{
1548 hashval_t hash;
1549 tree scope;
1550 const char *file;
1551 char *name;
1552
1553 ~occupied_ada_name () { free (name); }
1554};
1555
1556struct occupied_ada_name_hasher : delete_ptr_hash<occupied_ada_name>
1557{
1558 static inline hashval_t hash (occupied_ada_name *entry)
1559 { return entry->hash; }
1560 static inline bool equal (occupied_ada_name *a, occupied_ada_name *b)
1561 {
1562 return (a->scope == b->scope && a->file == b->file
1563 && !strcmp (a->name, b->name));
1564 }
1565};
1566
1567typedef hash_table<allocated_ada_name_hasher> allocated_ada_name_table;
1568typedef hash_table<occupied_ada_name_hasher> occupied_ada_name_table;
1569static allocated_ada_name_table *allocated_ada_names;
1570static occupied_ada_name_table *occupied_ada_names;
1571
1572/* Return a lower-case copy of NAME for Ada-insensitive comparison. */
1573
1574static char *
1575fold_ada_name (const char *name)
1576{
1577 char *folded = xstrdup (name);
1578 for (char *p = folded; *p; ++p)
1579 *p = TOLOWER (*p);
1580 return folded;
1581}
1582
1583/* Allocate a stable Ada name for IDENTITY and ROLE in SCOPE. PREFERRED is
1584 retained when it is unique. Only an actual collision receives SUFFIX and
1585 a deterministic ordinal. */
1586
1587static const char *
1588allocate_ada_name (const char *preferred, tree identity, ada_name_role role,
1589 tree scope, const char *file, const char *suffix)
1590{
1591 allocated_ada_name query;
1592 query.identity = identity;
1593 query.scope = scope;
1594 query.file = file;
1595 query.role = role;
1596 query.name = NULL;
1597 query.hash = (htab_hash_pointer (identity) ^ htab_hash_pointer (scope)
1598 ^ htab_hash_pointer (file) ^ (hashval_t) role);
1599 allocated_ada_name *existing
1600 = allocated_ada_names->find_with_hash (&query, query.hash);
1601 if (existing)
1602 return existing->name;
1603
1604 char *candidate = xstrdup (preferred);
1605 unsigned int ordinal = 1;
1606 while (true)
1607 {
1608 char *folded = fold_ada_name (candidate);
1609 occupied_ada_name occupied_query;
1610 occupied_query.scope = scope;
1611 occupied_query.file = file;
1612 occupied_query.name = folded;
1613 occupied_query.hash = (htab_hash_string (folded)
1614 ^ htab_hash_pointer (scope)
1615 ^ htab_hash_pointer (file));
1616 occupied_ada_name *occupied_existing
1617 = occupied_ada_names->find_with_hash (&occupied_query,
1618 occupied_query.hash);
1619 if (!occupied_existing)
1620 {
1621 occupied_ada_name **occupied_slot
1622 = occupied_ada_names->find_slot_with_hash (&occupied_query,
1623 occupied_query.hash, INSERT);
1624 occupied_query.name = NULL;
1625 occupied_ada_name *occupied = new occupied_ada_name;
1626 occupied->hash = occupied_query.hash;
1627 occupied->scope = scope;
1628 occupied->file = file;
1629 occupied->name = folded;
1630 *occupied_slot = occupied;
1631 break;
1632 }
1633
1634 occupied_query.name = NULL;
1635 free (folded);
1636 free (candidate);
1637 ++ordinal;
1638 const size_t length = strlen (preferred) + strlen (suffix) + 24;
1639 candidate = XNEWVEC (char, length);
1640 snprintf (candidate, length, "%s%s%u", preferred, suffix, ordinal);
1641 }
1642
1643 allocated_ada_name **slot
1644 = allocated_ada_names->find_slot_with_hash (&query, query.hash, INSERT);
1645 allocated_ada_name *allocated = new allocated_ada_name;
1646 allocated->hash = query.hash;
1647 allocated->identity = identity;
1648 allocated->scope = scope;
1649 allocated->file = file;
1650 allocated->role = role;
1651 allocated->name = candidate;
1652 *slot = allocated;
1653 return allocated->name;
1654}
1655
15041656/* Dump in BUFFER the name of an identifier NODE of type TYPE, following Ada
15051657 syntax. LIMITED_ACCESS indicates whether NODE can be accessed through a
15061658 limited 'with' clause rather than a regular 'with' clause. */
@@ -1513 +1665 @@pp_ada_tree_identifier (pretty_printer *buffer, tree node, tree type,
15131665 bool space_found = false;
15141666 char *s = to_ada_name (name, &space_found);
15151667 tree decl = get_underlying_decl (type);
1668 const char *allocated = s;
1669 if (cpp_check && decl)
1670 allocated = allocate_ada_name (s, node, ADA_NAME_SOURCE,
1671 DECL_CONTEXT (decl),
1672 LOCATION_FILE (decl_sloc (decl, false)),
1673 "_Case_");
15161674
15171675 bool external_decl = false;
15181676 if (decl)
@@ -1560 +1718 @@pp_ada_tree_identifier (pretty_printer *buffer, tree node, tree type,
15601718 || named_namespace_context (decl) != current_namespace))
15611719 {
15621720 pp_string (buffer, "Class_");
1563 pp_string (buffer, s);
1721 pp_string (buffer, allocated);
15641722 pp_dot (buffer);
15651723 }
15661724 }
@@ -1589 +1747 @@pp_ada_tree_identifier (pretty_printer *buffer, tree node, tree type,
15891747 pp_string (buffer, "unsigned_long_long");
15901748 }
15911749 else
1592 pp_string(buffer, s);
1750 pp_string(buffer, allocated);
15931751 else
15941752 if (!strcmp (s, "u_Bool") || !strcmp (s, "bool"))
15951753 {
@@ -1602 +1760 @@pp_ada_tree_identifier (pretty_printer *buffer, tree node, tree type,
16021760 pp_string (buffer, "bool");
16031761 }
16041762 else
1605 pp_string(buffer, s);
1763 pp_string(buffer, allocated);
16061764
16071765 free (s);
16081766}
@@ -3873 +4031 @@dump_ada_specs (void (*collect_all_refs)(const char *),
38734031 bitmap_obstack_initialize (NULL);
38744032
38754033 overloaded_names = init_overloaded_names ();
4034 allocated_ada_names = new allocated_ada_name_table (64);
4035 occupied_ada_names = new occupied_ada_name_table (64);
38764036
38774037 /* Iterate over the list of files to dump specs for. */
38784038 for (int i = 0; i < source_refs_used; i++)
@@ -3885 +4045 @@dump_ada_specs (void (*collect_all_refs)(const char *),
38854045 /* Free various tables. */
38864046 free (source_refs);
38874047 delete overloaded_names;
4048 delete allocated_ada_names;
4049 delete occupied_ada_names;
38884050
38894051 bitmap_obstack_release (NULL);
38904052}
gcc/testsuite/g++.dg/ada-spec/casefold-identity.C +34−0new file
@@ -0 +1 @@
1/* { dg-do compile } */
2/* { dg-options "-fdump-ada-spec-slim" } */
3/* { dg-final { scan-file casefold_identity_c.ads "type ITEM_Case_2" } } */
4/* { dg-final { scan-file casefold_identity_c.ads "subtype ALIAS_Case_2" } } */
5/* { dg-final { scan-file casefold_identity_c.ads "VALUE_Case_2" } } */
6/* { dg-final { scan-file casefold_identity_c.ads "VaLuE_Case_3" } } */
7/* { dg-final { scan-file casefold_identity_c.ads "function MEASURE_Case_2" } } */
8
9struct Item
10{
11 int value;
12};
13
14struct ITEM
15{
16 double value;
17};
18
19using Alias = Item;
20using ALIAS = ITEM;
21
22struct Fields
23{
24 int value;
25 int VALUE;
26 int VaLuE;
27};
28
29int measure (Item item) { return item.value; }
30int MEASURE (ITEM item) { return static_cast<int> (item.value); }
31int combine (Fields fields)
32{ return fields.value + fields.VALUE + fields.VaLuE; }
33
34/* { dg-final { cleanup-ada-spec } } */
35

Variant gcc-15-16

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

+199 −4 2 files

SHA-256
59b0e68f46e16297b5edb7c27cf8a0f3046116a761cbd622c8a47520b8ac808c
Patch
bundles/cxx-ada-casefold-identity/patches/gcc-15-16.patch

Download the patch

gcc/c-family/c-ada-spec.cc +165−4modified
@@ -755 +755 @@static bool bitfield_used = false;
755755static bool packed_layout = false;
756756static tree current_namespace = NULL_TREE;
757757
758enum ada_name_role
759{
760 ADA_NAME_SOURCE,
761 ADA_NAME_QUALIFIED_METHOD,
762 ADA_NAME_RENAMED_METHOD,
763 ADA_NAME_TEMPLATE_INSTANCE,
764 ADA_NAME_AS_BASE,
765 ADA_NAME_SYNTHETIC_FIELD,
766 ADA_NAME_FORMAL
767};
768
769static const char *allocate_ada_name (const char *, tree, ada_name_role,
770 tree, const char *, const char *);
758771static void pp_ada_namespace_name (pretty_printer *, tree);
759772
760773/* Return the innermost named C++ namespace containing NODE. Anonymous
@@ -1513 +1526 @@pp_ada_namespace_name (pretty_printer *pp, tree ns)
15131526 bool space_found = false;
15141527 char *name = to_ada_name (IDENTIFIER_POINTER (DECL_NAME (ns)),
15151528 &space_found);
1516 pp_string (pp, name);
1529 const char *allocated
1530 = allocate_ada_name (name, DECL_NAME (ns), ADA_NAME_SOURCE,
1531 DECL_CONTEXT (ns),
1532 LOCATION_FILE (decl_sloc (ns, false)), "_Case_");
1533 pp_string (pp, allocated);
15171534 free (name);
15181535}
15191536
@@ -1555 +1572 @@static bool package_prefix = true;
15551572static tree current_template = NULL_TREE;
15561573static tree current_template_instance = NULL_TREE;
15571574
1575struct allocated_ada_name
1576{
1577 hashval_t hash;
1578 tree identity;
1579 tree scope;
1580 const char *file;
1581 ada_name_role role;
1582 char *name;
1583
1584 ~allocated_ada_name () { free (name); }
1585};
1586
1587struct allocated_ada_name_hasher : delete_ptr_hash<allocated_ada_name>
1588{
1589 static inline hashval_t hash (allocated_ada_name *entry)
1590 { return entry->hash; }
1591 static inline bool equal (allocated_ada_name *a, allocated_ada_name *b)
1592 {
1593 return (a->identity == b->identity && a->scope == b->scope
1594 && a->file == b->file
1595 && a->role == b->role);
1596 }
1597};
1598
1599struct occupied_ada_name
1600{
1601 hashval_t hash;
1602 tree scope;
1603 const char *file;
1604 char *name;
1605
1606 ~occupied_ada_name () { free (name); }
1607};
1608
1609struct occupied_ada_name_hasher : delete_ptr_hash<occupied_ada_name>
1610{
1611 static inline hashval_t hash (occupied_ada_name *entry)
1612 { return entry->hash; }
1613 static inline bool equal (occupied_ada_name *a, occupied_ada_name *b)
1614 {
1615 return (a->scope == b->scope && a->file == b->file
1616 && !strcmp (a->name, b->name));
1617 }
1618};
1619
1620typedef hash_table<allocated_ada_name_hasher> allocated_ada_name_table;
1621typedef hash_table<occupied_ada_name_hasher> occupied_ada_name_table;
1622static allocated_ada_name_table *allocated_ada_names;
1623static occupied_ada_name_table *occupied_ada_names;
1624
1625/* Return a lower-case copy of NAME for Ada-insensitive comparison. */
1626
1627static char *
1628fold_ada_name (const char *name)
1629{
1630 char *folded = xstrdup (name);
1631 for (char *p = folded; *p; ++p)
1632 *p = TOLOWER (*p);
1633 return folded;
1634}
1635
1636/* Allocate a stable Ada name for IDENTITY and ROLE in SCOPE. PREFERRED is
1637 retained when it is unique. Only an actual collision receives SUFFIX and
1638 a deterministic ordinal. */
1639
1640static const char *
1641allocate_ada_name (const char *preferred, tree identity, ada_name_role role,
1642 tree scope, const char *file, const char *suffix)
1643{
1644 allocated_ada_name query;
1645 query.identity = identity;
1646 query.scope = scope;
1647 query.file = file;
1648 query.role = role;
1649 query.name = NULL;
1650 query.hash = (htab_hash_pointer (identity) ^ htab_hash_pointer (scope)
1651 ^ htab_hash_pointer (file) ^ (hashval_t) role);
1652 allocated_ada_name *existing
1653 = allocated_ada_names->find_with_hash (&query, query.hash);
1654 if (existing)
1655 return existing->name;
1656
1657 char *candidate = xstrdup (preferred);
1658 unsigned int ordinal = 1;
1659 while (true)
1660 {
1661 char *folded = fold_ada_name (candidate);
1662 occupied_ada_name occupied_query;
1663 occupied_query.scope = scope;
1664 occupied_query.file = file;
1665 occupied_query.name = folded;
1666 occupied_query.hash = (htab_hash_string (folded)
1667 ^ htab_hash_pointer (scope)
1668 ^ htab_hash_pointer (file));
1669 occupied_ada_name *occupied_existing
1670 = occupied_ada_names->find_with_hash (&occupied_query,
1671 occupied_query.hash);
1672 if (!occupied_existing)
1673 {
1674 occupied_ada_name **occupied_slot
1675 = occupied_ada_names->find_slot_with_hash (&occupied_query,
1676 occupied_query.hash, INSERT);
1677 occupied_query.name = NULL;
1678 occupied_ada_name *occupied = new occupied_ada_name;
1679 occupied->hash = occupied_query.hash;
1680 occupied->scope = scope;
1681 occupied->file = file;
1682 occupied->name = folded;
1683 *occupied_slot = occupied;
1684 break;
1685 }
1686
1687 occupied_query.name = NULL;
1688 free (folded);
1689 free (candidate);
1690 ++ordinal;
1691 const size_t length = strlen (preferred) + strlen (suffix) + 24;
1692 candidate = XNEWVEC (char, length);
1693 snprintf (candidate, length, "%s%s%u", preferred, suffix, ordinal);
1694 }
1695
1696 allocated_ada_name **slot
1697 = allocated_ada_names->find_slot_with_hash (&query, query.hash, INSERT);
1698 allocated_ada_name *allocated = new allocated_ada_name;
1699 allocated->hash = query.hash;
1700 allocated->identity = identity;
1701 allocated->scope = scope;
1702 allocated->file = file;
1703 allocated->role = role;
1704 allocated->name = candidate;
1705 *slot = allocated;
1706 return allocated->name;
1707}
1708
15581709/* Dump in PP the name of an identifier NODE of type TYPE, following Ada
15591710 syntax. LIMITED_ACCESS indicates whether NODE can be accessed through a
15601711 limited 'with' clause rather than a regular 'with' clause. */
@@ -1567 +1718 @@pp_ada_tree_identifier (pretty_printer *pp, tree node, tree type,
15671718 bool space_found = false;
15681719 char *s = to_ada_name (name, &space_found);
15691720 tree decl = get_underlying_decl (type);
1721 const char *allocated = s;
1722 if (cpp_check && decl)
1723 allocated = allocate_ada_name (s, node, ADA_NAME_SOURCE,
1724 DECL_CONTEXT (decl),
1725 LOCATION_FILE (decl_sloc (decl, false)),
1726 "_Case_");
15701727
15711728 bool external_decl = false;
15721729 if (decl)
@@ -1614 +1771 @@pp_ada_tree_identifier (pretty_printer *pp, tree node, tree type,
16141771 || named_namespace_context (decl) != current_namespace))
16151772 {
16161773 pp_string (pp, "Class_");
1617 pp_string (pp, s);
1774 pp_string (pp, allocated);
16181775 pp_dot (pp);
16191776 }
16201777 }
@@ -1643 +1800 @@pp_ada_tree_identifier (pretty_printer *pp, tree node, tree type,
16431800 pp_string (pp, "unsigned_long_long");
16441801 }
16451802 else
1646 pp_string (pp, s);
1803 pp_string (pp, allocated);
16471804 else
16481805 if (!strcmp (s, "u_Bool") || !strcmp (s, "bool"))
16491806 {
@@ -1656 +1813 @@pp_ada_tree_identifier (pretty_printer *pp, tree node, tree type,
16561813 pp_string (pp, "bool");
16571814 }
16581815 else
1659 pp_string (pp, s);
1816 pp_string (pp, allocated);
16601817
16611818 free (s);
16621819}
@@ -3960 +4117 @@dump_ada_specs (void (*collect_all_refs)(const char *),
39604117 bitmap_obstack_initialize (NULL);
39614118
39624119 overloaded_names = init_overloaded_names ();
4120 allocated_ada_names = new allocated_ada_name_table (64);
4121 occupied_ada_names = new occupied_ada_name_table (64);
39634122
39644123 /* Iterate over the list of files to dump specs for. */
39654124 for (int i = 0; i < source_refs_used; i++)
@@ -3972 +4131 @@dump_ada_specs (void (*collect_all_refs)(const char *),
39724131 /* Free various tables. */
39734132 free (source_refs);
39744133 delete overloaded_names;
4134 delete allocated_ada_names;
4135 delete occupied_ada_names;
39754136
39764137 bitmap_obstack_release (NULL);
39774138}
gcc/testsuite/g++.dg/ada-spec/casefold-identity.C +34−0new file
@@ -0 +1 @@
1/* { dg-do compile } */
2/* { dg-options "-fdump-ada-spec-slim" } */
3/* { dg-final { scan-file casefold_identity_c.ads "type ITEM_Case_2" } } */
4/* { dg-final { scan-file casefold_identity_c.ads "subtype ALIAS_Case_2" } } */
5/* { dg-final { scan-file casefold_identity_c.ads "VALUE_Case_2" } } */
6/* { dg-final { scan-file casefold_identity_c.ads "VaLuE_Case_3" } } */
7/* { dg-final { scan-file casefold_identity_c.ads "function MEASURE_Case_2" } } */
8
9struct Item
10{
11 int value;
12};
13
14struct ITEM
15{
16 double value;
17};
18
19using Alias = Item;
20using ALIAS = ITEM;
21
22struct Fields
23{
24 int value;
25 int VALUE;
26 int VaLuE;
27};
28
29int measure (Item item) { return item.value; }
30int MEASURE (ITEM item) { return static_cast<int> (item.value); }
31int combine (Fields fields)
32{ return fields.value + fields.VALUE + fields.VaLuE; }
33
34/* { dg-final { cleanup-ada-spec } } */
35

Tests.

Before the patch
GNAT rejects records, aliases, fields, or functions whose C++ identifiers differ only by case.
After the patch
Scope-local Case suffixes preserve every case-distinct identity and all generated references compile and link at -O0 and -O2.
casefold-identity.C C++ · 34 lines 
/* { dg-do compile } */
/* { dg-options "-fdump-ada-spec-slim" } */
/* { dg-final { scan-file casefold_identity_c.ads "type ITEM_Case_2" } } */
/* { dg-final { scan-file casefold_identity_c.ads "subtype ALIAS_Case_2" } } */
/* { dg-final { scan-file casefold_identity_c.ads "VALUE_Case_2" } } */
/* { dg-final { scan-file casefold_identity_c.ads "VaLuE_Case_3" } } */
/* { dg-final { scan-file casefold_identity_c.ads "function MEASURE_Case_2" } } */

struct Item
{
  int value;
};

struct ITEM
{
  double value;
};

using Alias = Item;
using ALIAS = ITEM;

struct Fields
{
  int value;
  int VALUE;
  int VaLuE;
};

int measure (Item item) { return item.value; }
int MEASURE (ITEM item) { return static_cast<int> (item.value); }
int combine (Fields fields)
{ return fields.value + fields.VALUE + fields.VaLuE; }

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

Download · View in repository

casefold_identity_consumer.adb Ada · 18 lines 
with Interfaces.C; use Interfaces.C;
with Casefold_Identity_C;

procedure Casefold_Identity_Consumer is
   package Bindings renames Casefold_Identity_C;

   First : Bindings.Item := (value => 7);
   Second : Bindings.ITEM_Case_2 := (value => 8.0);
   Pair : Bindings.Fields :=
     (value => 11, VALUE_Case_2 => 13, VaLuE_Case_3 => 17);
begin
   if Bindings.measure (First) /= 7
     or else Bindings.MEASURE_Case_2 (Second) /= 8
     or else Bindings.combine (Pair) /= 41
   then
      raise Program_Error with "case-distinct C++ symbols were conflated";
   end if;
end Casefold_Identity_Consumer;

Download · View in repository

run-test.sh shell · 69 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-casefold-identity/tests/casefold-identity.C"
ada_fixture="$root/bundles/cxx-ada-casefold-identity/tests/casefold_identity_consumer.adb"
work=$(mktemp -d "${TMPDIR:-/tmp}/gnat-cxx-ada-casefold.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" -c "-O$optimization" \
      -fdump-ada-spec-slim casefold-identity.C
  )

  set +e
  (
    cd "$case_dir"
    "${REGRESSION_ENV[@]}" "$REGRESSION_GNATMAKE" -q -f \
      "-O$optimization" casefold_identity_consumer.adb \
      -largs casefold-identity.o -lstdc++
    "${REGRESSION_ENV[@]}" ./casefold_identity_consumer
  ) >"$case_dir/run.log" 2>&1
  run_status=$?
  set -e

  if [[ "$state" == unpatched ]]; then
    [[ $run_status -ne 0 ]] || {
      echo "error: unpatched casefold regression unexpectedly passed" >&2
      exit 1
    }
    grep -Eiq 'conflicts with declaration|not declared' "$case_dir/run.log" || {
      cat "$case_dir/run.log"
      exit 1
    }
    echo "cxx-ada-casefold-identity -O$optimization: expected collision (GCC $version)"
    continue
  fi

  [[ $run_status -eq 0 ]] || {
    cat "$case_dir/run.log"
    exit 1
  }
  echo "cxx-ada-casefold-identity -O$optimization: patched (GCC $version)"
done

Download · View in repository

Commands.

Apply the patch
patch --fuzz=0 -p1 -i bundles/cxx-ada-casefold-identity/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/casefold-identity.C
Regression tests
  • gcc/testsuite/g++.dg/ada-spec/casefold-identity.C
Before the patch
GNAT rejects records, aliases, fields, or functions whose C++ identifiers differ only by case.
After the patch
Scope-local Case suffixes preserve every case-distinct identity and all generated references compile and link at -O0 and -O2.
Upstream issue
Not yet filed.
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-casefold-identity/tests/casefold-identity.C
Fixture SHA-256
ddeac6163886392cc380ef233de8f592ed012714d069412a9d735067691333bd
Test runner
bundles/cxx-ada-casefold-identity/run-test.sh