d: Mangled Symbols now back reference types and identifiers

Symbols with extern(D) linkage are now mangled using back references to
types and identifiers if these occur more than once in the mangled name
as emitted before.  This reduces symbol length, especially with chained
expressions of templated functions with Voldemort return types.

For example, the average symbol length of the 127000+ symbols created by
a libphobos unittest build is reduced by a factor of about 3, while the
longest symbol shrinks from 416133 to 1142 characters.

Reviewed-on: https://github.com/dlang/dmd/pull/12079

gcc/d/ChangeLog:

	* dmd/MERGE: Merge upstream dmd 2bd4fc3fe.

8 files changed, 158 insertions, 62 deletions

diff --git a/gcc/testsuite/gdc.test/compilable/testInference.d b/gcc/testsuite/gdc.test/compilable/testInference.d
index 95f4fcb..5a8e1e2 100644
--- a/gcc/testsuite/gdc.test/compilable/testInference.d
+++ b/gcc/testsuite/gdc.test/compilable/testInference.d
@@ -261,11 +261,13 @@ void test8234()
 /***************************************************/
 // 8504
 
+import core.demangle : demangle;
+
 void foo8504()()
 {
     static assert(typeof(foo8504!()).stringof == "void()");
     static assert(typeof(foo8504!()).mangleof == "FZv");
-    static assert(foo8504!().mangleof == "_D13testInference12__T7foo8504Z7foo8504FZv");
+    static assert(demangle(foo8504!().mangleof) == "void testInference.foo8504!().foo8504()");
 }
 
 auto toDelegate8504a(F)(auto ref F fp) { return fp; }
