/**
* Does name mangling for `extern(D)` symbols.
*
* Specification: $(LINK2 https://dlang.org/spec/abi.html#name_mangling, Name Mangling)
*
* Copyright: Copyright (C) 1999-2023 by The D Language Foundation, All Rights Reserved
* Authors: Walter Bright, https://www.digitalmars.com
* License: $(LINK2 https://www.boost.org/LICENSE_1_0.txt, Boost License 1.0)
* Source: $(LINK2 https://github.com/dlang/dmd/blob/master/src/dmd/dmangle.d, _dmangle.d)
* Documentation: https://dlang.org/phobos/dmd_dmangle.html
* Coverage: https://codecov.io/gh/dlang/dmd/src/master/src/dmd/dmangle.d
* References: https://dlang.org/blog/2017/12/20/ds-newfangled-name-mangling/
*/
module dmd.dmangle;
/******************************************************************************
* Returns exact mangled name of function.
*/
extern (C++) const(char)* mangleExact(FuncDeclaration fd)
{
//printf("mangleExact()\n");
if (!fd.mangleString)
{
OutBuffer buf;
auto backref = Backref(null);
scope Mangler v = new Mangler(&buf, &backref);
v.mangleExact(fd);
fd.mangleString = buf.extractChars();
}
return fd.mangleString;
}
extern (C++) void mangleToBuffer(Type t, OutBuffer* buf)
{
//printf("mangleToBuffer t()\n");
if (t.deco)
buf.writestring(t.deco);
else
{
auto backref = Backref(t);
mangleType(t, 0, buf, backref);
//printf("%s\n", buf.peekChars());
}
}
extern (C++) void mangleToBuffer(Expression e, OutBuffer* buf)
{
//printf("mangleToBuffer e()\n");
auto backref = Backref(null);
scope Mangler v = new Mangler(buf, &backref);
e.accept(v);
}
extern (C++) void mangleToBuffer(Dsymbol s, OutBuffer* buf)
{
//printf("mangleToBuffer s(%s)\n", s.toChars());
auto backref = Backref(null);
scope Mangler v = new Mangler(buf, &backref);
s.accept(v);
}
extern (C++) void mangleToBuffer(TemplateInstance ti, OutBuffer* buf)
{
//printf("mangleToBuffer ti()\n");
auto backref = Backref(null);
scope Mangler v = new Mangler(buf, &backref);
v.mangleTemplateInstance(ti);
}
/// Returns: `true` if the given character is a valid mangled character
package bool isValidMangling(dchar c) nothrow
{
return
c >= 'A' && c <= 'Z' ||
c >= 'a' && c <= 'z' ||
c >= '0' && c <= '9' ||
c != 0 && strchr("$%().:?@[]_", c) ||
isUniAlpha(c);
}
// valid mangled characters
unittest
{
assert('a'.isValidMangling);
assert('B'.isValidMangling);
assert('2'.isValidMangling);
assert('@'.isValidMangling);
assert('_'.isValidMangling);
}
// invalid mangled characters
unittest
{
assert(!'-'.isValidMangling);
assert(!0.isValidMangling);
assert(!'/'.isValidMangling);
assert(!'\\'.isValidMangling);
}
/**********************************************
* Convert a string representing a type (the deco) and
* return its equivalent Type.
* Params:
* deco = string containing the deco
* Returns:
* null for failed to convert
* Type for succeeded
*/
public Type decoToType(const(char)[] deco)
{
//printf("decoToType(): %.*s\n", cast(int)deco.length, deco.ptr);
if (auto sv = Type.stringtable.lookup(deco))
{
if (sv.value)
{
Type t = cast(Type)sv.value;
assert(t.deco);
return t;
}
}
return null;
}
/***************************************** private ***************************************/
private:
import core.stdc.ctype;
import core.stdc.stdio;
import core.stdc.string;
import dmd.aggregate;
import dmd.arraytypes;
import dmd.astenums;
import dmd.dclass;
import dmd.declaration;
import dmd.dmodule;
import dmd.dsymbol;
import dmd.dtemplate;
import dmd.expression;
import dmd.func;
import dmd.globals;
import dmd.id;
import dmd.identifier;
import dmd.mtype;
import dmd.root.ctfloat;
import dmd.common.outbuffer;
import dmd.root.aav;
import dmd.root.string;
import dmd.root.stringtable;
import dmd.root.utf;
import dmd.target;
import dmd.tokens;
import dmd.visitor;
private immutable char[TMAX] mangleChar =
[
Tchar : 'a',
Tbool : 'b',
Tcomplex80 : 'c',
Tfloat64 : 'd',
Tfloat80 : 'e',
Tfloat32 : 'f',
Tint8 : 'g',
Tuns8 : 'h',
Tint32 : 'i',
Timaginary80 : 'j',
Tuns32 : 'k',
Tint64 : 'l',
Tuns64 : 'm',
Tnull : 'n',
Timaginary32 : 'o',
Timaginary64 : 'p',
Tcomplex32 : 'q',
Tcomplex64 : 'r',
Tint16 : 's',
Tuns16 : 't',
Twchar : 'u',
Tvoid : 'v',
Tdchar : 'w',
// x // const
// y // immutable
Tint128 : 'z', // zi
Tuns128 : 'z', // zk
Tarray : 'A',
Ttuple : 'B',
Tclass : 'C',
Tdelegate : 'D',
Tenum : 'E',
Tfunction : 'F', // D function
Tsarray : 'G',
Taarray : 'H',
// I // in
// J // out
// K // ref
// L // lazy
// M // has this, or scope
// N // Nh:vector Ng:wild Nn:noreturn
// O // shared
Tpointer : 'P',
// Q // Type/symbol/identifier backward reference
Treference : 'R',
Tstruct : 'S',
// T // Ttypedef
// U // C function
// W // Windows function
// X // variadic T t...)
// Y // variadic T t,...)
// Z // not variadic, end of parameters
// '@' shouldn't appear anywhere in the deco'd names
Tnone : '@',
Tident : '@',
Tinstance : '@',
Terror : '@',
Ttypeof : '@',
Tslice : '@',
Treturn : '@',
Tvector : '@',
Ttraits : '@',
Tmixin : '@',
Ttag : '@',
Tnoreturn : '@', // becomes 'Nn'
];
unittest
{
foreach (i, mangle; mangleChar)
{
if (mangle == char.init)
{
fprintf(stderr, "ty = %u\n", cast(uint)i);
assert(0);
}
}
}
/************************************************
* Append the mangling of type `t` to `buf`.
* Params:
* t = type to mangle
* modMask = mod bits currently applying to t
* buf = buffer to append mangling to
* backref = state of back references (updated)
*/
void mangleType(Type t, ubyte modMask, OutBuffer* buf, ref Backref backref)
{
void visitWithMask(Type t, ubyte modMask)
{
void mangleSymbol(Dsymbol s)
{
scope Mangler v = new Mangler(buf, &backref);
v.mangleSymbol(s);
}
void visitType(Type t)
{
tyToDecoBuffer(buf, t.ty);
}
void visitTypeNext(TypeNext t)
{
visitType(t);
visitWithMask(t.next, t.mod);
}
void visitTypeVector(TypeVector t)
{
buf.writestring("Nh");
visitWithMask(t.basetype, t.mod);
}
void visitTypeSArray(TypeSArray t)
{
visitType(t);
if (t.dim)
buf.print(t.dim.toInteger());
if (t.next)
visitWithMask(t.next, t.mod);
}
void visitTypeDArray(TypeDArray t)
{
visitType(t);
if (t.next)
visitWithMask(t.next, t.mod);
}
void visitTypeAArray(TypeAArray t)
{
visitType(t);
visitWithMask(t.index, 0);
visitWithMask(t.next, t.mod);
}
void visitTypeFunction(TypeFunction t)
{
//printf("TypeFunction.toDecoBuffer() t = %p %s\n", t, t.toChars());
//static int nest; if (++nest == 50) *(char*)0=0;
mangleFuncType(t, t, t.mod, t.next, buf, backref);
}
void visitTypeIdentifier(TypeIdentifier t)
{
visitType(t);
auto name = t.ident.toString();
buf.print(cast(int)name.length);
buf.writestring(name);
}
void visitTypeEnum(TypeEnum t)
{
visitType(t);
mangleSymbol(t.sym);
}
void visitTypeStruct(TypeStruct t)
{
//printf("TypeStruct.toDecoBuffer('%s') = '%s'\n", t.toChars(), name);
visitType(t);
mangleSymbol(t.sym);
}
void visitTypeClass(TypeClass t)
{
//printf("TypeClass.toDecoBuffer('%s' mod=%x) = '%s'\n", t.toChars(), mod, name);
visitType(t);
mangleSymbol(t.sym);
}
void visitTypeTuple(TypeTuple t)
{
//printf("TypeTuple.toDecoBuffer() t = %p, %s\n", t, t.toChars());
visitType(t);
Parameter._foreach(t.arguments, (idx, param) {
mangleParameter(param, buf, backref);
return 0;
});
buf.writeByte('Z');
}
void visitTypeNull(TypeNull t)
{
visitType(t);
}
void visitTypeNoreturn(TypeNoreturn t)
{
buf.writestring("Nn");
}
if (modMask != t.mod)
{
MODtoDecoBuffer(buf, t.mod);
}
if (backref.addRefToType(buf, t))
return;
switch (t.ty)
{
case Tpointer:
case Treference:
case Tdelegate:
case Tslice: visitTypeNext (cast(TypeNext)t); break;
case Tarray: visitTypeDArray (t.isTypeDArray()); break;
case Tsarray: visitTypeSArray (t.isTypeSArray()); break;
case Taarray: visitTypeAArray (t.isTypeAArray()); break;
case Tfunction: visitTypeFunction (t.isTypeFunction()); break;
case Tident: visitTypeIdentifier(t.isTypeIdentifier()); break;
case Tclass: visitTypeClass (t.isTypeClass()); break;
case Tstruct: visitTypeStruct (t.isTypeStruct()); break;
case Tenum: visitTypeEnum (t.isTypeEnum()); break;
case Ttuple: visitTypeTuple (t.isTypeTuple()); break;
case Tnull: visitTypeNull (t.isTypeNull()); break;
case Tvector: visitTypeVector (t.isTypeVector()); break;
case Tnoreturn: visitTypeNoreturn (t.isTypeNoreturn); break;
case Terror:
break; // ignore errors
default: visitType(t); break;
}
}
visitWithMask(t, modMask);
}
/*************************************************************
*/
void mangleFuncType(TypeFunction t, TypeFunction ta, ubyte modMask, Type tret, OutBuffer* buf, ref Backref backref)
{
//printf("mangleFuncType() %s\n", t.toChars());
if (t.inuse && tret)
{
// printf("TypeFunction.mangleFuncType() t = %s inuse\n", t.toChars());
t.inuse = 2; // flag error to caller
return;
}
t.inuse++;
if (modMask != t.mod)
MODtoDecoBuffer(buf, t.mod);
char mc;
final switch (t.linkage)
{
case LINK.default_:
case LINK.d:
mc = 'F';
break;
case LINK.c:
mc = 'U';
break;
case LINK.windows:
mc = 'W';
break;
case LINK.cpp:
mc = 'R';
break;
case LINK.objc:
mc = 'Y';
break;
case LINK.system:
assert(0);
}
buf.writeByte(mc);
if (ta.purity)
buf.writestring("Na");
if (ta.isnothrow)
buf.writestring("Nb");
if (ta.isref)
buf.writestring("Nc");
if (ta.isproperty)
buf.writestring("Nd");
if (ta.isnogc)
buf.writestring("Ni");
// `return scope` must be in that order
if (ta.isreturnscope && !ta.isreturninferred)
{
buf.writestring("NjNl");
}
else
{
// when return ref, the order is `scope return`
if (ta.isScopeQual && !ta.isscopeinferred)
buf.writestring("Nl");
if (ta.isreturn && !ta.isreturninferred)
buf.writestring("Nj");
}
if (ta.islive)
buf.writestring("Nm");
switch (ta.trust)
{
case TRUST.trusted:
buf.writestring("Ne");
break;
case TRUST.safe:
buf.writestring("Nf");
break;
default:
break;
}
// Write argument types
foreach (idx, param; t.parameterList)
mangleParameter(param, buf, backref);
//if (buf.data[buf.length - 1] == '@') assert(0);
buf.writeByte('Z' - t.parameterList.varargs); // mark end of arg list
if (tret !is null)
mangleType(tret, 0, buf, backref);
t.inuse--;
}
/*************************************************************
*/
void mangleParameter(Parameter p, OutBuffer* buf, ref Backref backref)
{
// https://dlang.org/spec/abi.html#Parameter
auto stc = p.storageClass;
// Inferred storage classes don't get mangled in
if (stc & STC.scopeinferred)
stc &= ~(STC.scope_ | STC.scopeinferred);
if (stc & STC.returninferred)
stc &= ~(STC.return_ | STC.returninferred);
// much like hdrgen.stcToBuffer()
string rrs;
const isout = (stc & STC.out_) != 0;
final switch (buildScopeRef(stc))
{
case ScopeRef.None:
case ScopeRef.Scope:
case ScopeRef.Ref:
case ScopeRef.Return:
case ScopeRef.RefScope:
break;
case ScopeRef.ReturnScope: rrs = "NkM"; goto L1; // return scope
case ScopeRef.ReturnRef: rrs = isout ? "NkJ" : "NkK"; goto L1; // return ref
case ScopeRef.ReturnRef_Scope: rrs = isout ? "MNkJ" : "MNkK"; goto L1; // scope return ref
case ScopeRef.Ref_ReturnScope: rrs = isout ? "NkMJ" : "NkMK"; goto L1; // return scope ref
L1:
buf.writestring(rrs);
stc &= ~(STC.out_ | STC.scope_ | STC.ref_ | STC.return_);
break;
}
if (stc & STC.scope_)
buf.writeByte('M'); // scope
if (stc & STC.return_)
buf.writestring("Nk"); // return
switch (stc & (STC.IOR | STC.lazy_))
{
case 0:
break;
case STC.in_:
buf.writeByte('I');
break;
case STC.in_ | STC.ref_:
buf.writestring("IK");
break;
case STC.out_:
buf.writeByte('J');
break;
case STC.ref_:
buf.writeByte('K');
break;
case STC.lazy_:
buf.writeByte('L');
break;
default:
debug
{
printf("storageClass = x%llx\n", stc & (STC.IOR | STC.lazy_));
}
assert(0);
}
mangleType(p.type, (stc & STC.in_) ? MODFlags.const_ : 0, buf, backref);
}
private extern (C++) final class Mangler : Visitor
{
alias visit = Visitor.visit;
public:
static assert(Key.sizeof == size_t.sizeof);
OutBuffer* buf;
Backref* backref;
extern (D) this(OutBuffer* buf, Backref* backref)
{
this.buf = buf;
this.backref = backref;
}
void mangleSymbol(Dsymbol s)
{
s.accept(this);
}
void mangleIdentifier(Identifier id, Dsymbol s)
{
if (!backref.addRefToIdentifier(buf, id))
toBuffer(buf, id.toString(), s);
}
////////////////////////////////////////////////////////////////////////////
void mangleDecl(Declaration sthis)
{
mangleParent(sthis);
assert(sthis.ident);
mangleIdentifier(sthis.ident, sthis);
if (FuncDeclaration fd = sthis.isFuncDeclaration())
{
mangleFunc(fd, false);
}
else if (sthis.type)
{
mangleType(sthis.type, 0, buf, *backref);
}
else
assert(0);
}
void mangleParent(Dsymbol s)
{
//printf("mangleParent() %s %s\n", s.kind(), s.toChars());
Dsymbol p;
if (TemplateInstance ti = s.isTemplateInstance())
p = ti.isTemplateMixin() ? ti.parent : ti.tempdecl.parent;
else
p = s.parent;
if (p)
{
uint localNum = s.localNum;
mangleParent(p);
auto ti = p.isTemplateInstance();
if (ti && !ti.isTemplateMixin())
{
localNum = ti.tempdecl.localNum;
mangleTemplateInstance(ti);
}
else if (p.getIdent())
{
mangleIdentifier(p.ident, s);
if (FuncDeclaration f = p.isFuncDeclaration())
mangleFunc(f, true);
}
else
buf.writeByte('0');
if (localNum)
writeLocalParent(buf, localNum);
}
}
void mangleFunc(FuncDeclaration fd, bool inParent)
{
//printf("deco = '%s'\n", fd.type.deco ? fd.type.deco : "null");
//printf("fd.type = %s\n", fd.type.toChars());
if (fd.needThis() || fd.isNested())
buf.writeByte('M');
if (!fd.type || fd.type.ty == Terror)
{
// never should have gotten here, but could be the result of
// failed speculative compilation
buf.writestring("9__error__FZ");
//printf("[%s] %s no type\n", fd.loc.toChars(), fd.toChars());
//assert(0); // don't mangle function until semantic3 done.
}
else if (inParent)
{
TypeFunction tf = fd.type.isTypeFunction();
TypeFunction tfo = fd.originalType.isTypeFunction();
mangleFuncType(tf, tfo, 0, null, buf, *backref);
}
else
{
mangleType(fd.type, 0, buf, *backref);
}
}
override void visit(Declaration d)
{
//printf("Declaration.mangle(this = %p, '%s', parent = '%s', linkage = %d)\n",
// d, d.toChars(), d.parent ? d.parent.toChars() : "null", d.linkage);
if (const id = externallyMangledIdentifier(d))
{
buf.writestring(id);
return;
}
buf.writestring("_D");
mangleDecl(d);
debug
{
const slice = (*buf)[];
assert(slice.length);
for (size_t pos; pos < slice.length; )
{
dchar c;
auto ppos = pos;
const s = utf_decodeChar(slice, pos, c);
assert(s is null, s);
assert(c.isValidMangling, "The mangled name '" ~ slice ~ "' " ~
"contains an invalid character: " ~ slice[ppos..pos]);
}
}
}
/******************************************************************************
* Normally FuncDeclaration and FuncAliasDeclaration have overloads.
* If and only if there is no overloads, mangle() could return
* exact mangled name.
*
* module test;
* void foo(long) {} // _D4test3fooFlZv
* void foo(string) {} // _D4test3fooFAyaZv
*
* // from FuncDeclaration.mangle().
* pragma(msg, foo.mangleof); // prints unexact mangled name "4test3foo"
* // by calling Dsymbol.mangle()
*
* // from FuncAliasDeclaration.mangle()
* pragma(msg, __traits(getOverloads, test, "foo")[0].mangleof); // "_D4test3fooFlZv"
* pragma(msg, __traits(getOverloads, test, "foo")[1].mangleof); // "_D4test3fooFAyaZv"
*
* If a function has no overloads, .mangleof property still returns exact mangled name.
*
* void bar() {}
* pragma(msg, bar.mangleof); // still prints "_D4test3barFZv"
* // by calling FuncDeclaration.mangleExact().
*/
override void visit(FuncDeclaration fd)
{
if (fd.isUnique())
mangleExact(fd);
else
visit(cast(Dsymbol)fd);
}
// ditto
override void visit(FuncAliasDeclaration fd)
{
FuncDeclaration f = fd.toAliasFunc();
FuncAliasDeclaration fa = f.isFuncAliasDeclaration();
if (!fd.hasOverloads && !fa)
{
mangleExact(f);
return;
}
if (fa)
{
mangleSymbol(fa);
return;
}
visit(cast(Dsymbol)fd);
}
override void visit(OverDeclaration od)
{
if (od.overnext)
{
visit(cast(Dsymbol)od);
return;
}
if (FuncDeclaration fd = od.aliassym.isFuncDeclaration())
{
if (fd.isUnique())
{
mangleExact(fd);
return;
}
}
if (TemplateDeclaration td = od.aliassym.isTemplateDeclaration())
{
if (td.overnext is null)
{
mangleSymbol(td);
return;
}
}
visit(cast(Dsymbol)od);
}
void mangleExact(FuncDeclaration fd)
{
assert(!fd.isFuncAliasDeclaration());
if (fd.mangleOverride)
{
buf.writestring(fd.mangleOverride);
return;
}
if (fd.isMain())
{
buf.writestring("_Dmain");
return;
}
if (fd.isWinMain() || fd.isDllMain())
{
buf.writestring(fd.ident.toString());
return;
}
visit(cast(Declaration)fd);
}
override void visit(VarDeclaration vd)
{
if (vd.mangleOverride)
{
buf.writestring(vd.mangleOverride);
return;
}
visit(cast(Declaration)vd);
}
override void visit(AggregateDeclaration ad)
{
ClassDeclaration cd = ad.isClassDeclaration();
Dsymbol parentsave = ad.parent;
if (cd)
{
/* These are reserved to the compiler, so keep simple
* names for them.
*/
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)
{
// Don't mangle parent
ad.parent = null;
}
}
visit(cast(Dsymbol)ad);
ad.parent = parentsave;
}
override void visit(TemplateInstance ti)
{
version (none)
{
printf("TemplateInstance.mangle() %p %s", ti, ti.toChars());
if (ti.parent)
printf(" parent = %s %s", ti.parent.kind(), ti.parent.toChars());
printf("\n");
}
if (!ti.tempdecl)
ti.error("is not defined");
else
mangleParent(ti);
if (ti.isTemplateMixin() && ti.ident)
mangleIdentifier(ti.ident, ti);
else
mangleTemplateInstance(ti);
}
void mangleTemplateInstance(TemplateInstance ti)
{
TemplateDeclaration tempdecl = ti.tempdecl.isTemplateDeclaration();
assert(tempdecl);
// Use "__U" for the symbols declared inside template constraint.
const char T = ti.members ? 'T' : 'U';
buf.printf("__%c", T);
mangleIdentifier(tempdecl.ident, tempdecl);
auto args = ti.tiargs;
size_t nparams = tempdecl.parameters.length - (tempdecl.isVariadic() ? 1 : 0);
for (size_t i = 0; i < args.length; i++)
{
auto o = (*args)[i];
Type ta = isType(o);
Expression ea = isExpression(o);
Dsymbol sa = isDsymbol(o);
Tuple va = isTuple(o);
//printf("\to [%d] %p ta %p ea %p sa %p va %p\n", i, o, ta, ea, sa, va);
if (i < nparams && (*tempdecl.parameters)[i].specialization())
buf.writeByte('H'); // https://issues.dlang.org/show_bug.cgi?id=6574
if (ta)
{
buf.writeByte('T');
mangleType(ta, 0, buf, *backref);
}
else if (ea)
{
// Don't interpret it yet, it might actually be an alias template parameter.
// Only constfold manifest constants, not const/immutable lvalues, see https://issues.dlang.org/show_bug.cgi?id=17339.
enum keepLvalue = true;
ea = ea.optimize(WANTvalue, keepLvalue);
if (auto ev = ea.isVarExp())
{
sa = ev.var;
ea = null;
goto Lsa;
}
if (auto et = ea.isThisExp())
{
sa = et.var;
ea = null;
goto Lsa;
}
if (auto ef = ea.isFuncExp())
{
if (ef.td)
sa = ef.td;
else
sa = ef.fd;
ea = null;
goto Lsa;
}
buf.writeByte('V');
if (ea.op == EXP.tuple)
{
ea.error("tuple is not a valid template value argument");
continue;
}
// Now that we know it is not an alias, we MUST obtain a value
uint olderr = global.errors;
ea = ea.ctfeInterpret();
if (ea.op == EXP.error || olderr != global.errors)
continue;
/* Use type mangling that matches what it would be for a function parameter
*/
mangleType(ea.type, 0, buf, *backref);
ea.accept(this);
}
else if (sa)
{
Lsa:
sa = sa.toAlias();
if (sa.isDeclaration() && !sa.isOverDeclaration())
{
Declaration d = sa.isDeclaration();
if (auto fad = d.isFuncAliasDeclaration())
d = fad.toAliasFunc();
if (d.mangleOverride)
{
buf.writeByte('X');
toBuffer(buf, d.mangleOverride, d);
continue;
}
if (const id = externallyMangledIdentifier(d))
{
buf.writeByte('X');
toBuffer(buf, id, d);
continue;
}
if (!d.type || !d.type.deco)
{
ti.error("forward reference of %s `%s`", d.kind(), d.toChars());
continue;
}
}
buf.writeByte('S');
mangleSymbol(sa);
}
else if (va)
{
assert(i + 1 == args.length); // must be last one
args = &va.objects;
i = -cast(size_t)1;
}
else
assert(0);
}
buf.writeByte('Z');
}
override void visit(Dsymbol s)
{
version (none)
{
printf("Dsymbol.mangle() '%s'", s.toChars());
if (s.parent)
printf(" parent = %s %s", s.parent.kind(), s.parent.toChars());
printf("\n");
}
if (s.parent && s.ident)
{
if (auto m = s.parent.isModule())
{
if (m.filetype == FileType.c)
{
/* C types at global level get mangled into the __C global namespace
* to get the same mangling regardless of which module it
* is declared in. This works because types are the same if the mangling
* is the same.
*/
mangleIdentifier(Id.ImportC, s); // parent
mangleIdentifier(s.ident, s);
return;
}
}
}
mangleParent(s);
if (s.ident)
mangleIdentifier(s.ident, s);
else
toBuffer(buf, s.toString(), s);
//printf("Dsymbol.mangle() %s = %s\n", s.toChars(), id);
}
////////////////////////////////////////////////////////////////////////////
override void visit(Expression e)
{
e.error("expression `%s` is not a valid template value argument", e.toChars());
}
override void visit(IntegerExp e)
{
const v = e.toInteger();
if (cast(sinteger_t)v < 0)
{
buf.writeByte('N');
buf.print(-v);
}
else
{
buf.writeByte('i');
buf.print(v);
}
}
override void visit(RealExp e)
{
buf.writeByte('e');
realToMangleBuffer(buf, e.value);
}
override void visit(ComplexExp e)
{
buf.writeByte('c');
realToMangleBuffer(buf, e.toReal());
buf.writeByte('c'); // separate the two
realToMangleBuffer(buf, e.toImaginary());
}
override void visit(NullExp e)
{
buf.writeByte('n');
}
override void visit(StringExp e)
{
char m;
OutBuffer tmp;
const(char)[] q;
/* Write string in UTF-8 format
*/
switch (e.sz)
{
case 1:
m = 'a';
q = e.peekString();
break;
case 2:
{
m = 'w';
const slice = e.peekWstring();
for (size_t u = 0; u < e.len;)
{
dchar c;
if (const s = utf_decodeWchar(slice, u, c))
e.error("%.*s", cast(int)s.length, s.ptr);
else
tmp.writeUTF8(c);
}
q = tmp[];
break;
}
case 4:
{
m = 'd';
const slice = e.peekDstring();
foreach (c; slice)
{
if (!utf_isValidDchar(c))
e.error("invalid UCS-32 char \\U%08x", c);
else
tmp.writeUTF8(c);
}
q = tmp[];
break;
}
default:
assert(0);
}
buf.reserve(1 + 11 + 2 * q.length);
buf.writeByte(m);
buf.print(q.length);
buf.writeByte('_'); // nbytes <= 11
auto slice = buf.allocate(2 * q.length);
foreach (i, c; q)
{
char hi = (c >> 4) & 0xF;
slice[i * 2] = cast(char)(hi < 10 ? hi + '0' : hi - 10 + 'a');
char lo = c & 0xF;
slice[i * 2 + 1] = cast(char)(lo < 10 ? lo + '0' : lo - 10 + 'a');
}
}
override void visit(ArrayLiteralExp e)
{
const dim = e.elements ? e.elements.length : 0;
buf.writeByte('A');
buf.print(dim);
foreach (i; 0 .. dim)
{
e[i].accept(this);
}
}
override void visit(AssocArrayLiteralExp e)
{
const dim = e.keys.length;
buf.writeByte('A');
buf.print(dim);
foreach (i; 0 .. dim)
{
(*e.keys)[i].accept(this);
(*e.values)[i].accept(this);
}
}
override void visit(StructLiteralExp e)
{
const dim = e.elements ? e.elements.length : 0;
buf.writeByte('S');
buf.print(dim);
foreach (i; 0 .. dim)
{
Expression ex = (*e.elements)[i];
if (ex)
ex.accept(this);
else
buf.writeByte('v'); // 'v' for void
}
}
override void visit(FuncExp e)
{
buf.writeByte('f');
if (e.td)
mangleSymbol(e.td);
else
mangleSymbol(e.fd);
}
}
/***************************************
* Manage back reference mangling
*/
private struct Backref
{
/**
* Back references a non-basic type
*
* The encoded mangling is
* 'Q' <relative position of first occurrence of type>
*
* Params:
* t = the type to encode via back referencing
*
* Returns:
* true if the type was found. A back reference has been encoded.
* false if the type was not found. The current position is saved for later back references.
*/
bool addRefToType(OutBuffer* buf, Type t)
{
if (t.isTypeBasic())
return false;
/**
* https://issues.dlang.org/show_bug.cgi?id=21591
*
* Special case for unmerged TypeFunctions: use the generic merged
* function type as backref cache key to avoid missed backrefs.
*
* Merging is based on mangling, so we need to avoid an infinite
* recursion by excluding the case where `t` is the root type passed to
* `mangleToBuffer()`.
*/
if (t != rootType)
{
if (t.isFunction_Delegate_PtrToFunction())
{
t = t.merge2();
}
}
return backrefImpl(buf, types, t);
}
/**
* Back references a single identifier
*
* The encoded mangling is
* 'Q' <relative position of first occurrence of type>
*
* Params:
* id = the identifier to encode via back referencing
*
* Returns:
* true if the identifier was found. A back reference has been encoded.
* false if the identifier was not found. The current position is saved for later back references.
*/
bool addRefToIdentifier(OutBuffer* buf, Identifier id)
{
return backrefImpl(buf, idents, id);
}
private:
extern(D) bool backrefImpl(T)(OutBuffer* buf, ref AssocArray!(T, size_t) aa, T key)
{
auto p = aa.getLvalue(key);
if (*p)
{
const offset = *p - 1;
writeBackRef(buf, buf.length - offset);
return true;
}
*p = buf.length + 1;
return false;
}
Type rootType; /// avoid infinite recursion
AssocArray!(Type, size_t) types; /// Type => (offset+1) in buf
AssocArray!(Identifier, size_t) idents; /// Identifier => (offset+1) in buf
}
/***********************
* Mangle basic type ty to buf.
*/
private void tyToDecoBuffer(OutBuffer* buf, int ty)
{
const c = mangleChar[ty];
buf.writeByte(c);
if (c == 'z')
buf.writeByte(ty == Tint128 ? 'i' : 'k');
}
/*********************************
* Mangling for mod.
*/
private void MODtoDecoBuffer(OutBuffer* buf, MOD mod)
{
switch (mod)
{
case 0:
break;
case MODFlags.const_:
buf.writeByte('x');
break;
case MODFlags.immutable_:
buf.writeByte('y');
break;
case MODFlags.shared_:
buf.writeByte('O');
break;
case MODFlags.shared_ | MODFlags.const_:
buf.writestring("Ox");
break;
case MODFlags.wild:
buf.writestring("Ng");
break;
case MODFlags.wildconst:
buf.writestring("Ngx");
break;
case MODFlags.shared_ | MODFlags.wild:
buf.writestring("ONg");
break;
case MODFlags.shared_ | MODFlags.wildconst:
buf.writestring("ONgx");
break;
default:
assert(0);
}
}
/**
* writes a back reference with the relative position encoded with base 26
* using upper case letters for all digits but the last digit which uses
* a lower case letter.
* The decoder has to look up the referenced position to determine
* whether the back reference is an identifier (starts with a digit)
* or a type (starts with a letter).
*
* Params:
* buf = buffer to write to
* pos = relative position to encode
*/
private
void writeBackRef(OutBuffer* buf, size_t pos)
{
buf.writeByte('Q');
enum base = 26;
size_t mul = 1;
while (pos >= mul * base)
mul *= base;
while (mul >= base)
{
auto dig = cast(ubyte)(pos / mul);
buf.writeByte('A' + dig);
pos -= dig * mul;
mul /= base;
}
buf.writeByte('a' + cast(ubyte)pos);
}
/************************************************************
* Write length prefixed string to buf.
*/
private
extern (D) void toBuffer(OutBuffer* buf, const(char)[] id, Dsymbol s)
{
const len = id.length;
if (buf.length + len >= 8 * 1024 * 1024) // 8 megs ought be enough for anyone
s.error("excessive length %llu for symbol, possible recursive expansion?", cast(ulong)(buf.length + len));
else
{
buf.print(len);
buf.writestring(id);
}
}
/*****
* There can be multiple different declarations in the same
* function that have the same mangled name.
* This results in localNum having a non-zero number, which
* is used to add a fake parent of the form `__Sddd` to make
* the mangled names unique.
* https://issues.dlang.org/show_bug.cgi?id=20565
* Params:
* buf = buffer to write to
* localNum = local symbol number
*/
private
void writeLocalParent(OutBuffer* buf, uint localNum)
{
uint ndigits = 1;
auto n = localNum;
while (n >= 10)
{
n /= 10;
++ndigits;
}
buf.printf("%u__S%u", ndigits + 3, localNum);
}
/*************************
* Write real to buffer.
* Params:
* buf = buffer to write to
* value = real to write
*/
private
void realToMangleBuffer(OutBuffer* buf, real_t value)
{
/* Rely on %A to get portable mangling.
* Must munge result to get only identifier characters.
*
* Possible values from %A => mangled result
* NAN => NAN
* -INF => NINF
* INF => INF
* -0X1.1BC18BA997B95P+79 => N11BC18BA997B95P79
* 0X1.9P+2 => 19P2
*/
if (CTFloat.isNaN(value))
{
buf.writestring("NAN"); // no -NAN bugs
return;
}
if (value < CTFloat.zero)
{
buf.writeByte('N');
value = -value;
}
if (CTFloat.isInfinity(value))
{
buf.writestring("INF");
return;
}
char[36] buffer = void;
// 'A' format yields [-]0xh.hhhhp+-d
const n = CTFloat.sprint(buffer.ptr, buffer.length, 'A', value);
assert(n < buffer.length);
foreach (const c; buffer[2 .. n])
{
switch (c)
{
case '-':
buf.writeByte('N');
break;
case '+':
case '.':
break;
default:
buf.writeByte(c);
break;
}
}
}
/************************************************************
* Try to obtain an externally mangled identifier from a declaration.
* If the declaration is at global scope or mixed in at global scope,
* the user might want to call it externally, so an externally mangled
* name is returned. Member functions or nested functions can't be called
* externally in C, so in that case null is returned. C++ does support
* namespaces, so extern(C++) always gives a C++ mangled name.
*
* See also: https://issues.dlang.org/show_bug.cgi?id=20012
*
* Params:
* d = declaration to mangle
*
* Returns:
* an externally mangled name or null if the declaration cannot be called externally
*/
private
extern (D) const(char)[] externallyMangledIdentifier(Declaration d)
{
assert(!d.mangleOverride, "mangle overrides should have been handled earlier");
const linkage = d.resolvedLinkage();
const par = d.toParent(); //toParent() skips over mixin templates
if (!par || par.isModule() || linkage == LINK.cpp ||
(linkage == LINK.c && d.isCsymbol() &&
(d.isFuncDeclaration() ||
(d.isVarDeclaration() && d.isDataseg() && d.storage_class & STC.extern_))))
{
if (linkage != LINK.d && d.localNum)
d.error("the same declaration cannot be in multiple scopes with non-D linkage");
final switch (linkage)
{
case LINK.d:
break;
case LINK.c:
case LINK.windows:
case LINK.objc:
return d.ident.toString();
case LINK.cpp:
{
const p = target.cpp.toMangle(d);
return p.toDString();
}
case LINK.default_:
d.error("forward declaration");
return d.ident.toString();
case LINK.system:
assert(0);
}
}
return null;
}