gcc/d/dmd/dmangle.d

   1 /**
   2  * Does name mangling for `extern(D)` symbols.
   3  *
   4  * Specification: $(LINK2 https://dlang.org/spec/abi.html#name_mangling, Name Mangling)
   5  *
   6  * Copyright: Copyright (C) 1999-2024 by The D Language Foundation, All Rights Reserved
   7  * Authors: Walter Bright, https://www.digitalmars.com
   8  * License:   $(LINK2 https://www.boost.org/LICENSE_1_0.txt, Boost License 1.0)
   9  * Source:    $(LINK2 https://github.com/dlang/dmd/blob/master/src/dmd/dmangle.d, _dmangle.d)
  10  * Documentation:  https://dlang.org/phobos/dmd_dmangle.html
  11  * Coverage:    https://codecov.io/gh/dlang/dmd/src/master/src/dmd/dmangle.d
  12  * References:  https://dlang.org/blog/2017/12/20/ds-newfangled-name-mangling/
  13  */
  14
  15 module dmd.dmangle;
  16
  17
  18 /******************************************************************************
  19  * Returns exact mangled name of function.
  20  */
  21 extern (C++) const(char)* mangleExact(FuncDeclaration fd)
  22 {
  23     //printf("mangleExact()\n");
  24     if (!fd.mangleString)
  25     {
  26         OutBuffer buf;
  27         auto backref = Backref(null);
  28         scope Mangler v = new Mangler(buf, &backref);
  29         v.mangleExact(fd);
  30         fd.mangleString = buf.extractChars();
  31     }
  32     return fd.mangleString;
  33 }
  34
  35 extern (C++) void mangleToBuffer(Type t, ref OutBuffer buf)
  36 {
  37     //printf("mangleToBuffer t()\n");
  38     if (t.deco)
  39         buf.writestring(t.deco);
  40     else
  41     {
  42         auto backref = Backref(t);
  43         mangleType(t, 0, buf, backref);
  44         //printf("%s\n", buf.peekChars());
  45     }
  46 }
  47
  48 extern (C++) void mangleToBuffer(Expression e, ref OutBuffer buf)
  49 {
  50     //printf("mangleToBuffer e()\n");
  51     auto backref = Backref(null);
  52     scope Mangler v = new Mangler(buf, &backref);
  53     e.accept(v);
  54 }
  55
  56 extern (C++) void mangleToBuffer(Dsymbol s, ref OutBuffer buf)
  57 {
  58     //printf("mangleToBuffer s(%s)\n", s.toChars());
  59     auto backref = Backref(null);
  60     scope Mangler v = new Mangler(buf, &backref);
  61     s.accept(v);
  62 }
  63
  64 extern (C++) void mangleToBuffer(TemplateInstance ti, ref OutBuffer buf)
  65 {
  66     //printf("mangleToBuffer ti()\n");
  67     auto backref = Backref(null);
  68     scope Mangler v = new Mangler(buf, &backref);
  69     v.mangleTemplateInstance(ti);
  70 }
  71
  72 /// Returns: `true` if the given character is a valid mangled character
  73 package bool isValidMangling(dchar c) nothrow
  74 {
  75     return
  76         c >= 'A' && c <= 'Z' ||
  77         c >= 'a' && c <= 'z' ||
  78         c >= '0' && c <= '9' ||
  79         c != 0 && strchr("$%().:?@[]_", c) ||
  80         isUniAlpha(c);
  81 }
  82
  83 // valid mangled characters
  84 unittest
  85 {
  86     assert('a'.isValidMangling);
  87     assert('B'.isValidMangling);
  88     assert('2'.isValidMangling);
  89     assert('@'.isValidMangling);
  90     assert('_'.isValidMangling);
  91 }
  92
  93 // invalid mangled characters
  94 unittest
  95 {
  96     assert(!'-'.isValidMangling);
  97     assert(!0.isValidMangling);
  98     assert(!'/'.isValidMangling);
  99     assert(!'\\'.isValidMangling);
 100 }
 101
 102 /**********************************************
 103  * Convert a string representing a type (the deco) and
 104  * return its equivalent Type.
 105  * Params:
 106  *      deco = string containing the deco
 107  * Returns:
 108  *      null for failed to convert
 109  *      Type for succeeded
 110  */
 111
 112 public Type decoToType(const(char)[] deco)
 113 {
 114     //printf("decoToType(): %.*s\n", cast(int)deco.length, deco.ptr);
 115     if (auto sv = Type.stringtable.lookup(deco))
 116     {
 117         if (sv.value)
 118         {
 119             Type t = cast(Type)sv.value;
 120             assert(t.deco);
 121             return t;
 122         }
 123     }
 124     return null;
 125 }
 126
 127
 128 /***************************************** private ***************************************/
 129
 130 private:
 131
 132
 133 import core.stdc.ctype;
 134 import core.stdc.stdio;
 135 import core.stdc.string;
 136
 137 import dmd.aggregate;
 138 import dmd.arraytypes;
 139 import dmd.astenums;
 140 import dmd.basicmangle;
 141 import dmd.dclass;
 142 import dmd.declaration;
 143 import dmd.dinterpret;
 144 import dmd.dmodule;
 145 import dmd.dsymbol;
 146 import dmd.dtemplate;
 147 import dmd.errors;
 148 import dmd.expression;
 149 import dmd.func;
 150 import dmd.globals;
 151 import dmd.id;
 152 import dmd.identifier;
 153 import dmd.mtype;
 154 import dmd.root.ctfloat;
 155 import dmd.common.outbuffer;
 156 import dmd.optimize;
 157 import dmd.root.aav;
 158 import dmd.root.string;
 159 import dmd.root.stringtable;
 160 import dmd.root.utf;
 161 import dmd.target;
 162 import dmd.tokens;
 163 import dmd.visitor;
 164
 165 /************************************************
 166  * Append the mangling of type `t` to `buf`.
 167  * Params:
 168  *      t = type to mangle
 169  *      modMask = mod bits currently applying to t
 170  *      buf = buffer to append mangling to
 171  *      backref = state of back references (updated)
 172  */
 173 void mangleType(Type t, ubyte modMask, ref OutBuffer buf, ref Backref backref)
 174 {
 175     void visitWithMask(Type t, ubyte modMask)
 176     {
 177         void mangleSymbol(Dsymbol s)
 178         {
 179             scope Mangler v = new Mangler(buf, &backref);
 180             v.mangleSymbol(s);
 181         }
 182
 183         void visitType(Type t)
 184         {
 185             tyToDecoBuffer(buf, t.ty);
 186         }
 187
 188         void visitTypeNext(TypeNext t)
 189         {
 190             visitType(t);
 191             visitWithMask(t.next, t.mod);
 192         }
 193
 194         void visitTypeVector(TypeVector t)
 195         {
 196             buf.writestring("Nh");
 197             visitWithMask(t.basetype, t.mod);
 198         }
 199
 200         void visitTypeSArray(TypeSArray t)
 201         {
 202             visitType(t);
 203             if (t.dim)
 204                 buf.print(t.dim.toInteger());
 205             if (t.next)
 206                 visitWithMask(t.next, t.mod);
 207         }
 208
 209         void visitTypeDArray(TypeDArray t)
 210         {
 211             visitType(t);
 212             if (t.next)
 213                 visitWithMask(t.next, t.mod);
 214         }
 215
 216         void visitTypeAArray(TypeAArray t)
 217         {
 218             visitType(t);
 219             visitWithMask(t.index, 0);
 220             visitWithMask(t.next, t.mod);
 221         }
 222
 223         void visitTypeFunction(TypeFunction t)
 224         {
 225             //printf("TypeFunction.toDecoBuffer() t = %p %s\n", t, t.toChars());
 226             //static int nest; if (++nest == 50) *(char*)0=0;
 227             mangleFuncType(t, t, t.mod, t.next, buf, backref);
 228         }
 229
 230         void visitTypeIdentifier(TypeIdentifier t)
 231         {
 232             visitType(t);
 233             auto name = t.ident.toString();
 234             buf.print(cast(int)name.length);
 235             buf.writestring(name);
 236         }
 237
 238         void visitTypeEnum(TypeEnum t)
 239         {
 240             visitType(t);
 241             mangleSymbol(t.sym);
 242         }
 243
 244         void visitTypeStruct(TypeStruct t)
 245         {
 246             //printf("TypeStruct.toDecoBuffer('%s') = '%s'\n", t.toChars(), name);
 247             visitType(t);
 248             mangleSymbol(t.sym);
 249         }
 250
 251         void visitTypeClass(TypeClass t)
 252         {
 253             //printf("TypeClass.toDecoBuffer('%s' mod=%x) = '%s'\n", t.toChars(), mod, name);
 254             visitType(t);
 255             mangleSymbol(t.sym);
 256         }
 257
 258         void visitTypeTuple(TypeTuple t)
 259         {
 260             //printf("TypeTuple.toDecoBuffer() t = %p, %s\n", t, t.toChars());
 261             visitType(t);
 262             Parameter._foreach(t.arguments, (idx, param) {
 263                     mangleParameter(param, buf, backref);
 264                     return 0;
 265             });
 266             buf.writeByte('Z');
 267         }
 268
 269         void visitTypeNull(TypeNull t)
 270         {
 271             visitType(t);
 272         }
 273
 274         void visitTypeNoreturn(TypeNoreturn t)
 275         {
 276             buf.writestring("Nn");
 277         }
 278
 279         if (modMask != t.mod)
 280         {
 281             MODtoDecoBuffer(buf, t.mod);
 282         }
 283         if (backref.addRefToType(buf, t))
 284             return;
 285
 286         switch (t.ty)
 287         {
 288             case Tpointer:
 289             case Treference:
 290             case Tdelegate:
 291             case Tslice:     visitTypeNext      (cast(TypeNext)t);      break;
 292
 293             case Tarray:     visitTypeDArray    (t.isTypeDArray());     break;
 294             case Tsarray:    visitTypeSArray    (t.isTypeSArray());     break;
 295             case Taarray:    visitTypeAArray    (t.isTypeAArray());     break;
 296             case Tfunction:  visitTypeFunction  (t.isTypeFunction());   break;
 297             case Tident:     visitTypeIdentifier(t.isTypeIdentifier()); break;
 298             case Tclass:     visitTypeClass     (t.isTypeClass());      break;
 299             case Tstruct:    visitTypeStruct    (t.isTypeStruct());     break;
 300             case Tenum:      visitTypeEnum      (t.isTypeEnum());       break;
 301             case Ttuple:     visitTypeTuple     (t.isTypeTuple());      break;
 302             case Tnull:      visitTypeNull      (t.isTypeNull());       break;
 303             case Tvector:    visitTypeVector    (t.isTypeVector());     break;
 304             case Tnoreturn:  visitTypeNoreturn  (t.isTypeNoreturn);     break;
 305
 306             case Terror:
 307                 break;      // ignore errors
 308
 309             default:         visitType(t); break;
 310         }
 311     }
 312
 313     visitWithMask(t, modMask);
 314 }
 315
 316
 317 /*************************************************************
 318  */
 319 void mangleFuncType(TypeFunction t, TypeFunction ta, ubyte modMask, Type tret, ref OutBuffer buf, ref Backref backref)
 320 {
 321     //printf("mangleFuncType() %s\n", t.toChars());
 322     if (t.inuse && tret)
 323     {
 324         // printf("TypeFunction.mangleFuncType() t = %s inuse\n", t.toChars());
 325         t.inuse = 2; // flag error to caller
 326         return;
 327     }
 328     t.inuse++;
 329     if (modMask != t.mod)
 330         MODtoDecoBuffer(buf, t.mod);
 331
 332     char mc;
 333     final switch (t.linkage)
 334     {
 335     case LINK.default_:
 336     case LINK.d:
 337         mc = 'F';
 338         break;
 339     case LINK.c:
 340         mc = 'U';
 341         break;
 342     case LINK.windows:
 343         mc = 'W';
 344         break;
 345     case LINK.cpp:
 346         mc = 'R';
 347         break;
 348     case LINK.objc:
 349         mc = 'Y';
 350         break;
 351     case LINK.system:
 352         assert(0);
 353     }
 354     buf.writeByte(mc);
 355
 356     if (ta.purity)
 357         buf.writestring("Na");
 358     if (ta.isnothrow)
 359         buf.writestring("Nb");
 360     if (ta.isref)
 361         buf.writestring("Nc");
 362     if (ta.isproperty)
 363         buf.writestring("Nd");
 364     if (ta.isnogc)
 365         buf.writestring("Ni");
 366
 367     // `return scope` must be in that order
 368     if (ta.isreturnscope && !ta.isreturninferred)
 369     {
 370         buf.writestring("NjNl");
 371     }
 372     else
 373     {
 374         // when return ref, the order is `scope return`
 375         if (ta.isScopeQual && !ta.isscopeinferred)
 376             buf.writestring("Nl");
 377
 378         if (ta.isreturn && !ta.isreturninferred)
 379             buf.writestring("Nj");
 380     }
 381
 382     if (ta.islive)
 383         buf.writestring("Nm");
 384
 385     switch (ta.trust)
 386     {
 387         case TRUST.trusted:
 388             buf.writestring("Ne");
 389             break;
 390         case TRUST.safe:
 391             buf.writestring("Nf");
 392             break;
 393         default:
 394             break;
 395     }
 396
 397     // Write argument types
 398     foreach (idx, param; t.parameterList)
 399         mangleParameter(param, buf, backref);
 400     //if (buf.data[buf.length - 1] == '@') assert(0);
 401     buf.writeByte('Z' - t.parameterList.varargs); // mark end of arg list
 402     if (tret !is null)
 403         mangleType(tret, 0, buf, backref);
 404     t.inuse--;
 405 }
 406
 407 /*************************************************************
 408  */
 409 void mangleParameter(Parameter p, ref OutBuffer buf, ref Backref backref)
 410 {
 411     // https://dlang.org/spec/abi.html#Parameter
 412
 413     auto stc = p.storageClass;
 414
 415     // Inferred storage classes don't get mangled in
 416     if (stc & STC.scopeinferred)
 417         stc &= ~(STC.scope_ | STC.scopeinferred);
 418     if (stc & STC.returninferred)
 419         stc &= ~(STC.return_ | STC.returninferred);
 420
 421     // much like hdrgen.stcToBuffer()
 422     string rrs;
 423     const isout = (stc & STC.out_) != 0;
 424     final switch (buildScopeRef(stc))
 425     {
 426         case ScopeRef.None:
 427         case ScopeRef.Scope:
 428         case ScopeRef.Ref:
 429         case ScopeRef.Return:
 430         case ScopeRef.RefScope:
 431             break;
 432
 433         case ScopeRef.ReturnScope:     rrs = "NkM";                  goto L1;  // return scope
 434         case ScopeRef.ReturnRef:       rrs = isout ? "NkJ"  : "NkK"; goto L1;  // return ref
 435         case ScopeRef.ReturnRef_Scope: rrs = isout ? "MNkJ" : "MNkK"; goto L1; // scope return ref
 436         case ScopeRef.Ref_ReturnScope: rrs = isout ? "NkMJ" : "NkMK"; goto L1; // return scope ref
 437         L1:
 438             buf.writestring(rrs);
 439             stc &= ~(STC.out_ | STC.scope_ | STC.ref_ | STC.return_);
 440             break;
 441     }
 442
 443     if (stc & STC.scope_)
 444         buf.writeByte('M');  // scope
 445
 446     if (stc & STC.return_)
 447         buf.writestring("Nk"); // return
 448
 449     switch (stc & ((STC.IOR | STC.lazy_) & ~STC.constscoperef))
 450     {
 451     case 0:
 452         break;
 453     case STC.in_:
 454         buf.writeByte('I');
 455         break;
 456     case STC.in_ | STC.ref_:
 457         buf.writestring("IK");
 458         break;
 459     case STC.out_:
 460         buf.writeByte('J');
 461         break;
 462     case STC.ref_:
 463         buf.writeByte('K');
 464         break;
 465     case STC.lazy_:
 466         buf.writeByte('L');
 467         break;
 468     default:
 469         debug
 470         {
 471             printf("storageClass = x%llx\n", stc & (STC.IOR | STC.lazy_));
 472         }
 473         assert(0);
 474     }
 475     mangleType(p.type, (stc & STC.in_) ? MODFlags.const_ : 0, buf, backref);
 476 }
 477
 478
 479 private extern (C++) final class Mangler : Visitor
 480 {
 481     alias visit = Visitor.visit;
 482 public:
 483     static assert(Key.sizeof == size_t.sizeof);
 484
 485     OutBuffer* buf;
 486     Backref* backref;
 487
 488     extern (D) this(ref OutBuffer buf, Backref* backref) @trusted
 489     {
 490         this.buf = &buf;
 491         this.backref = backref;
 492     }
 493
 494     void mangleSymbol(Dsymbol s)
 495     {
 496         s.accept(this);
 497     }
 498
 499     void mangleIdentifier(Identifier id, Dsymbol s)
 500     {
 501         if (!backref.addRefToIdentifier(*buf, id))
 502             toBuffer(*buf, id.toString(), s);
 503     }
 504
 505     void mangleInteger(dinteger_t v)
 506     {
 507         if (cast(sinteger_t) v < 0)
 508         {
 509             buf.writeByte('N');
 510             buf.print(-v);
 511         }
 512         else
 513         {
 514             buf.writeByte('i');
 515             buf.print(v);
 516         }
 517     }
 518
 519     ////////////////////////////////////////////////////////////////////////////
 520     void mangleDecl(Declaration sthis)
 521     {
 522         mangleParent(sthis);
 523         assert(sthis.ident);
 524         mangleIdentifier(sthis.ident, sthis);
 525         if (FuncDeclaration fd = sthis.isFuncDeclaration())
 526         {
 527             mangleFunc(fd, false);
 528         }
 529         else if (sthis.type)
 530         {
 531             mangleType(sthis.type, 0, *buf, *backref);
 532         }
 533         else
 534             assert(0);
 535     }
 536
 537     void mangleParent(Dsymbol s)
 538     {
 539         //printf("mangleParent() %s %s\n", s.kind(), s.toChars());
 540         Dsymbol p;
 541         if (TemplateInstance ti = s.isTemplateInstance())
 542             p = ti.isTemplateMixin() ? ti.parent : ti.tempdecl.parent;
 543         else
 544             p = s.parent;
 545         if (p)
 546         {
 547             uint localNum = s.localNum;
 548             mangleParent(p);
 549             auto ti = p.isTemplateInstance();
 550             if (ti && !ti.isTemplateMixin())
 551             {
 552                 localNum = ti.tempdecl.localNum;
 553                 mangleTemplateInstance(ti);
 554             }
 555             else if (p.getIdent())
 556             {
 557                 mangleIdentifier(p.ident, s);
 558                 if (FuncDeclaration f = p.isFuncDeclaration())
 559                     mangleFunc(f, true);
 560             }
 561             else
 562                 buf.writeByte('0');
 563
 564             if (localNum)
 565                 writeLocalParent(*buf, localNum);
 566         }
 567     }
 568
 569     void mangleFunc(FuncDeclaration fd, bool inParent)
 570     {
 571         //printf("deco = '%s'\n", fd.type.deco ? fd.type.deco : "null");
 572         //printf("fd.type = %s\n", fd.type.toChars());
 573         if (fd.needThis() || fd.isNested())
 574             buf.writeByte('M');
 575
 576         if (!fd.type || fd.type.ty == Terror)
 577         {
 578             // never should have gotten here, but could be the result of
 579             // failed speculative compilation
 580             buf.writestring("9__error__FZ");
 581
 582             //printf("[%s] %s no type\n", fd.loc.toChars(), fd.toChars());
 583             //assert(0); // don't mangle function until semantic3 done.
 584         }
 585         else if (inParent)
 586         {
 587             TypeFunction tf = fd.type.isTypeFunction();
 588             TypeFunction tfo = fd.originalType.isTypeFunction();
 589             mangleFuncType(tf, tfo, 0, null, *buf, *backref);
 590         }
 591         else
 592         {
 593             mangleType(fd.type, 0, *buf, *backref);
 594         }
 595     }
 596
 597     override void visit(Declaration d)
 598     {
 599         //printf("Declaration.mangle(this = %p, '%s', parent = '%s', linkage = %d)\n",
 600         //        d, d.toChars(), d.parent ? d.parent.toChars() : "null", d.linkage);
 601         if (const id = externallyMangledIdentifier(d))
 602         {
 603             buf.writestring(id);
 604             return;
 605         }
 606         buf.writestring("_D");
 607         mangleDecl(d);
 608         debug
 609         {
 610             const slice = (*buf)[];
 611             assert(slice.length);
 612             for (size_t pos; pos < slice.length; )
 613             {
 614                 dchar c;
 615                 auto ppos = pos;
 616                 const s = utf_decodeChar(slice, pos, c);
 617                 assert(s is null, s);
 618                 assert(c.isValidMangling, "The mangled name '" ~ slice ~ "' " ~
 619                     "contains an invalid character: " ~ slice[ppos..pos]);
 620             }
 621         }
 622     }
 623
 624     /******************************************************************************
 625      * Normally FuncDeclaration and FuncAliasDeclaration have overloads.
 626      * If and only if there is no overloads, mangle() could return
 627      * exact mangled name.
 628      *
 629      *      module test;
 630      *      void foo(long) {}           // _D4test3fooFlZv
 631      *      void foo(string) {}         // _D4test3fooFAyaZv
 632      *
 633      *      // from FuncDeclaration.mangle().
 634      *      pragma(msg, foo.mangleof);  // prints unexact mangled name "4test3foo"
 635      *                                  // by calling Dsymbol.mangle()
 636      *
 637      *      // from FuncAliasDeclaration.mangle()
 638      *      pragma(msg, __traits(getOverloads, test, "foo")[0].mangleof);  // "_D4test3fooFlZv"
 639      *      pragma(msg, __traits(getOverloads, test, "foo")[1].mangleof);  // "_D4test3fooFAyaZv"
 640      *
 641      * If a function has no overloads, .mangleof property still returns exact mangled name.
 642      *
 643      *      void bar() {}
 644      *      pragma(msg, bar.mangleof);  // still prints "_D4test3barFZv"
 645      *                                  // by calling FuncDeclaration.mangleExact().
 646      */
 647     override void visit(FuncDeclaration fd)
 648     {
 649         if (fd.isUnique())
 650             mangleExact(fd);
 651         else
 652             visit(cast(Dsymbol)fd);
 653     }
 654
 655     // ditto
 656     override void visit(FuncAliasDeclaration fd)
 657     {
 658         FuncDeclaration f = fd.toAliasFunc();
 659         FuncAliasDeclaration fa = f.isFuncAliasDeclaration();
 660         if (!fd.hasOverloads && !fa)
 661         {
 662             mangleExact(f);
 663             return;
 664         }
 665         if (fa)
 666         {
 667             mangleSymbol(fa);
 668             return;
 669         }
 670         visit(cast(Dsymbol)fd);
 671     }
 672
 673     override void visit(OverDeclaration od)
 674     {
 675         if (od.overnext)
 676         {
 677             visit(cast(Dsymbol)od);
 678             return;
 679         }
 680         if (FuncDeclaration fd = od.aliassym.isFuncDeclaration())
 681         {
 682             if (fd.isUnique())
 683             {
 684                 mangleExact(fd);
 685                 return;
 686             }
 687         }
 688         if (TemplateDeclaration td = od.aliassym.isTemplateDeclaration())
 689         {
 690             if (td.overnext is null)
 691             {
 692                 mangleSymbol(td);
 693                 return;
 694             }
 695         }
 696         visit(cast(Dsymbol)od);
 697     }
 698
 699     void mangleExact(FuncDeclaration fd)
 700     {
 701         assert(!fd.isFuncAliasDeclaration());
 702         if (fd.mangleOverride)
 703         {
 704             buf.writestring(fd.mangleOverride);
 705             return;
 706         }
 707         if (fd.isMain())
 708         {
 709             buf.writestring("_Dmain");
 710             return;
 711         }
 712         if (fd.isWinMain() || fd.isDllMain())
 713         {
 714             buf.writestring(fd.ident.toString());
 715             return;
 716         }
 717         visit(cast(Declaration)fd);
 718     }
 719
 720     override void visit(VarDeclaration vd)
 721     {
 722         if (vd.mangleOverride)
 723         {
 724             buf.writestring(vd.mangleOverride);
 725             return;
 726         }
 727         visit(cast(Declaration)vd);
 728     }
 729
 730     override void visit(AggregateDeclaration ad)
 731     {
 732         ClassDeclaration cd = ad.isClassDeclaration();
 733         Dsymbol parentsave = ad.parent;
 734         if (cd)
 735         {
 736             /* These are reserved to the compiler, so keep simple
 737              * names for them.
 738              */
 739             if (cd.ident == Id.Exception && cd.parent.ident == Id.object || cd.ident == Id.TypeInfo || cd.ident == Id.TypeInfo_Struct || cd.ident == Id.TypeInfo_Class || cd.ident == Id.TypeInfo_Tuple || cd == ClassDeclaration.object || cd == Type.typeinfoclass || cd == Module.moduleinfo || strncmp(cd.ident.toChars(), "TypeInfo_", 9) == 0)
 740             {
 741                 // Don't mangle parent
 742                 ad.parent = null;
 743             }
 744         }
 745         visit(cast(Dsymbol)ad);
 746         ad.parent = parentsave;
 747     }
 748
 749     override void visit(TemplateInstance ti)
 750     {
 751         version (none)
 752         {
 753             printf("TemplateInstance.mangle() %p %s", ti, ti.toChars());
 754             if (ti.parent)
 755                 printf("  parent = %s %s", ti.parent.kind(), ti.parent.toChars());
 756             printf("\n");
 757         }
 758         if (!ti.tempdecl)
 759             error(ti.loc, "%s `%s` is not defined", ti.kind, ti.toPrettyChars);
 760         else
 761             mangleParent(ti);
 762
 763         if (ti.isTemplateMixin() && ti.ident)
 764             mangleIdentifier(ti.ident, ti);
 765         else
 766             mangleTemplateInstance(ti);
 767     }
 768
 769     void mangleTemplateInstance(TemplateInstance ti)
 770     {
 771         TemplateDeclaration tempdecl = ti.tempdecl.isTemplateDeclaration();
 772         assert(tempdecl);
 773
 774         // Use "__U" for the symbols declared inside template constraint.
 775         const char T = ti.members ? 'T' : 'U';
 776         buf.printf("__%c", T);
 777         mangleIdentifier(tempdecl.ident, tempdecl);
 778
 779         auto args = ti.tiargs;
 780         size_t nparams = tempdecl.parameters.length - (tempdecl.isVariadic() ? 1 : 0);
 781         for (size_t i = 0; i < args.length; i++)
 782         {
 783             auto o = (*args)[i];
 784             Type ta = isType(o);
 785             Expression ea = isExpression(o);
 786             Dsymbol sa = isDsymbol(o);
 787             Tuple va = isTuple(o);
 788             //printf("\to [%d] %p ta %p ea %p sa %p va %p\n", i, o, ta, ea, sa, va);
 789             if (i < nparams && (*tempdecl.parameters)[i].specialization())
 790                 buf.writeByte('H'); // https://issues.dlang.org/show_bug.cgi?id=6574
 791             if (ta)
 792             {
 793                 buf.writeByte('T');
 794                 mangleType(ta, 0, *buf, *backref);
 795             }
 796             else if (ea)
 797             {
 798                 // Don't interpret it yet, it might actually be an alias template parameter.
 799                 // Only constfold manifest constants, not const/immutable lvalues, see https://issues.dlang.org/show_bug.cgi?id=17339.
 800                 enum keepLvalue = true;
 801                 ea = ea.optimize(WANTvalue, keepLvalue);
 802                 if (auto ev = ea.isVarExp())
 803                 {
 804                     sa = ev.var;
 805                     ea = null;
 806                     goto Lsa;
 807                 }
 808                 if (auto et = ea.isThisExp())
 809                 {
 810                     sa = et.var;
 811                     ea = null;
 812                     goto Lsa;
 813                 }
 814                 if (auto ef = ea.isFuncExp())
 815                 {
 816                     if (ef.td)
 817                         sa = ef.td;
 818                     else
 819                         sa = ef.fd;
 820                     ea = null;
 821                     goto Lsa;
 822                 }
 823                 buf.writeByte('V');
 824                 if (ea.op == EXP.tuple)
 825                 {
 826                     error(ea.loc, "sequence is not a valid template value argument");
 827                     continue;
 828                 }
 829                 // Now that we know it is not an alias, we MUST obtain a value
 830                 uint olderr = global.errors;
 831                 ea = ea.ctfeInterpret();
 832                 if (ea.op == EXP.error || olderr != global.errors)
 833                     continue;
 834
 835                 /* Use type mangling that matches what it would be for a function parameter
 836                 */
 837                 mangleType(ea.type, 0, *buf, *backref);
 838                 ea.accept(this);
 839             }
 840             else if (sa)
 841             {
 842             Lsa:
 843                 sa = sa.toAlias();
 844                 if (sa.isDeclaration() && !sa.isOverDeclaration())
 845                 {
 846                     Declaration d = sa.isDeclaration();
 847
 848                     if (auto fad = d.isFuncAliasDeclaration())
 849                         d = fad.toAliasFunc();
 850                     if (d.mangleOverride)
 851                     {
 852                         buf.writeByte('X');
 853                         toBuffer(*buf, d.mangleOverride, d);
 854                         continue;
 855                     }
 856                     if (const id = externallyMangledIdentifier(d))
 857                     {
 858                         buf.writeByte('X');
 859                         toBuffer(*buf, id, d);
 860                         continue;
 861                     }
 862                     if (!d.type || !d.type.deco)
 863                     {
 864                         error(ti.loc, "%s `%s` forward reference of %s `%s`", ti.kind, ti.toPrettyChars, d.kind(), d.toChars());
 865                         continue;
 866                     }
 867                 }
 868                 buf.writeByte('S');
 869                 mangleSymbol(sa);
 870             }
 871             else if (va)
 872             {
 873                 assert(i + 1 == args.length); // must be last one
 874                 args = &va.objects;
 875                 i = -cast(size_t)1;
 876             }
 877             else
 878                 assert(0);
 879         }
 880         buf.writeByte('Z');
 881     }
 882
 883     override void visit(Dsymbol s)
 884     {
 885         version (none)
 886         {
 887             printf("Dsymbol.mangle() '%s'", s.toChars());
 888             if (s.parent)
 889                 printf("  parent = %s %s", s.parent.kind(), s.parent.toChars());
 890             printf("\n");
 891         }
 892         if (s.parent && s.ident)
 893         {
 894             if (auto m = s.parent.isModule())
 895             {
 896                 if (m.filetype == FileType.c)
 897                 {
 898                     /* C types at global level get mangled into the __C global namespace
 899                      * to get the same mangling regardless of which module it
 900                      * is declared in. This works because types are the same if the mangling
 901                      * is the same.
 902                      */
 903                     mangleIdentifier(Id.ImportC, s); // parent
 904                     mangleIdentifier(s.ident, s);
 905                     return;
 906                 }
 907             }
 908         }
 909         mangleParent(s);
 910         if (s.ident)
 911             mangleIdentifier(s.ident, s);
 912         else
 913             toBuffer(*buf, s.toString(), s);
 914         //printf("Dsymbol.mangle() %s = %s\n", s.toChars(), id);
 915     }
 916
 917     ////////////////////////////////////////////////////////////////////////////
 918     override void visit(Expression e)
 919     {
 920         if (!e.type.isTypeError())
 921             error(e.loc, "expression `%s` is not a valid template value argument", e.toChars());
 922     }
 923
 924     override void visit(IntegerExp e)
 925     {
 926         mangleInteger(e.toInteger());
 927     }
 928
 929     override void visit(RealExp e)
 930     {
 931         buf.writeByte('e');
 932         realToMangleBuffer(*buf, e.value);
 933     }
 934
 935     override void visit(ComplexExp e)
 936     {
 937         buf.writeByte('c');
 938         realToMangleBuffer(*buf, e.toReal());
 939         buf.writeByte('c'); // separate the two
 940         realToMangleBuffer(*buf, e.toImaginary());
 941     }
 942
 943     override void visit(NullExp e)
 944     {
 945         buf.writeByte('n');
 946     }
 947
 948     override void visit(StringExp e)
 949     {
 950         char m;
 951         OutBuffer tmp;
 952         const(char)[] q;
 953
 954         /* Write string in UTF-8 format
 955          */
 956         switch (e.sz)
 957         {
 958         case 1:
 959             m = 'a';
 960             q = e.peekString();
 961             break;
 962         case 2:
 963         {
 964             m = 'w';
 965             const slice = e.peekWstring();
 966             for (size_t u = 0; u < e.len;)
 967             {
 968                 dchar c;
 969                 if (const s = utf_decodeWchar(slice, u, c))
 970                     error(e.loc, "%.*s", cast(int)s.length, s.ptr);
 971                 else
 972                     tmp.writeUTF8(c);
 973             }
 974             q = tmp[];
 975             break;
 976         }
 977         case 4:
 978         {
 979             m = 'd';
 980             const slice = e.peekDstring();
 981             foreach (c; slice)
 982             {
 983                 if (!utf_isValidDchar(c))
 984                     error(e.loc, "invalid UCS-32 char \\U%08x", c);
 985                 else
 986                     tmp.writeUTF8(c);
 987             }
 988             q = tmp[];
 989             break;
 990         }
 991         case 8:
 992             // String of size 8 has to be hexstring cast to long[], mangle as array literal
 993             buf.writeByte('A');
 994             buf.print(e.len);
 995             foreach (i; 0 .. e.len)
 996             {
 997                 mangleInteger(e.getIndex(i));
 998             }
 999             return;
1000         default:
1001             assert(0);
1002         }
1003         buf.reserve(1 + 11 + 2 * q.length);
1004         buf.writeByte(m);
1005         buf.print(q.length);
1006         buf.writeByte('_');    // nbytes <= 11
1007         buf.writeHexString(cast(const(ubyte)[]) q, false);
1008     }
1009
1010     override void visit(ArrayLiteralExp e)
1011     {
1012         const dim = e.elements ? e.elements.length : 0;
1013         buf.writeByte('A');
1014         buf.print(dim);
1015         foreach (i; 0 .. dim)
1016         {
1017             e[i].accept(this);
1018         }
1019     }
1020
1021     override void visit(AssocArrayLiteralExp e)
1022     {
1023         const dim = e.keys.length;
1024         buf.writeByte('A');
1025         buf.print(dim);
1026         foreach (i; 0 .. dim)
1027         {
1028             (*e.keys)[i].accept(this);
1029             (*e.values)[i].accept(this);
1030         }
1031     }
1032
1033     override void visit(StructLiteralExp e)
1034     {
1035         const dim = e.elements ? e.elements.length : 0;
1036         buf.writeByte('S');
1037         buf.print(dim);
1038         foreach (i; 0 .. dim)
1039         {
1040             Expression ex = (*e.elements)[i];
1041             if (ex)
1042                 ex.accept(this);
1043             else
1044                 buf.writeByte('v'); // 'v' for void
1045         }
1046     }
1047
1048     override void visit(FuncExp e)
1049     {
1050         buf.writeByte('f');
1051         if (e.td)
1052             mangleSymbol(e.td);
1053         else
1054             mangleSymbol(e.fd);
1055     }
1056 }
1057
1058 /***************************************
1059  * Manage back reference mangling
1060  */
1061 private struct Backref
1062 {
1063     /**
1064     * Back references a non-basic type
1065     *
1066     * The encoded mangling is
1067     *       'Q' <relative position of first occurrence of type>
1068     *
1069     * Params:
1070     *  t = the type to encode via back referencing
1071     *
1072     * Returns:
1073     *  true if the type was found. A back reference has been encoded.
1074     *  false if the type was not found. The current position is saved for later back references.
1075     */
1076     bool addRefToType(ref OutBuffer buf, Type t)
1077     {
1078         if (t.isTypeBasic())
1079             return false;
1080
1081         /**
1082          * https://issues.dlang.org/show_bug.cgi?id=21591
1083          *
1084          * Special case for unmerged TypeFunctions: use the generic merged
1085          * function type as backref cache key to avoid missed backrefs.
1086          *
1087          * Merging is based on mangling, so we need to avoid an infinite
1088          * recursion by excluding the case where `t` is the root type passed to
1089          * `mangleToBuffer()`.
1090          */
1091         if (t != rootType)
1092         {
1093             if (t.isFunction_Delegate_PtrToFunction())
1094             {
1095                 import dmd.typesem : merge2;
1096                 t = t.merge2();
1097             }
1098         }
1099
1100         return backrefImpl(buf, types, t);
1101     }
1102
1103     /**
1104     * Back references a single identifier
1105     *
1106     * The encoded mangling is
1107     *       'Q' <relative position of first occurrence of type>
1108     *
1109     * Params:
1110     *  id = the identifier to encode via back referencing
1111     *
1112     * Returns:
1113     *  true if the identifier was found. A back reference has been encoded.
1114     *  false if the identifier was not found. The current position is saved for later back references.
1115     */
1116     bool addRefToIdentifier(ref OutBuffer buf, Identifier id)
1117     {
1118         return backrefImpl(buf, idents, id);
1119     }
1120
1121   private:
1122
1123     extern(D) bool backrefImpl(T)(ref OutBuffer buf, ref AssocArray!(T, size_t) aa, T key)
1124     {
1125         auto p = aa.getLvalue(key);
1126         if (*p)
1127         {
1128             const offset = *p - 1;
1129             writeBackRef(buf, buf.length - offset);
1130             return true;
1131         }
1132         *p = buf.length + 1;
1133         return false;
1134     }
1135
1136     Type rootType;                          /// avoid infinite recursion
1137     AssocArray!(Type, size_t) types;        /// Type => (offset+1) in buf
1138     AssocArray!(Identifier, size_t) idents; /// Identifier => (offset+1) in buf
1139 }
1140
1141 /*********************************
1142  * Mangling for mod.
1143  */
1144 private void MODtoDecoBuffer(ref OutBuffer buf, MOD mod) @safe
1145 {
1146     switch (mod)
1147     {
1148     case 0:
1149         break;
1150     case MODFlags.const_:
1151         buf.writeByte('x');
1152         break;
1153     case MODFlags.immutable_:
1154         buf.writeByte('y');
1155         break;
1156     case MODFlags.shared_:
1157         buf.writeByte('O');
1158         break;
1159     case MODFlags.shared_ | MODFlags.const_:
1160         buf.writestring("Ox");
1161         break;
1162     case MODFlags.wild:
1163         buf.writestring("Ng");
1164         break;
1165     case MODFlags.wildconst:
1166         buf.writestring("Ngx");
1167         break;
1168     case MODFlags.shared_ | MODFlags.wild:
1169         buf.writestring("ONg");
1170         break;
1171     case MODFlags.shared_ | MODFlags.wildconst:
1172         buf.writestring("ONgx");
1173         break;
1174     default:
1175         assert(0);
1176     }
1177 }
1178
1179
1180 /**
1181  * writes a back reference with the relative position encoded with base 26
1182  *  using upper case letters for all digits but the last digit which uses
1183  *  a lower case letter.
1184  * The decoder has to look up the referenced position to determine
1185  *  whether the back reference is an identifier (starts with a digit)
1186  *  or a type (starts with a letter).
1187  *
1188  * Params:
1189  *  buf           = buffer to write to
1190  *  pos           = relative position to encode
1191  */
1192 private
1193 void writeBackRef(ref OutBuffer buf, size_t pos) @safe
1194 {
1195     buf.writeByte('Q');
1196     enum base = 26;
1197     size_t mul = 1;
1198     while (pos >= mul * base)
1199         mul *= base;
1200     while (mul >= base)
1201     {
1202         auto dig = cast(ubyte)(pos / mul);
1203         buf.writeByte('A' + dig);
1204         pos -= dig * mul;
1205         mul /= base;
1206     }
1207     buf.writeByte('a' + cast(ubyte)pos);
1208 }
1209
1210
1211 /************************************************************
1212  * Write length prefixed string to buf.
1213  */
1214 private
1215 extern (D) void toBuffer(ref OutBuffer buf, const(char)[] id, Dsymbol s)
1216 {
1217     const len = id.length;
1218     if (buf.length + len >= 8 * 1024 * 1024) // 8 megs ought be enough for anyone
1219         error(s.loc, "%s `%s` excessive length %llu for symbol, possible recursive expansion?", s.kind, s.toPrettyChars, cast(ulong)(buf.length + len));
1220     else
1221     {
1222         buf.print(len);
1223         buf.writestring(id);
1224     }
1225 }
1226
1227
1228 /*****
1229  * There can be multiple different declarations in the same
1230  * function that have the same mangled name.
1231  * This results in localNum having a non-zero number, which
1232  * is used to add a fake parent of the form `__Sddd` to make
1233  * the mangled names unique.
1234  * https://issues.dlang.org/show_bug.cgi?id=20565
1235  * Params:
1236  *      buf = buffer to write to
1237  *      localNum = local symbol number
1238  */
1239 private
1240 void writeLocalParent(ref OutBuffer buf, uint localNum)
1241 {
1242     uint ndigits = 1;
1243     auto n = localNum;
1244     while (n >= 10)
1245     {
1246         n /= 10;
1247         ++ndigits;
1248     }
1249     buf.printf("%u__S%u", ndigits + 3, localNum);
1250 }
1251
1252 /*************************
1253  * Write real to buffer.
1254  * Params:
1255  *      buf = buffer to write to
1256  *      value = real to write
1257  */
1258 private
1259 void realToMangleBuffer(ref OutBuffer buf, real_t value)
1260 {
1261     /* Rely on %A to get portable mangling.
1262      * Must munge result to get only identifier characters.
1263      *
1264      * Possible values from %A  => mangled result
1265      * NAN                      => NAN
1266      * -INF                     => NINF
1267      * INF                      => INF
1268      * -0X1.1BC18BA997B95P+79   => N11BC18BA997B95P79
1269      * 0X1.9P+2                 => 19P2
1270      */
1271     if (CTFloat.isNaN(value))
1272     {
1273         buf.writestring("NAN"); // no -NAN bugs
1274         return;
1275     }
1276
1277     if (value < CTFloat.zero)
1278     {
1279         buf.writeByte('N');
1280         value = -value;
1281     }
1282
1283     if (CTFloat.isInfinity(value))
1284     {
1285         buf.writestring("INF");
1286         return;
1287     }
1288
1289     char[36] buffer = void;
1290     // 'A' format yields [-]0xh.hhhhp+-d
1291     const n = CTFloat.sprint(buffer.ptr, buffer.length, 'A', value);
1292     assert(n < buffer.length);
1293     foreach (const c; buffer[2 .. n])
1294     {
1295         switch (c)
1296         {
1297             case '-':
1298                 buf.writeByte('N');
1299                 break;
1300
1301             case '+':
1302             case '.':
1303                 break;
1304
1305             default:
1306                 buf.writeByte(c);
1307                 break;
1308         }
1309     }
1310 }
1311
1312 /************************************************************
1313  * Try to obtain an externally mangled identifier from a declaration.
1314  * If the declaration is at global scope or mixed in at global scope,
1315  * the user might want to call it externally, so an externally mangled
1316  * name is returned. Member functions or nested functions can't be called
1317  * externally in C, so in that case null is returned. C++ does support
1318  * namespaces, so extern(C++) always gives a C++ mangled name.
1319  *
1320  * See also: https://issues.dlang.org/show_bug.cgi?id=20012
1321  *
1322  * Params:
1323  *     d = declaration to mangle
1324  *
1325  * Returns:
1326  *     an externally mangled name or null if the declaration cannot be called externally
1327  */
1328 private
1329 extern (D) const(char)[] externallyMangledIdentifier(Declaration d)
1330 {
1331     assert(!d.mangleOverride, "mangle overrides should have been handled earlier");
1332
1333     const linkage = d.resolvedLinkage();
1334     const par = d.toParent(); //toParent() skips over mixin templates
1335     if (!par || par.isModule() || linkage == LINK.cpp ||
1336         (linkage == LINK.c && d.isCsymbol() &&
1337          (d.isFuncDeclaration() ||
1338           (d.isVarDeclaration() && d.isDataseg() && d.storage_class & STC.extern_))))
1339     {
1340         if (linkage != LINK.d && d.localNum)
1341             error(d.loc, "%s `%s` the same declaration cannot be in multiple scopes with non-D linkage", d.kind, d.toPrettyChars);
1342
1343         final switch (linkage)
1344         {
1345             case LINK.d:
1346                 break;
1347             case LINK.c:
1348             case LINK.windows:
1349             case LINK.objc:
1350                 return d.ident.toString();
1351             case LINK.cpp:
1352             {
1353                 const p = target.cpp.toMangle(d);
1354                 return p.toDString();
1355             }
1356             case LINK.default_:
1357                 error(d.loc, "%s `%s` forward declaration", d.kind, d.toPrettyChars);
1358                 return d.ident.toString();
1359             case LINK.system:
1360                 assert(0);
1361         }
1362     }
1363     return null;
1364 }