@@ -277,7 +279,7 @@ void test8504()
 {
     static assert(typeof(foo8504!()).stringof == "pure nothrow @nogc @safe void()");
     static assert(typeof(foo8504!()).mangleof == "FNaNbNiNfZv");
-    static assert(foo8504!().mangleof == "_D13testInference12__T7foo8504Z7foo8504FNaNbNiNfZv");
+    static assert(demangle(foo8504!().mangleof) == "pure nothrow @nogc @safe void testInference.foo8504!().foo8504()");
 
     auto fp1 = toDelegate8504a(&testC8504);
     auto fp2 = toDelegate8504b(&testC8504);
diff --git a/gcc/testsuite/gdc.test/fail_compilation/fail12485.d b/gcc/testsuite/gdc.test/fail_compilation/fail12485.d
index 71f8698..e1b1577 100644
--- a/gcc/testsuite/gdc.test/fail_compilation/fail12485.d
+++ b/gcc/testsuite/gdc.test/fail_compilation/fail12485.d
@@ -1,11 +1,12 @@
 void dorecursive()
 {
-    recursive([0]);
+    recursive!"ratherLongSymbolNameToHitTheMaximumSymbolLengthEarlierThanTheTemplateRecursionLimit_";
 }
 
-void recursive(R)(R r)
+void recursive(string name)()
 {
-    import std.algorithm;
-    recursive( r.filter!(e=>true) );
+    struct S {} // define type to kick off mangler
+    static if (name.length <= (4 << 20))
+        recursive!(name ~ name);
 }
 
diff --git a/gcc/testsuite/gdc.test/runnable/imports/testmangle.d b/gcc/testsuite/gdc.test/runnable/imports/testmangle.d
new file mode 100644
index 0000000..5311a83
--- /dev/null
+++ b/gcc/testsuite/gdc.test/runnable/imports/testmangle.d
@@ -0,0 +1,66 @@
+// helper for mangling tests with back references
+
+module imports.testmangle;
+
+public import core.demangle : demangle, demangleType;
+
+// detect mangle version
+private
+{
+    struct Detect;
+    Detect* detectMangle(Detect*);
+    void DetectTmpl(T)() {}
+}
+
+pragma(msg,detectMangle.mangleof);
+static if(detectMangle.mangleof == "_D7imports10testmangle12detectMangleFPSQL3H6DetectZQ1e")
+    enum { BackRefs = true, BackRefSymbols = true }
+else static if(detectMangle.mangleof == "_D7imports10testmangle12detectMangleFPSQBlQBg6DetectZQq")
+    enum { BackRefs = true, BackRefSymbols = false }
+else static if(detectMangle.mangleof == "_D7imports10testmangle12detectMangleFPS7imports10testmangle6DetectZPS7imports10testmangle6Detect")
+    enum { BackRefs = false, BackRefSymbols = false }
+else
+    static assert(false, "unknown mangling");
+
+private enum tmplMangle = (DetectTmpl!int).mangleof;
+pragma(msg,tmplMangle);
+static if(tmplMangle[0..40] == "_D7imports10testmangle__T10DetectTmplTiZ")
+    enum HasTemplateLength = false;
+else static if(tmplMangle[0..42] == "_D7imports10testmangle18__T10DetectTmplTiZ")
+    enum HasTemplateLength = true;
+else
+    static assert(false, "unknown mangling");
+
+pragma(msg,BackRefs);
+pragma(msg,BackRefSymbols);
+
+static if (BackRefs)
+{
+    string tl(string s)() { return null; }
+    string id(string s, string r, string r2 = null)() { return BackRefSymbols && r2 !is null ? r2 : r; }
+}
+else
+{
+    string tl(string s)() { return HasTemplateLength ? s : null; }
+    string id(string s, string r, string r2 = null)() { return s; }
+}
+
+bool equalDemangle(string m1, string m2)
+{
+    auto dm1 = demangle(m1);
+    auto dm2 = demangle(m2);
+    return dm1 == dm2;
+}
+
+string unsignedToString(ulong x)
+{
+    string s;
+    s ~= cast(char)('0' + (x % 10));
+    x /= 10;
+    while (x > 0)
+    {
+        s = cast(char)('0' + (x % 10)) ~ s;
+        x /= 10;
+    }
+    return s;
+}
diff --git a/gcc/testsuite/gdc.test/runnable/link6574.d b/gcc/testsuite/gdc.test/runnable/link6574.d
index 0f97ed7..ab5e552 100644
--- a/gcc/testsuite/gdc.test/runnable/link6574.d
+++ b/gcc/testsuite/gdc.test/runnable/link6574.d
@@ -1,16 +1,18 @@
 // PERMUTE_ARGS:
 module link6574;
 
+import imports.testmangle;
+
 enum Method { A, B, }
 
 int foo(Method method = Method.A)()
 {
-    static assert(foo.mangleof == "_D8link657428__T3fooVE8link65746Methodi0Z3fooFZi");
+    static assert(foo.mangleof == "_D8link6574"~tl!"28"~"__T3fooVE"~id!("8link6574","Qs")~"6Methodi0Z"~id!("3foo","Qs")~"FZi");
     return 10 * foo!method();
 }
 int foo(Method method : Method.A)()
 {
-    static assert(foo.mangleof == "_D8link657429__T3fooHVE8link65746Methodi0Z3fooFZi");
+    static assert(foo.mangleof == "_D8link6574"~tl!"29"~"__T3fooHVE"~id!("8link6574","Qt")~"6Methodi0Z"~id!("3foo","Qt")~"FZi");
     return 2;
 }
 int foo(Method method : Method.B)()
@@ -21,7 +23,7 @@ int foo(Method method : Method.B)()
 
 int bar(Method method = Method.B)()
 {
-    static assert(bar.mangleof == "_D8link657428__T3barVE8link65746Methodi1Z3barFZi");
+    static assert(bar.mangleof == "_D8link6574"~tl!"28"~"__T3barVE"~id!("8link6574","Qs")~"6Methodi1Z"~id!("3bar","Qs")~"FZi");
     return 10 * bar!method();
 }
 int bar(Method method : Method.A)()
@@ -31,7 +33,7 @@ int bar(Method method : Method.A)()
 }
 int bar(Method method : Method.B)()
 {
-    static assert(bar.mangleof == "_D8link657429__T3barHVE8link65746Methodi1Z3barFZi");
+    static assert(bar.mangleof == "_D8link6574"~tl!"29"~"__T3barHVE"~id!("8link6574","Qt")~"6Methodi1Z"~id!("3bar","Qt")~"FZi");
     return 3;
 }
 
diff --git a/gcc/testsuite/gdc.test/runnable/mangle.d b/gcc/testsuite/gdc.test/runnable/mangle.d
index 8820a6d..883d58a 100644
--- a/gcc/testsuite/gdc.test/runnable/mangle.d
+++ b/gcc/testsuite/gdc.test/runnable/mangle.d
@@ -1,6 +1,8 @@
 // PERMUTE_ARGS:
 // EXTRA_SOURCES: imports/mangle10077.d
 
+import imports.testmangle;
+
 /***************************************************/
 // 10077 - pragma(mangle)
 
@@ -79,7 +81,7 @@ class C2774
 static assert(C2774.foo2774.mangleof == "_D6mangle5C27747foo2774MFZi");
 
 template TFoo2774(T) {}
-static assert(TFoo2774!int.mangleof == "6mangle15__T8TFoo2774TiZ");
+static assert(TFoo2774!int.mangleof == "6mangle"~tl!"15"~"__T8TFoo2774TiZ");
 
 void test2774()
 {
@@ -175,8 +177,8 @@ void test8847b()
 
 struct Test8847
 {
-    enum result1 = "S6mangle8Test88478__T3fooZ3fooMFZ6Result";
-    enum result2 = "S6mangle8Test88478__T3fooZ3fooMxFiZ6Result";
+    enum result1 = "S6mangle8Test8847"~tl!("8")~"__T3fooZ"~id!("3foo","Qf")~"MFZ6Result";
+    enum result2 = "S6mangle8Test8847"~tl!("8")~"__T3fooZ"~id!("3foo","Qf")~"MxFiZ6Result";
 
     auto foo()()
     {
@@ -236,9 +238,10 @@ void test8847d()
 
 void test8847e()
 {
-    enum resultHere = "6mangle"~"9test8847eFZ"~"8__T3fooZ"~"3foo";
+    enum resultHere = "6mangle"~"9test8847eFZ"~tl!"8"~"__T3fooZ"~id!("3foo","Qf");
     enum resultBar =  "S"~resultHere~"MFNaNfNgiZ3Bar";
-    enum resultFoo = "_D"~resultHere~"MFNaNbNiNfNgiZNg"~resultBar;   // added 'Nb'
+    static if(BackRefs) {} else
+      enum resultFoo = "_D"~resultHere~"MFNaNbNiNfNgiZNg"~resultBar;   // added 'Nb'
 
     // Make template function to infer 'nothrow' attributes
     auto foo()(inout int) pure @safe
@@ -248,10 +251,16 @@ void test8847e()
         return inout(Bar)();
     }
 
+    import core.demangle : demangle, demangleType;
     auto bar = foo(0);
     static assert(typeof(bar).stringof == "Bar");
     static assert(typeof(bar).mangleof == resultBar);
-    static assert(foo!().mangleof == resultFoo);
+    enum fooDemangled = "pure nothrow @nogc @safe inout(mangle.test8847e().foo!().foo(inout(int)).Bar) mangle.test8847e().foo!().foo(inout(int))";
+
+    static if (BackRefs)
+      static assert(demangle(foo!().mangleof) == fooDemangled);
+    else
+      static assert(foo!().mangleof == resultFoo);
 }
 
 // --------
@@ -287,7 +296,7 @@ auto bar12352()
 
     return S();
 }
-static assert(       bar12352        .mangleof == "_D6mangle8bar12352FNaNbNiNfZS6mangle8bar12352FZ1S");
+static assert(       bar12352        .mangleof == "_D6mangle8bar12352FNaNbNiNfZS"~id!("6mangle8bar12352FZ","QBbQxFZ","QL2H")~"1S");
 static assert(typeof(bar12352())     .mangleof ==  "S6mangle8bar12352FZ1S");
 static assert(typeof(bar12352()).func.mangleof == "_D6mangle8bar12352FZ1S4funcMFZv");
 
@@ -301,7 +310,7 @@ auto baz12352()
 
     return new C();
 }
-static assert(       baz12352        .mangleof == "_D6mangle8baz12352FNaNbNfZC6mangle8baz12352FZ1C");
+static assert(       baz12352      .mangleof == "_D6mangle8baz12352FNaNbNfZC"~id!("6mangle8baz12352FZ","QzQuFZ","QL2F")~"1C");
 static assert(typeof(baz12352())     .mangleof ==  "C6mangle8baz12352FZ1C");
 static assert(typeof(baz12352()).func.mangleof == "_D6mangle8baz12352FZ1C4funcMFZv");
 
@@ -312,8 +321,8 @@ void f9525(T)(in T*) { }
 
 void test9525()
 {
-    enum result1 = "S6mangle8test9525FZ26__T5test1S136mangle5f9525Z5test1MFZ1S";
-    enum result2 = "S6mangle8test9525FZ26__T5test2S136mangle5f9525Z5test2MFNaNbZ1S";
+    enum result1 = "S6mangle8test9525FZ"~tl!"26"~"__T5test1S"~tl!"13"~id!("6mangle","QBc")~"5f9525Z"~id!("5test1","Qr")~"MFZ1S";
+    enum result2 = "S6mangle8test9525FZ"~tl!"26"~"__T5test2S"~tl!"13"~id!("6mangle","QBc")~"5f9525Z"~id!("5test2","Qr")~"MFNaNbZ1S";
 
     void test1(alias a)()
     {
@@ -383,23 +392,32 @@ void test11718()
     string TyName(string tail)()
     {
         enum s = "__T7Ty11718" ~ tail;
-        enum int len = s.length;
-        return "S6mangle" ~ len.stringof ~ s;
+        enum len = unsignedToString(s.length);
+        return "S6mangle" ~ tl!(len) ~ s;
     }
     string fnName(string paramPart)()
     {
-        enum s = "_D6mangle35__T7fn11718T"~
+        enum s = "_D6mangle"~tl!("35")~"__T7fn11718T"~
                  "S6mangle9test11718FZ1AZ7fn11718"~paramPart~"1a"~
                  "S6mangle9test11718FZ1A";
-        enum int len = s.length;
-        return len.stringof ~ s;
+        enum len = unsignedToString(s.length);
+        return tl!len ~ s;
     }
     enum result1 = TyName!("S" ~ fnName!("F"~"S6mangle9test11718FZ1A"~"Z") ~ "Z") ~ "7Ty11718";
     enum result2 = TyName!("S" ~ fnName!("F"~""                      ~"Z") ~ "Z") ~ "7Ty11718";
 
     struct A {}
-    static assert(fn11718(A.init) == result1);
-    static assert(fn11718!A()     == result2);
+    static if (BackRefs)
+    {
+        static assert(fn11718(A.init) == "S6mangle__T7Ty11718S_DQv__T7fn11718TSQBk9test11718FZ1AZQBcFQxZ1aQBcZQCf");
+        static assert(fn11718!A()     == "S6mangle__T7Ty11718S_DQv__T7fn11718TSQBk9test11718FZ1AZQBcFZ1aQBaZQCd");
+    }
+    else
+    {
+        pragma(msg, fn11718(A.init));
+        static assert(fn11718(A.init) == result1);
+        static assert(fn11718!A()     == result2);
+    }
 }
 
 /*******************************************/
@@ -417,9 +435,10 @@ void test11776()
         {
             auto s = S11776!(a => 1)();
             static assert(typeof(s).mangleof ==
-                "S"~"6mangle"~"56"~(
-                    "__T"~"6S11776"~"S42"~("6mangle"~"9test11776"~"FZ"~"9__lambda1MFZ"~"9__lambda1")~"Z"
-                )~"6S11776");
+                "S"~"6mangle"~tl!("56")~
+                ("__T"~"6S11776"~"S"~tl!("42")~
+                 (id!("6mangle","Qs")~"9test11776"~"FZ"~"9__lambda1MFZ"~id!("9__lambda1","Qn"))~"Z"
+                 )~id!("6S11776", "QBm"));
         }
     };
 }
@@ -464,7 +483,7 @@ void test12217(int)
     static assert(    S.mangleof ==  "S6mangle9test12217FiZ1S");
     static assert(  bar.mangleof == "_D6mangle9test12217FiZ3barMFNaNbNiNfZv");
     static assert(  var.mangleof == "_D6mangle9test12217FiZ3vari");
-    static assert(X!int.mangleof ==   "6mangle9test12217FiZ8__T1XTiZ");
+    static assert(X!int.mangleof ==   "6mangle9test12217FiZ"~tl!("8")~"__T1XTiZ");
 }
 
 void test12217() {}
@@ -476,22 +495,21 @@ void func12231a()()
 if (is(typeof({
         class C {}
         static assert(C.mangleof ==
-            "C6mangle16__U10func12231aZ10func12231aFZ9__lambda1MFZ1C");
+            "C6mangle"~tl!("16")~"__U10func12231aZ"~id!("10func12231a","Qn")~"FZ9__lambda1MFZ1C");
             //         ###            L                       #
     })))
 {}
 
 void func12231b()()
 if (is(typeof({
-        class C {}
-        static assert(C.mangleof ==
-            "C6mangle16__U10func12231bZ10func12231bFZ9__lambda1MFZ1C");
+        class C {}        static assert(C.mangleof ==
+            "C6mangle"~tl!("16")~"__U10func12231bZ"~id!("10func12231b","Qn")~"FZ9__lambda1MFZ1C");
             //         L__L           L                       LL
-    })) &&
+      })) &&
     is(typeof({
         class C {}
         static assert(C.mangleof ==
-            "C6mangle16__U10func12231bZ10func12231bFZ9__lambda2MFZ1C");
+            "C6mangle"~tl!("16")~"__U10func12231bZ"~id!("10func12231b","Qn")~"FZ9__lambda2MFZ1C");
             //         L__L           L                       LL
     })))
 {}
@@ -500,14 +518,14 @@ void func12231c()()
 if (is(typeof({
         class C {}
         static assert(C.mangleof ==
-            "C6mangle16__U10func12231cZ10func12231cFZ9__lambda1MFZ1C");
+            "C6mangle"~tl!("16")~"__U10func12231cZ"~id!("10func12231c","Qn")~"FZ9__lambda1MFZ1C");
             //         L__L           L                       LL
     })))
 {
     (){
         class C {}
         static assert(C.mangleof ==
-            "C6mangle16__T10func12231cZ10func12231cFZ9__lambda1MFZ1C");
+            "C6mangle"~tl!("16")~"__T10func12231cZ"~id!("10func12231c","Qn")~"FZ9__lambda1MFZ1C");
             //         L__L           L                       LL
     }();
 }
@@ -515,15 +533,15 @@ if (is(typeof({
 void func12231c(X)()
 if (is(typeof({
         class C {}
-        static assert(C.mangleof ==
-            "C6mangle20__U10func12231cTAyaZ10func12231cFZ9__lambda1MFZ1C");
+    static assert(C.mangleof ==
+            "C6mangle"~tl!("20")~"__U10func12231cTAyaZ"~id!("10func12231c","Qr")~"FZ9__lambda1MFZ1C");
             //         L__L           L___L                       LL
     })))
 {
     (){
         class C {}
         static assert(C.mangleof ==
-            "C6mangle20__T10func12231cTAyaZ10func12231cFZ9__lambda1MFZ1C");
+            "C6mangle"~tl!("20")~"__T10func12231cTAyaZ"~id!("10func12231c","Qr")~"FZ9__lambda1MFZ1C");
             //         L__L           L___L                       LL
     }();
 }
diff --git a/gcc/testsuite/gdc.test/runnable/template4.d b/gcc/testsuite/gdc.test/runnable/template4.d
index 77d6254..81723f6 100644
--- a/gcc/testsuite/gdc.test/runnable/template4.d
+++ b/gcc/testsuite/gdc.test/runnable/template4.d
@@ -1074,22 +1074,27 @@ struct Foo7469d(T...) { }
 struct Foo7469e(int a, T...) { }
 struct Foo7469f(T, int k=1) { }
 struct Foo7469g(T, int k=1) { }
+struct Foo7469h(uint x) { }
+
+import core.demangle : demangleType;
 
 void test7469()
 {
-    static assert(Foo7469a!(3 )    .mangleof[$-28 .. $] == "17__T8Foo7469aVii3Z8Foo7469a");
-    static assert(Foo7469a!(3u)    .mangleof[$-28 .. $] == "17__T8Foo7469aVii3Z8Foo7469a");
-    static assert(Foo7469b!(3u)    .mangleof[$-28 .. $] == "17__T8Foo7469bVii3Z8Foo7469b");
-    static assert(Foo7469b!(3 )    .mangleof[$-28 .. $] == "17__T8Foo7469bVii3Z8Foo7469b");
-    static assert(Foo7469c!(3 )    .mangleof[$-28 .. $] == "17__T8Foo7469cVii3Z8Foo7469c");
-    static assert(Foo7469c!(3u)    .mangleof[$-28 .. $] == "17__T8Foo7469cVki3Z8Foo7469c");
-    static assert(Foo7469d!(3 )    .mangleof[$-28 .. $] == "17__T8Foo7469dVii3Z8Foo7469d");
-    static assert(Foo7469d!(3u)    .mangleof[$-28 .. $] == "17__T8Foo7469dVki3Z8Foo7469d");
-    static assert(Foo7469e!(3u, 5u).mangleof[$-32 .. $] == "21__T8Foo7469eVii3Vki5Z8Foo7469e");
-    static assert(Foo7469f!(int, 1).mangleof[$-30 .. $] == "19__T8Foo7469fTiVii1Z8Foo7469f");
-    static assert(Foo7469f!(int)   .mangleof[$-30 .. $] == "19__T8Foo7469fTiVii1Z8Foo7469f");
-    static assert(Foo7469g!(int)   .mangleof[$-30 .. $] == "19__T8Foo7469gTiVii1Z8Foo7469g");
-    static assert(Foo7469g!(int, 1).mangleof[$-30 .. $] == "19__T8Foo7469gTiVii1Z8Foo7469g");
+    static assert(demangleType(Foo7469a!(3 )    .mangleof) == "template4.Foo7469a!(3).Foo7469a");
+    static assert(demangleType(Foo7469a!(3u)    .mangleof) == "template4.Foo7469a!(3).Foo7469a");
+    static assert(demangleType(Foo7469b!(3u)    .mangleof) == "template4.Foo7469b!(3).Foo7469b");
+    static assert(demangleType(Foo7469b!(3 )    .mangleof) == "template4.Foo7469b!(3).Foo7469b");
+    static assert(demangleType(Foo7469c!(3 )    .mangleof) == "template4.Foo7469c!(3).Foo7469c");
+    static assert(demangleType(Foo7469c!(3u)    .mangleof) == "template4.Foo7469c!(3u).Foo7469c");
+    static assert(demangleType(Foo7469d!(3 )    .mangleof) == "template4.Foo7469d!(3).Foo7469d");
+    static assert(demangleType(Foo7469d!(3u)    .mangleof) == "template4.Foo7469d!(3u).Foo7469d");
+    static assert(demangleType(Foo7469e!(3u, 5u).mangleof) == "template4.Foo7469e!(3, 5u).Foo7469e");
+    static assert(demangleType(Foo7469f!(int, 1).mangleof) == "template4.Foo7469f!(int, 1).Foo7469f");
+    static assert(demangleType(Foo7469f!(int)   .mangleof) == "template4.Foo7469f!(int, 1).Foo7469f");
+    static assert(demangleType(Foo7469g!(int)   .mangleof) == "template4.Foo7469g!(int, 1).Foo7469g");
+    static assert(demangleType(Foo7469g!(int, 1).mangleof) == "template4.Foo7469g!(int, 1).Foo7469g");
+    static assert(demangleType(Foo7469h!(3 )    .mangleof) == "template4.Foo7469h!(3u).Foo7469h");
+    static assert(demangleType(Foo7469h!(3u)    .mangleof) == "template4.Foo7469h!(3u).Foo7469h");
 }
 
 /******************************************/
diff --git a/gcc/testsuite/gdc.test/runnable/template9.d b/gcc/testsuite/gdc.test/runnable/template9.d
index 4f18295..b016ff9 100644
--- a/gcc/testsuite/gdc.test/runnable/template9.d
+++ b/gcc/testsuite/gdc.test/runnable/template9.d
@@ -4465,6 +4465,7 @@ void test13807()
 
 /******************************************/
 // 14174
+import imports.testmangle;
 
 struct Config14174(a, b) {}
 
@@ -4474,22 +4475,22 @@ alias defConfig14174 = Config14174!(N14174, N14174);
 
 void accepter14174a(Config : Config14174!(T) = defConfig14174, T...)()
 {
-    static assert(accepter14174a.mangleof
-        == "_D7breaker131__T14"~
+    static assert(equalDemangle(accepter14174a.mangleof,
+           "_D7breaker131__T14"~
            "accepter14174a"~
            "HTS7breaker51__T11Config14174TS7breaker6N14174TS7breaker6N14174Z11Config14174TS7breaker6N14174TS7breaker6N14174Z14"~
            "accepter14174a"~
-           "FZv");
+           "FZv"));
 }
 
 void accepter14174b(Config : Config14174!(T) = defConfig14174, T...)()
 {
-    static assert(accepter14174b.mangleof
-        == "_D7breaker131__T14"~
+    static assert(equalDemangle(accepter14174b.mangleof,
+           "_D7breaker131__T14"~
            "accepter14174b"~
            "HTS7breaker51__T11Config14174TS7breaker6N14174TS7breaker6N14174Z11Config14174TS7breaker6N14174TS7breaker6N14174Z14"~
            "accepter14174b"~
-           "FZv");
+           "FZv"));
 }
 
 void test14174()
diff --git a/gcc/testsuite/gdc.test/runnable/testconst.d b/gcc/testsuite/gdc.test/runnable/testconst.d
index 2da39a2..42f9c1b 100644
--- a/gcc/testsuite/gdc.test/runnable/testconst.d
+++ b/gcc/testsuite/gdc.test/runnable/testconst.d
@@ -84,10 +84,11 @@ void foo8(const char[] s, const C8 c, const int x)
 
 void test8()
 {
+    import core.demangle : demangle;
     auto p = &foo8;
     showf(p.mangleof);
     assert(typeof(p).mangleof == "PFxAaxC9testconst2C8xiZv");
-    assert(p.mangleof == "_D9testconst5test8FZ1pPFxAaxC9testconst2C8xiZv");
+    assert(demangle(p.mangleof) == "void function(const(char[]), const(testconst.C8), const(int))* testconst.test8().p");
 }
 
 /************************************/