ItaniumMangle.cpp revision 226633
1291128Sbapt//===--- ItaniumMangle.cpp - Itanium C++ Name Mangling ----------*- C++ -*-===// 295060Sjmallett// 395060Sjmallett// The LLVM Compiler Infrastructure 4331722Seadler// 51590Srgrimes// This file is distributed under the University of Illinois Open Source 61590Srgrimes// License. See LICENSE.TXT for details. 71590Srgrimes// 81590Srgrimes//===----------------------------------------------------------------------===// 91590Srgrimes// 101590Srgrimes// Implements C++ name mangling according to the Itanium C++ ABI, 111590Srgrimes// which is used in GCC 3.2 and newer (and many compilers that are 121590Srgrimes// ABI-compatible with GCC): 131590Srgrimes// 141590Srgrimes// http://www.codesourcery.com/public/cxx-abi/abi.html 151590Srgrimes// 161590Srgrimes//===----------------------------------------------------------------------===// 171590Srgrimes#include "clang/AST/Mangle.h" 181590Srgrimes#include "clang/AST/ASTContext.h" 19228063Sbapt#include "clang/AST/Decl.h" 201590Srgrimes#include "clang/AST/DeclCXX.h" 211590Srgrimes#include "clang/AST/DeclObjC.h" 221590Srgrimes#include "clang/AST/DeclTemplate.h" 231590Srgrimes#include "clang/AST/ExprCXX.h" 241590Srgrimes#include "clang/AST/ExprObjC.h" 251590Srgrimes#include "clang/AST/TypeLoc.h" 261590Srgrimes#include "clang/Basic/ABI.h" 271590Srgrimes#include "clang/Basic/SourceManager.h" 281590Srgrimes#include "clang/Basic/TargetInfo.h" 291590Srgrimes#include "llvm/ADT/StringExtras.h" 301590Srgrimes#include "llvm/Support/raw_ostream.h" 311590Srgrimes#include "llvm/Support/ErrorHandling.h" 321590Srgrimes 331590Srgrimes#define MANGLE_CHECKER 0 341590Srgrimes 351590Srgrimes#if MANGLE_CHECKER 3695060Sjmallett#include <cxxabi.h> 3795060Sjmallett#endif 381590Srgrimes 39228063Sbaptusing namespace clang; 401590Srgrimes 411590Srgrimesnamespace { 421590Srgrimes 431590Srgrimesstatic const CXXRecordDecl *GetLocalClassDecl(const NamedDecl *ND) { 441590Srgrimes const DeclContext *DC = dyn_cast<DeclContext>(ND); 451590Srgrimes if (!DC) 461590Srgrimes DC = ND->getDeclContext(); 47228063Sbapt while (!DC->isNamespace() && !DC->isTranslationUnit()) { 4895060Sjmallett if (isa<FunctionDecl>(DC->getParent())) 49228063Sbapt return dyn_cast<CXXRecordDecl>(DC); 5095060Sjmallett DC = DC->getParent(); 51291128Sbapt } 52228063Sbapt return 0; 531590Srgrimes} 5495060Sjmallett 551590Srgrimesstatic const FunctionDecl *getStructor(const FunctionDecl *fn) { 5695060Sjmallett if (const FunctionTemplateDecl *ftd = fn->getPrimaryTemplate()) 571590Srgrimes return ftd->getTemplatedDecl(); 581590Srgrimes 591590Srgrimes return fn; 601590Srgrimes} 611590Srgrimes 6295060Sjmallettstatic const NamedDecl *getStructor(const NamedDecl *decl) { 6395060Sjmallett const FunctionDecl *fn = dyn_cast_or_null<FunctionDecl>(decl); 6495060Sjmallett return (fn ? getStructor(fn) : decl); 6595060Sjmallett} 6695060Sjmallett 6795060Sjmallettstatic const unsigned UnknownArity = ~0U; 6895060Sjmallett 6995060Sjmallettclass ItaniumMangleContext : public MangleContext { 7095060Sjmallett llvm::DenseMap<const TagDecl *, uint64_t> AnonStructIds; 71228063Sbapt unsigned Discriminator; 7295060Sjmallett llvm::DenseMap<const NamedDecl*, unsigned> Uniquifier; 7395060Sjmallett 7495060Sjmallettpublic: 7595060Sjmallett explicit ItaniumMangleContext(ASTContext &Context, 7695060Sjmallett DiagnosticsEngine &Diags) 7795060Sjmallett : MangleContext(Context, Diags) { } 7895060Sjmallett 79228063Sbapt uint64_t getAnonymousStructId(const TagDecl *TD) { 8095060Sjmallett std::pair<llvm::DenseMap<const TagDecl *, 8195060Sjmallett uint64_t>::iterator, bool> Result = 8295060Sjmallett AnonStructIds.insert(std::make_pair(TD, AnonStructIds.size())); 831590Srgrimes return Result.first->second; 8495060Sjmallett } 851590Srgrimes 861590Srgrimes void startNewFunction() { 871590Srgrimes MangleContext::startNewFunction(); 88228063Sbapt mangleInitDiscriminator(); 891590Srgrimes } 901590Srgrimes 911590Srgrimes /// @name Mangler Entry Points 921590Srgrimes /// @{ 931590Srgrimes 941590Srgrimes bool shouldMangleDeclName(const NamedDecl *D); 9595060Sjmallett void mangleName(const NamedDecl *D, raw_ostream &); 961590Srgrimes void mangleThunk(const CXXMethodDecl *MD, 971590Srgrimes const ThunkInfo &Thunk, 981590Srgrimes raw_ostream &); 9995060Sjmallett void mangleCXXDtorThunk(const CXXDestructorDecl *DD, CXXDtorType Type, 10095060Sjmallett const ThisAdjustment &ThisAdjustment, 1011590Srgrimes raw_ostream &); 1021590Srgrimes void mangleReferenceTemporary(const VarDecl *D, 103228063Sbapt raw_ostream &); 1041590Srgrimes void mangleCXXVTable(const CXXRecordDecl *RD, 105228063Sbapt raw_ostream &); 10695060Sjmallett void mangleCXXVTT(const CXXRecordDecl *RD, 10795060Sjmallett raw_ostream &); 108100014Sjmallett void mangleCXXCtorVTable(const CXXRecordDecl *RD, int64_t Offset, 109228063Sbapt const CXXRecordDecl *Type, 110228063Sbapt raw_ostream &); 11195060Sjmallett void mangleCXXRTTI(QualType T, raw_ostream &); 11295060Sjmallett void mangleCXXRTTIName(QualType T, raw_ostream &); 11395060Sjmallett void mangleCXXCtor(const CXXConstructorDecl *D, CXXCtorType Type, 11495060Sjmallett raw_ostream &); 11595060Sjmallett void mangleCXXDtor(const CXXDestructorDecl *D, CXXDtorType Type, 116228063Sbapt raw_ostream &); 11795060Sjmallett 11895060Sjmallett void mangleItaniumGuardVariable(const VarDecl *D, raw_ostream &); 11995060Sjmallett 12095060Sjmallett void mangleInitDiscriminator() { 12195060Sjmallett Discriminator = 0; 12295060Sjmallett } 12395060Sjmallett 12495887Sjmallett bool getNextDiscriminator(const NamedDecl *ND, unsigned &disc) { 12595060Sjmallett unsigned &discriminator = Uniquifier[ND]; 12695060Sjmallett if (!discriminator) 12795060Sjmallett discriminator = ++Discriminator; 1281590Srgrimes if (discriminator == 1) 1291590Srgrimes return false; 1301590Srgrimes disc = discriminator-2; 1311590Srgrimes return true; 1321590Srgrimes } 1331590Srgrimes /// @} 13495060Sjmallett}; 1351590Srgrimes 13695060Sjmallett/// CXXNameMangler - Manage the mangling of a single name. 1371590Srgrimesclass CXXNameMangler { 1381590Srgrimes ItaniumMangleContext &Context; 1391590Srgrimes raw_ostream &Out; 1401590Srgrimes 1411590Srgrimes /// The "structor" is the top-level declaration being mangled, if 142228063Sbapt /// that's not a template specialization; otherwise it's the pattern 143228063Sbapt /// for that specialization. 144228063Sbapt const NamedDecl *Structor; 145228063Sbapt unsigned StructorType; 14695060Sjmallett 147228063Sbapt /// SeqID - The next subsitution sequence number. 1481590Srgrimes unsigned SeqID; 1491590Srgrimes 15095060Sjmallett class FunctionTypeDepthState { 1511590Srgrimes unsigned Bits; 1521590Srgrimes 1531590Srgrimes enum { InResultTypeMask = 1 }; 1541590Srgrimes 1551590Srgrimes public: 1561590Srgrimes FunctionTypeDepthState() : Bits(0) {} 1571590Srgrimes 1581590Srgrimes /// The number of function types we're inside. 1591590Srgrimes unsigned getDepth() const { 1601590Srgrimes return Bits >> 1; 1611590Srgrimes } 1621590Srgrimes 1631590Srgrimes /// True if we're in the return type of the innermost function type. 1641590Srgrimes bool isInResultType() const { 1651590Srgrimes return Bits & InResultTypeMask; 16695060Sjmallett } 16795060Sjmallett 16895060Sjmallett FunctionTypeDepthState push() { 16995060Sjmallett FunctionTypeDepthState tmp = *this; 17095060Sjmallett Bits = (Bits & ~InResultTypeMask) + 2; 17195060Sjmallett return tmp; 17295060Sjmallett } 17395060Sjmallett 1741590Srgrimes void enterResultType() { 1751590Srgrimes Bits |= InResultTypeMask; 1761590Srgrimes } 1771590Srgrimes 1781590Srgrimes void leaveResultType() { 179228063Sbapt Bits &= ~InResultTypeMask; 180228063Sbapt } 181228063Sbapt 182228063Sbapt void pop(FunctionTypeDepthState saved) { 183228063Sbapt assert(getDepth() == saved.getDepth() + 1); 184228063Sbapt Bits = saved.Bits; 185228063Sbapt } 186228063Sbapt 187228063Sbapt } FunctionTypeDepth; 188228063Sbapt 189228063Sbapt llvm::DenseMap<uintptr_t, unsigned> Substitutions; 190228063Sbapt 191228063Sbapt ASTContext &getASTContext() const { return Context.getASTContext(); } 192228063Sbapt 193228063Sbaptpublic: 194228063Sbapt CXXNameMangler(ItaniumMangleContext &C, raw_ostream &Out_, 195228063Sbapt const NamedDecl *D = 0) 1961590Srgrimes : Context(C), Out(Out_), Structor(getStructor(D)), StructorType(0), 197228063Sbapt SeqID(0) { 1981590Srgrimes // These can't be mangled without a ctor type or dtor type. 199228063Sbapt assert(!D || (!isa<CXXDestructorDecl>(D) && 2001590Srgrimes !isa<CXXConstructorDecl>(D))); 2011590Srgrimes } 2021590Srgrimes CXXNameMangler(ItaniumMangleContext &C, raw_ostream &Out_, 2031590Srgrimes const CXXConstructorDecl *D, CXXCtorType Type) 2041590Srgrimes : Context(C), Out(Out_), Structor(getStructor(D)), StructorType(Type), 2051590Srgrimes SeqID(0) { } 2061590Srgrimes CXXNameMangler(ItaniumMangleContext &C, raw_ostream &Out_, 2071590Srgrimes const CXXDestructorDecl *D, CXXDtorType Type) 2081590Srgrimes : Context(C), Out(Out_), Structor(getStructor(D)), StructorType(Type), 2091590Srgrimes SeqID(0) { } 2101590Srgrimes 2111590Srgrimes#if MANGLE_CHECKER 2121590Srgrimes ~CXXNameMangler() { 213228063Sbapt if (Out.str()[0] == '\01') 2141590Srgrimes return; 2151590Srgrimes 2161590Srgrimes int status = 0; 2171590Srgrimes char *result = abi::__cxa_demangle(Out.str().str().c_str(), 0, 0, &status); 2181590Srgrimes assert(status == 0 && "Could not demangle mangled name!"); 2191590Srgrimes free(result); 2201590Srgrimes } 2211590Srgrimes#endif 2221590Srgrimes raw_ostream &getStream() { return Out; } 2231590Srgrimes 2241590Srgrimes void mangle(const NamedDecl *D, StringRef Prefix = "_Z"); 22577378Sgshapiro void mangleCallOffset(int64_t NonVirtual, int64_t Virtual); 2261590Srgrimes void mangleNumber(const llvm::APSInt &I); 2271590Srgrimes void mangleNumber(int64_t Number); 2281590Srgrimes void mangleFloat(const llvm::APFloat &F); 2291590Srgrimes void mangleFunctionEncoding(const FunctionDecl *FD); 2301590Srgrimes void mangleName(const NamedDecl *ND); 2311590Srgrimes void mangleType(QualType T); 2321590Srgrimes void mangleNameOrStandardSubstitution(const NamedDecl *ND); 2331590Srgrimes 2341590Srgrimesprivate: 2351590Srgrimes bool mangleSubstitution(const NamedDecl *ND); 2361590Srgrimes bool mangleSubstitution(QualType T); 2371590Srgrimes bool mangleSubstitution(TemplateName Template); 2381590Srgrimes bool mangleSubstitution(uintptr_t Ptr); 2391590Srgrimes 2401590Srgrimes void mangleExistingSubstitution(QualType type); 2411590Srgrimes void mangleExistingSubstitution(TemplateName name); 2421590Srgrimes 2431590Srgrimes bool mangleStandardSubstitution(const NamedDecl *ND); 2441590Srgrimes 2451590Srgrimes void addSubstitution(const NamedDecl *ND) { 2461590Srgrimes ND = cast<NamedDecl>(ND->getCanonicalDecl()); 2471590Srgrimes 2481590Srgrimes addSubstitution(reinterpret_cast<uintptr_t>(ND)); 2498874Srgrimes } 250114368Stjr void addSubstitution(QualType T); 251228063Sbapt void addSubstitution(TemplateName Template); 2521590Srgrimes void addSubstitution(uintptr_t Ptr); 253114368Stjr 2541590Srgrimes void mangleUnresolvedPrefix(NestedNameSpecifier *qualifier, 2551590Srgrimes NamedDecl *firstQualifierLookup, 2561590Srgrimes bool recursive = false); 2571590Srgrimes void mangleUnresolvedName(NestedNameSpecifier *qualifier, 2581590Srgrimes NamedDecl *firstQualifierLookup, 2591590Srgrimes DeclarationName name, 260100014Sjmallett unsigned KnownArity = UnknownArity); 2611590Srgrimes 2621590Srgrimes void mangleName(const TemplateDecl *TD, 2631590Srgrimes const TemplateArgument *TemplateArgs, 2641590Srgrimes unsigned NumTemplateArgs); 26595060Sjmallett void mangleUnqualifiedName(const NamedDecl *ND) { 26695060Sjmallett mangleUnqualifiedName(ND, ND->getDeclName(), UnknownArity); 26795060Sjmallett } 268228063Sbapt void mangleUnqualifiedName(const NamedDecl *ND, DeclarationName Name, 2691590Srgrimes unsigned KnownArity); 270269162Sbapt void mangleUnscopedName(const NamedDecl *ND); 271228701Sbz void mangleUnscopedTemplateName(const TemplateDecl *ND); 272234310Sbapt void mangleUnscopedTemplateName(TemplateName); 273228697Sbapt void mangleSourceName(const IdentifierInfo *II); 274228697Sbapt void mangleLocalName(const NamedDecl *ND); 275234310Sbapt void mangleNestedName(const NamedDecl *ND, const DeclContext *DC, 276234310Sbapt bool NoFunction=false); 277228697Sbapt void mangleNestedName(const TemplateDecl *TD, 278228697Sbapt const TemplateArgument *TemplateArgs, 279228701Sbz unsigned NumTemplateArgs); 280269162Sbapt void manglePrefix(NestedNameSpecifier *qualifier); 2811590Srgrimes void manglePrefix(const DeclContext *DC, bool NoFunction=false); 2821590Srgrimes void manglePrefix(QualType type); 2831590Srgrimes void mangleTemplatePrefix(const TemplateDecl *ND); 2841590Srgrimes void mangleTemplatePrefix(TemplateName Template); 2851590Srgrimes void mangleOperatorName(OverloadedOperatorKind OO, unsigned Arity); 2861590Srgrimes void mangleQualifiers(Qualifiers Quals); 2871590Srgrimes void mangleRefQualifier(RefQualifierKind RefQualifier); 2881590Srgrimes 2891590Srgrimes void mangleObjCMethodName(const ObjCMethodDecl *MD); 2901590Srgrimes 291228063Sbapt // Declare manglers for every type class. 29295060Sjmallett#define ABSTRACT_TYPE(CLASS, PARENT) 2931590Srgrimes#define NON_CANONICAL_TYPE(CLASS, PARENT) 2941590Srgrimes#define TYPE(CLASS, PARENT) void mangleType(const CLASS##Type *T); 2951590Srgrimes#include "clang/AST/TypeNodes.def" 2961590Srgrimes 2971590Srgrimes void mangleType(const TagType*); 2981590Srgrimes void mangleType(TemplateName); 299228063Sbapt void mangleBareFunctionType(const FunctionType *T, 300228063Sbapt bool MangleReturnType); 301228063Sbapt void mangleNeonVectorType(const VectorType *T); 3021590Srgrimes 3031590Srgrimes void mangleIntegerLiteral(QualType T, const llvm::APSInt &Value); 304228063Sbapt void mangleMemberExpr(const Expr *base, bool isArrow, 3051590Srgrimes NestedNameSpecifier *qualifier, 3061590Srgrimes NamedDecl *firstQualifierLookup, 3071590Srgrimes DeclarationName name, 308228063Sbapt unsigned knownArity); 3091590Srgrimes void mangleExpression(const Expr *E, unsigned Arity = UnknownArity); 3101590Srgrimes void mangleCXXCtorType(CXXCtorType T); 3111590Srgrimes void mangleCXXDtorType(CXXDtorType T); 3121590Srgrimes 3131590Srgrimes void mangleTemplateArgs(const ASTTemplateArgumentListInfo &TemplateArgs); 314100014Sjmallett void mangleTemplateArgs(TemplateName Template, 3151590Srgrimes const TemplateArgument *TemplateArgs, 3161590Srgrimes unsigned NumTemplateArgs); 3171590Srgrimes void mangleTemplateArgs(const TemplateParameterList &PL, 3181590Srgrimes const TemplateArgument *TemplateArgs, 3191590Srgrimes unsigned NumTemplateArgs); 3201590Srgrimes void mangleTemplateArgs(const TemplateParameterList &PL, 3211590Srgrimes const TemplateArgumentList &AL); 3221590Srgrimes void mangleTemplateArg(const NamedDecl *P, TemplateArgument A); 3231590Srgrimes void mangleUnresolvedTemplateArgs(const TemplateArgument *args, 3241590Srgrimes unsigned numArgs); 3251590Srgrimes 3261590Srgrimes void mangleTemplateParameter(unsigned Index); 3271590Srgrimes 32895060Sjmallett void mangleFunctionParam(const ParmVarDecl *parm); 3291590Srgrimes}; 33095060Sjmallett 331228063Sbapt} 3321590Srgrimes 33395060Sjmallettstatic bool isInCLinkageSpecification(const Decl *D) { 3341590Srgrimes D = D->getCanonicalDecl(); 33595060Sjmallett for (const DeclContext *DC = D->getDeclContext(); 3361590Srgrimes !DC->isTranslationUnit(); DC = DC->getParent()) { 3371590Srgrimes if (const LinkageSpecDecl *Linkage = dyn_cast<LinkageSpecDecl>(DC)) 3381590Srgrimes return Linkage->getLanguage() == LinkageSpecDecl::lang_c; 3391590Srgrimes } 3401590Srgrimes 3411590Srgrimes return false; 3421590Srgrimes} 3431590Srgrimes 3441590Srgrimesbool ItaniumMangleContext::shouldMangleDeclName(const NamedDecl *D) { 3451590Srgrimes // In C, functions with no attributes never need to be mangled. Fastpath them. 3461590Srgrimes if (!getASTContext().getLangOptions().CPlusPlus && !D->hasAttrs()) 3471590Srgrimes return false; 3481590Srgrimes 3491590Srgrimes // Any decl can be declared with __asm("foo") on it, and this takes precedence 3501590Srgrimes // over all other naming in the .o file. 3511590Srgrimes if (D->hasAttr<AsmLabelAttr>()) 3521590Srgrimes return true; 3531590Srgrimes 3541590Srgrimes // Clang's "overloadable" attribute extension to C/C++ implies name mangling 3551590Srgrimes // (always) as does passing a C++ member function and a function 3561590Srgrimes // whose name is not a simple identifier. 3571590Srgrimes const FunctionDecl *FD = dyn_cast<FunctionDecl>(D); 3581590Srgrimes if (FD && (FD->hasAttr<OverloadableAttr>() || isa<CXXMethodDecl>(FD) || 3591590Srgrimes !FD->getDeclName().isIdentifier())) 3601590Srgrimes return true; 3611590Srgrimes 3621590Srgrimes // Otherwise, no mangling is done outside C++ mode. 3631590Srgrimes if (!getASTContext().getLangOptions().CPlusPlus) 3641590Srgrimes return false; 3651590Srgrimes 3661590Srgrimes // Variables at global scope with non-internal linkage are not mangled 367228063Sbapt if (!FD) { 3681590Srgrimes const DeclContext *DC = D->getDeclContext(); 3691590Srgrimes // Check for extern variable declared locally. 3701590Srgrimes if (DC->isFunctionOrMethod() && D->hasLinkage()) 3711590Srgrimes while (!DC->isNamespace() && !DC->isTranslationUnit()) 3721590Srgrimes DC = DC->getParent(); 3731590Srgrimes if (DC->isTranslationUnit() && D->getLinkage() != InternalLinkage) 3741590Srgrimes return false; 3751590Srgrimes } 3761590Srgrimes 3771590Srgrimes // Class members are always mangled. 378228063Sbapt if (D->getDeclContext()->isRecord()) 3791590Srgrimes return true; 3801590Srgrimes 3811590Srgrimes // C functions and "main" are not mangled. 3821590Srgrimes if ((FD && FD->isMain()) || isInCLinkageSpecification(D)) 3831590Srgrimes return false; 3841590Srgrimes 38595060Sjmallett return true; 38695060Sjmallett} 38795060Sjmallett 38895060Sjmallettvoid CXXNameMangler::mangle(const NamedDecl *D, StringRef Prefix) { 38995060Sjmallett // Any decl can be declared with __asm("foo") on it, and this takes precedence 390100014Sjmallett // over all other naming in the .o file. 39195060Sjmallett if (const AsmLabelAttr *ALA = D->getAttr<AsmLabelAttr>()) { 39295060Sjmallett // If we have an asm name, then we use it as the mangling. 393100014Sjmallett 394100014Sjmallett // Adding the prefix can cause problems when one file has a "foo" and 39595060Sjmallett // another has a "\01foo". That is known to happen on ELF with the 39695060Sjmallett // tricks normally used for producing aliases (PR9177). Fortunately the 39795060Sjmallett // llvm mangler on ELF is a nop, so we can just avoid adding the \01 39895060Sjmallett // marker. We also avoid adding the marker if this is an alias for an 39995060Sjmallett // LLVM intrinsic. 4001590Srgrimes StringRef UserLabelPrefix = 4011590Srgrimes getASTContext().getTargetInfo().getUserLabelPrefix(); 4021590Srgrimes if (!UserLabelPrefix.empty() && !ALA->getLabel().startswith("llvm.")) 4031590Srgrimes Out << '\01'; // LLVM IR Marker for __asm("foo") 4041590Srgrimes 4051590Srgrimes Out << ALA->getLabel(); 4061590Srgrimes return; 4071590Srgrimes } 4081590Srgrimes 4091590Srgrimes // <mangled-name> ::= _Z <encoding> 41095060Sjmallett // ::= <data name> 41195060Sjmallett // ::= <special-name> 412228063Sbapt Out << Prefix; 4131590Srgrimes if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) 4141590Srgrimes mangleFunctionEncoding(FD); 4151590Srgrimes else if (const VarDecl *VD = dyn_cast<VarDecl>(D)) 4161590Srgrimes mangleName(VD); 4171590Srgrimes else 41895060Sjmallett mangleName(cast<FieldDecl>(D)); 41995060Sjmallett} 4201590Srgrimes 4211590Srgrimesvoid CXXNameMangler::mangleFunctionEncoding(const FunctionDecl *FD) { 4221590Srgrimes // <encoding> ::= <function name> <bare-function-type> 4231590Srgrimes mangleName(FD); 4241590Srgrimes 4251590Srgrimes // Don't mangle in the type if this isn't a decl we should typically mangle. 4261590Srgrimes if (!Context.shouldMangleDeclName(FD)) 4271590Srgrimes return; 4281590Srgrimes 4291590Srgrimes // Whether the mangling of a function type includes the return type depends on 4301590Srgrimes // the context and the nature of the function. The rules for deciding whether 4311590Srgrimes // the return type is included are: 4321590Srgrimes // 4331590Srgrimes // 1. Template functions (names or types) have return types encoded, with 4341590Srgrimes // the exceptions listed below. 4351590Srgrimes // 2. Function types not appearing as part of a function name mangling, 4361590Srgrimes // e.g. parameters, pointer types, etc., have return type encoded, with the 4371590Srgrimes // exceptions listed below. 4381590Srgrimes // 3. Non-template function names do not have return types encoded. 4391590Srgrimes // 4401590Srgrimes // The exceptions mentioned in (1) and (2) above, for which the return type is 4411590Srgrimes // never included, are 4421590Srgrimes // 1. Constructors. 4431590Srgrimes // 2. Destructors. 4441590Srgrimes // 3. Conversion operator functions, e.g. operator int. 4451590Srgrimes bool MangleReturnType = false; 4461590Srgrimes if (FunctionTemplateDecl *PrimaryTemplate = FD->getPrimaryTemplate()) { 4471590Srgrimes if (!(isa<CXXConstructorDecl>(FD) || isa<CXXDestructorDecl>(FD) || 4481590Srgrimes isa<CXXConversionDecl>(FD))) 4491590Srgrimes MangleReturnType = true; 4501590Srgrimes 4511590Srgrimes // Mangle the type of the primary template. 4521590Srgrimes FD = PrimaryTemplate->getTemplatedDecl(); 4531590Srgrimes } 4541590Srgrimes 4551590Srgrimes mangleBareFunctionType(FD->getType()->getAs<FunctionType>(), 4561590Srgrimes MangleReturnType); 4571590Srgrimes} 458228063Sbapt 459228063Sbaptstatic const DeclContext *IgnoreLinkageSpecDecls(const DeclContext *DC) { 4601590Srgrimes while (isa<LinkageSpecDecl>(DC)) { 4611590Srgrimes DC = DC->getParent(); 4621590Srgrimes } 4631590Srgrimes 4641590Srgrimes return DC; 4651590Srgrimes} 4667896Sache 4671590Srgrimes/// isStd - Return whether a given namespace is the 'std' namespace. 4681590Srgrimesstatic bool isStd(const NamespaceDecl *NS) { 4691590Srgrimes if (!IgnoreLinkageSpecDecls(NS->getParent())->isTranslationUnit()) 4701590Srgrimes return false; 4711590Srgrimes 4721590Srgrimes const IdentifierInfo *II = NS->getOriginalNamespace()->getIdentifier(); 4731590Srgrimes return II && II->isStr("std"); 4741590Srgrimes} 4751590Srgrimes 47695060Sjmallett// isStdNamespace - Return whether a given decl context is a toplevel 'std' 47795060Sjmallett// namespace. 47895060Sjmallettstatic bool isStdNamespace(const DeclContext *DC) { 47938926Ssteve if (!DC->isNamespace()) 480100014Sjmallett return false; 48195060Sjmallett 48295060Sjmallett return isStd(cast<NamespaceDecl>(DC)); 48395060Sjmallett} 48495060Sjmallett 48538926Sstevestatic const TemplateDecl * 48695060SjmallettisTemplate(const NamedDecl *ND, const TemplateArgumentList *&TemplateArgs) { 48795060Sjmallett // Check if we have a function template. 48895060Sjmallett if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(ND)){ 48995060Sjmallett if (const TemplateDecl *TD = FD->getPrimaryTemplate()) { 49095060Sjmallett TemplateArgs = FD->getTemplateSpecializationArgs(); 49195060Sjmallett return TD; 49295060Sjmallett } 49395060Sjmallett } 49495060Sjmallett 49595060Sjmallett // Check if we have a class template. 49695060Sjmallett if (const ClassTemplateSpecializationDecl *Spec = 49795060Sjmallett dyn_cast<ClassTemplateSpecializationDecl>(ND)) { 49895060Sjmallett TemplateArgs = &Spec->getTemplateArgs(); 49995060Sjmallett return Spec->getSpecializedTemplate(); 50095060Sjmallett } 50195060Sjmallett 50295060Sjmallett return 0; 50395060Sjmallett} 50495060Sjmallett 5051590Srgrimesvoid CXXNameMangler::mangleName(const NamedDecl *ND) { 506228063Sbapt // <name> ::= <nested-name> 5071590Srgrimes // ::= <unscoped-name> 5081590Srgrimes // ::= <unscoped-template-name> <template-args> 5091590Srgrimes // ::= <local-name> 5101590Srgrimes // 5111590Srgrimes const DeclContext *DC = ND->getDeclContext(); 51295060Sjmallett 5131590Srgrimes // If this is an extern variable declared locally, the relevant DeclContext 5141590Srgrimes // is that of the containing namespace, or the translation unit. 51595887Sjmallett if (isa<FunctionDecl>(DC) && ND->hasLinkage()) 5161590Srgrimes while (!DC->isNamespace() && !DC->isTranslationUnit()) 51795060Sjmallett DC = DC->getParent(); 51895060Sjmallett else if (GetLocalClassDecl(ND)) { 51995060Sjmallett mangleLocalName(ND); 52095060Sjmallett return; 5211590Srgrimes } 5221590Srgrimes 5231590Srgrimes while (isa<LinkageSpecDecl>(DC)) 5241590Srgrimes DC = DC->getParent(); 5251590Srgrimes 5261590Srgrimes if (DC->isTranslationUnit() || isStdNamespace(DC)) { 5271590Srgrimes // Check if we have a template. 5281590Srgrimes const TemplateArgumentList *TemplateArgs = 0; 529228063Sbapt if (const TemplateDecl *TD = isTemplate(ND, TemplateArgs)) { 5301590Srgrimes mangleUnscopedTemplateName(TD); 5311590Srgrimes TemplateParameterList *TemplateParameters = TD->getTemplateParameters(); 5321590Srgrimes mangleTemplateArgs(*TemplateParameters, *TemplateArgs); 5331590Srgrimes return; 5341590Srgrimes } 5351590Srgrimes 5361590Srgrimes mangleUnscopedName(ND); 5371590Srgrimes return; 5381590Srgrimes } 5391590Srgrimes 5401590Srgrimes if (isa<FunctionDecl>(DC) || isa<ObjCMethodDecl>(DC)) { 5411590Srgrimes mangleLocalName(ND); 5421590Srgrimes return; 5431590Srgrimes } 5441590Srgrimes 5451590Srgrimes mangleNestedName(ND, DC); 5461590Srgrimes} 5471590Srgrimesvoid CXXNameMangler::mangleName(const TemplateDecl *TD, 5481590Srgrimes const TemplateArgument *TemplateArgs, 5491590Srgrimes unsigned NumTemplateArgs) { 55095060Sjmallett const DeclContext *DC = IgnoreLinkageSpecDecls(TD->getDeclContext()); 55195060Sjmallett 55295060Sjmallett if (DC->isTranslationUnit() || isStdNamespace(DC)) { 553228063Sbapt mangleUnscopedTemplateName(TD); 55495060Sjmallett TemplateParameterList *TemplateParameters = TD->getTemplateParameters(); 55595060Sjmallett mangleTemplateArgs(*TemplateParameters, TemplateArgs, NumTemplateArgs); 556228063Sbapt } else { 5571590Srgrimes mangleNestedName(TD, TemplateArgs, NumTemplateArgs); 55895060Sjmallett } 55995060Sjmallett} 56095060Sjmallett 56195060Sjmallettvoid CXXNameMangler::mangleUnscopedName(const NamedDecl *ND) { 56295060Sjmallett // <unscoped-name> ::= <unqualified-name> 56395060Sjmallett // ::= St <unqualified-name> # ::std:: 564228063Sbapt if (isStdNamespace(ND->getDeclContext())) 56595060Sjmallett Out << "St"; 56695060Sjmallett 56795060Sjmallett mangleUnqualifiedName(ND); 56895060Sjmallett} 56924901Sjoerg 57095060Sjmallettvoid CXXNameMangler::mangleUnscopedTemplateName(const TemplateDecl *ND) { 5711590Srgrimes // <unscoped-template-name> ::= <unscoped-name> 572228063Sbapt // ::= <substitution> 573228063Sbapt if (mangleSubstitution(ND)) 5741590Srgrimes return; 5751590Srgrimes 5761590Srgrimes // <template-template-param> ::= <template-param> 5771590Srgrimes if (const TemplateTemplateParmDecl *TTP 5781590Srgrimes = dyn_cast<TemplateTemplateParmDecl>(ND)) { 5791590Srgrimes mangleTemplateParameter(TTP->getIndex()); 5801590Srgrimes return; 581228063Sbapt } 5821590Srgrimes 5831590Srgrimes mangleUnscopedName(ND->getTemplatedDecl()); 584228063Sbapt addSubstitution(ND); 5851590Srgrimes} 5861590Srgrimes 5871590Srgrimesvoid CXXNameMangler::mangleUnscopedTemplateName(TemplateName Template) { 5881590Srgrimes // <unscoped-template-name> ::= <unscoped-name> 58995887Sjmallett // ::= <substitution> 5901590Srgrimes if (TemplateDecl *TD = Template.getAsTemplateDecl()) 591228063Sbapt return mangleUnscopedTemplateName(TD); 592228063Sbapt 5931590Srgrimes if (mangleSubstitution(Template)) 594228063Sbapt return; 5951590Srgrimes 5961590Srgrimes DependentTemplateName *Dependent = Template.getAsDependentTemplateName(); 5971590Srgrimes assert(Dependent && "Not a dependent template name?"); 5981590Srgrimes if (const IdentifierInfo *Id = Dependent->getIdentifier()) 5991590Srgrimes mangleSourceName(Id); 6001590Srgrimes else 60195060Sjmallett mangleOperatorName(Dependent->getOperator(), UnknownArity); 60295887Sjmallett 6031590Srgrimes addSubstitution(Template); 604228063Sbapt} 6051590Srgrimes 606228063Sbaptvoid CXXNameMangler::mangleFloat(const llvm::APFloat &f) { 607228063Sbapt // ABI: 60895060Sjmallett // Floating-point literals are encoded using a fixed-length 60995060Sjmallett // lowercase hexadecimal string corresponding to the internal 61095060Sjmallett // representation (IEEE on Itanium), high-order bytes first, 611228063Sbapt // without leading zeroes. For example: "Lf bf800000 E" is -1.0f 612228063Sbapt // on Itanium. 61395060Sjmallett // APInt::toString uses uppercase hexadecimal, and it's not really 61495060Sjmallett // worth embellishing that interface for this use case, so we just 6151590Srgrimes // do a second pass to lowercase things. 6161590Srgrimes typedef llvm::SmallString<20> buffer_t; 6171590Srgrimes buffer_t buffer; 6181590Srgrimes f.bitcastToAPInt().toString(buffer, 16, false); 6191590Srgrimes 6201590Srgrimes for (buffer_t::iterator i = buffer.begin(), e = buffer.end(); i != e; ++i) 6211590Srgrimes if (isupper(*i)) *i = tolower(*i); 6221590Srgrimes 6231590Srgrimes Out.write(buffer.data(), buffer.size()); 6241590Srgrimes} 62595060Sjmallett 62695887Sjmallettvoid CXXNameMangler::mangleNumber(const llvm::APSInt &Value) { 6271590Srgrimes if (Value.isSigned() && Value.isNegative()) { 628228063Sbapt Out << 'n'; 629228063Sbapt Value.abs().print(Out, true); 6301590Srgrimes } else 631228063Sbapt Value.print(Out, Value.isSigned()); 6321590Srgrimes} 6331590Srgrimes 6341590Srgrimesvoid CXXNameMangler::mangleNumber(int64_t Number) { 63595060Sjmallett // <number> ::= [n] <non-negative decimal integer> 63695060Sjmallett if (Number < 0) { 63795060Sjmallett Out << 'n'; 638228063Sbapt Number = -Number; 63995060Sjmallett } 640228063Sbapt 641228063Sbapt Out << Number; 64295060Sjmallett} 64395060Sjmallett 644228063Sbaptvoid CXXNameMangler::mangleCallOffset(int64_t NonVirtual, int64_t Virtual) { 64595060Sjmallett // <call-offset> ::= h <nv-offset> _ 646228063Sbapt // ::= v <v-offset> _ 647228063Sbapt // <nv-offset> ::= <offset number> # non-virtual base override 64895060Sjmallett // <v-offset> ::= <offset number> _ <virtual offset number> 649228063Sbapt // # virtual base override, with vcall offset 65095060Sjmallett if (!Virtual) { 65195060Sjmallett Out << 'h'; 65295060Sjmallett mangleNumber(NonVirtual); 6531590Srgrimes Out << '_'; 6541590Srgrimes return; 6551590Srgrimes } 6561590Srgrimes 65795060Sjmallett Out << 'v'; 65895887Sjmallett mangleNumber(NonVirtual); 6591590Srgrimes Out << '_'; 66095060Sjmallett mangleNumber(Virtual); 661228063Sbapt Out << '_'; 6621590Srgrimes} 6631590Srgrimes 6641590Srgrimesvoid CXXNameMangler::manglePrefix(QualType type) { 665228063Sbapt if (const TemplateSpecializationType *TST = 666228063Sbapt type->getAs<TemplateSpecializationType>()) { 667228063Sbapt if (!mangleSubstitution(QualType(TST, 0))) { 668228063Sbapt mangleTemplatePrefix(TST->getTemplateName()); 6691590Srgrimes 6701590Srgrimes // FIXME: GCC does not appear to mangle the template arguments when 6711590Srgrimes // the template in question is a dependent template name. Should we 67295060Sjmallett // emulate that badness? 67395060Sjmallett mangleTemplateArgs(TST->getTemplateName(), TST->getArgs(), 67495060Sjmallett TST->getNumArgs()); 67595887Sjmallett addSubstitution(QualType(TST, 0)); 67695060Sjmallett } 67795060Sjmallett } else if (const DependentTemplateSpecializationType *DTST 67895060Sjmallett = type->getAs<DependentTemplateSpecializationType>()) { 67995060Sjmallett TemplateName Template 68095060Sjmallett = getASTContext().getDependentTemplateName(DTST->getQualifier(), 68195060Sjmallett DTST->getIdentifier()); 68295060Sjmallett mangleTemplatePrefix(Template); 68395060Sjmallett 68495060Sjmallett // FIXME: GCC does not appear to mangle the template arguments when 68595060Sjmallett // the template in question is a dependent template name. Should we 68695060Sjmallett // emulate that badness? 6871590Srgrimes mangleTemplateArgs(Template, DTST->getArgs(), DTST->getNumArgs()); 6881590Srgrimes } else { 68995060Sjmallett // We use the QualType mangle type variant here because it handles 69095887Sjmallett // substitutions. 6911590Srgrimes mangleType(type); 6921590Srgrimes } 6931590Srgrimes} 6941590Srgrimes 6951590Srgrimes/// Mangle everything prior to the base-unresolved-name in an unresolved-name. 6961590Srgrimes/// 6971590Srgrimes/// \param firstQualifierLookup - the entity found by unqualified lookup 6981590Srgrimes/// for the first name in the qualifier, if this is for a member expression 6991590Srgrimes/// \param recursive - true if this is being called recursively, 7001590Srgrimes/// i.e. if there is more prefix "to the right". 7011590Srgrimesvoid CXXNameMangler::mangleUnresolvedPrefix(NestedNameSpecifier *qualifier, 7021590Srgrimes NamedDecl *firstQualifierLookup, 7031590Srgrimes bool recursive) { 7041590Srgrimes 7051590Srgrimes // x, ::x 7061590Srgrimes // <unresolved-name> ::= [gs] <base-unresolved-name> 7071590Srgrimes 7081590Srgrimes // T::x / decltype(p)::x 70995060Sjmallett // <unresolved-name> ::= sr <unresolved-type> <base-unresolved-name> 71095887Sjmallett 7111590Srgrimes // T::N::x /decltype(p)::N::x 7121590Srgrimes // <unresolved-name> ::= srN <unresolved-type> <unresolved-qualifier-level>+ E 713228063Sbapt // <base-unresolved-name> 71495060Sjmallett 7151590Srgrimes // A::x, N::y, A<T>::z; "gs" means leading "::" 7161590Srgrimes // <unresolved-name> ::= [gs] sr <unresolved-qualifier-level>+ E 7171590Srgrimes // <base-unresolved-name> 71895060Sjmallett 7191590Srgrimes switch (qualifier->getKind()) { 7201590Srgrimes case NestedNameSpecifier::Global: 7211590Srgrimes Out << "gs"; 7221590Srgrimes 7231590Srgrimes // We want an 'sr' unless this is the entire NNS. 7241590Srgrimes if (recursive) 7251590Srgrimes Out << "sr"; 7261590Srgrimes 72795060Sjmallett // We never want an 'E' here. 72895887Sjmallett return; 7291590Srgrimes 7301590Srgrimes case NestedNameSpecifier::Namespace: 73195060Sjmallett if (qualifier->getPrefix()) 7321590Srgrimes mangleUnresolvedPrefix(qualifier->getPrefix(), firstQualifierLookup, 7331590Srgrimes /*recursive*/ true); 734228063Sbapt else 735228063Sbapt Out << "sr"; 7361590Srgrimes mangleSourceName(qualifier->getAsNamespace()->getIdentifier()); 7371590Srgrimes break; 7381590Srgrimes case NestedNameSpecifier::NamespaceAlias: 739228063Sbapt if (qualifier->getPrefix()) 7401590Srgrimes mangleUnresolvedPrefix(qualifier->getPrefix(), firstQualifierLookup, 74195060Sjmallett /*recursive*/ true); 7421590Srgrimes else 7431590Srgrimes Out << "sr"; 7441590Srgrimes mangleSourceName(qualifier->getAsNamespaceAlias()->getIdentifier()); 7451590Srgrimes break; 746228063Sbapt 747228063Sbapt case NestedNameSpecifier::TypeSpec: 748228063Sbapt case NestedNameSpecifier::TypeSpecWithTemplate: { 74995060Sjmallett const Type *type = qualifier->getAsType(); 750228063Sbapt 75195060Sjmallett // We only want to use an unresolved-type encoding if this is one of: 75295060Sjmallett // - a decltype 753228063Sbapt // - a template type parameter 754228063Sbapt // - a template template parameter with arguments 75595060Sjmallett // In all of these cases, we should have no prefix. 75695060Sjmallett if (qualifier->getPrefix()) { 757228063Sbapt mangleUnresolvedPrefix(qualifier->getPrefix(), firstQualifierLookup, 75895060Sjmallett /*recursive*/ true); 759228063Sbapt } else { 760228063Sbapt // Otherwise, all the cases want this. 761228063Sbapt Out << "sr"; 76295060Sjmallett } 76395060Sjmallett 76495060Sjmallett // Only certain other types are valid as prefixes; enumerate them. 7651590Srgrimes switch (type->getTypeClass()) { 766228063Sbapt case Type::Builtin: 7671590Srgrimes case Type::Complex: 76895060Sjmallett case Type::Pointer: 769228063Sbapt case Type::BlockPointer: 7701590Srgrimes case Type::LValueReference: 771228063Sbapt case Type::RValueReference: 772228063Sbapt case Type::MemberPointer: 773228063Sbapt case Type::ConstantArray: 774228063Sbapt case Type::IncompleteArray: 77595060Sjmallett case Type::VariableArray: 77695060Sjmallett case Type::DependentSizedArray: 77795060Sjmallett case Type::DependentSizedExtVector: 778228063Sbapt case Type::Vector: 779228063Sbapt case Type::ExtVector: 780228063Sbapt case Type::FunctionProto: 781228063Sbapt case Type::FunctionNoProto: 78295060Sjmallett case Type::Enum: 783228063Sbapt case Type::Paren: 7841590Srgrimes case Type::Elaborated: 7851590Srgrimes case Type::Attributed: 786228063Sbapt case Type::Auto: 7871590Srgrimes case Type::PackExpansion: 788228063Sbapt case Type::ObjCObject: 7891590Srgrimes case Type::ObjCInterface: 79095060Sjmallett case Type::ObjCObjectPointer: 791228063Sbapt case Type::Atomic: 7921590Srgrimes llvm_unreachable("type is illegal as a nested name specifier"); 793228063Sbapt 794228063Sbapt case Type::SubstTemplateTypeParmPack: 795228063Sbapt // FIXME: not clear how to mangle this! 7961590Srgrimes // template <class T...> class A { 797228063Sbapt // template <class U...> void foo(decltype(T::foo(U())) x...); 798269162Sbapt // }; 799228063Sbapt Out << "_SUBSTPACK_"; 8001590Srgrimes break; 801228063Sbapt 8021590Srgrimes // <unresolved-type> ::= <template-param> 8031590Srgrimes // ::= <decltype> 8041590Srgrimes // ::= <template-template-param> <template-args> 8051590Srgrimes // (this last is not official yet) 8061590Srgrimes case Type::TypeOfExpr: 80795060Sjmallett case Type::TypeOf: 80895887Sjmallett case Type::Decltype: 8091590Srgrimes case Type::TemplateTypeParm: 81095060Sjmallett case Type::UnaryTransform: 81195060Sjmallett case Type::SubstTemplateTypeParm: 81228386Sjlemon unresolvedType: 81395060Sjmallett assert(!qualifier->getPrefix()); 81495060Sjmallett 81595060Sjmallett // We only get here recursively if we're followed by identifiers. 81695060Sjmallett if (recursive) Out << 'N'; 81795060Sjmallett 818228063Sbapt // This seems to do everything we want. It's not really 81995060Sjmallett // sanctioned for a substituted template parameter, though. 82095060Sjmallett mangleType(QualType(type, 0)); 8211590Srgrimes 8221590Srgrimes // We never want to print 'E' directly after an unresolved-type, 82395060Sjmallett // so we return directly. 82495060Sjmallett return; 825269162Sbapt 826269162Sbapt case Type::Typedef: 827269162Sbapt mangleSourceName(cast<TypedefType>(type)->getDecl()->getIdentifier()); 828269162Sbapt break; 8291590Srgrimes 8301590Srgrimes case Type::UnresolvedUsing: 8311590Srgrimes mangleSourceName(cast<UnresolvedUsingType>(type)->getDecl() 8321590Srgrimes ->getIdentifier()); 8331590Srgrimes break; 8341590Srgrimes 8351590Srgrimes case Type::Record: 8361590Srgrimes mangleSourceName(cast<RecordType>(type)->getDecl()->getIdentifier()); 83795060Sjmallett break; 83895887Sjmallett 8391590Srgrimes case Type::TemplateSpecialization: { 84095060Sjmallett const TemplateSpecializationType *tst 84195060Sjmallett = cast<TemplateSpecializationType>(type); 8421590Srgrimes TemplateName name = tst->getTemplateName(); 8431590Srgrimes switch (name.getKind()) { 8441590Srgrimes case TemplateName::Template: 845228063Sbapt case TemplateName::QualifiedTemplate: { 846228063Sbapt TemplateDecl *temp = name.getAsTemplateDecl(); 847228063Sbapt 848228063Sbapt // If the base is a template template parameter, this is an 849228063Sbapt // unresolved type. 850228063Sbapt assert(temp && "no template for template specialization type"); 851228063Sbapt if (isa<TemplateTemplateParmDecl>(temp)) goto unresolvedType; 852228063Sbapt 853228063Sbapt mangleSourceName(temp->getIdentifier()); 8541590Srgrimes break; 8551590Srgrimes } 8561590Srgrimes 85795060Sjmallett case TemplateName::OverloadedTemplate: 8581590Srgrimes case TemplateName::DependentTemplate: 8591590Srgrimes llvm_unreachable("invalid base for a template specialization type"); 8601590Srgrimes 8611590Srgrimes case TemplateName::SubstTemplateTemplateParm: { 8621590Srgrimes SubstTemplateTemplateParmStorage *subst 8631590Srgrimes = name.getAsSubstTemplateTemplateParm(); 8641590Srgrimes mangleExistingSubstitution(subst->getReplacement()); 86595060Sjmallett break; 86695887Sjmallett } 8671590Srgrimes 86895060Sjmallett case TemplateName::SubstTemplateTemplateParmPack: { 86995060Sjmallett // FIXME: not clear how to mangle this! 8701590Srgrimes // template <template <class U> class T...> class A { 87176822Sgshapiro // template <class U...> void foo(decltype(T<U>::foo) x...); 87276822Sgshapiro // }; 87376822Sgshapiro Out << "_SUBSTPACK_"; 87476822Sgshapiro break; 87576822Sgshapiro } 87676822Sgshapiro } 87795060Sjmallett 87895060Sjmallett mangleUnresolvedTemplateArgs(tst->getArgs(), tst->getNumArgs()); 8791590Srgrimes break; 88095060Sjmallett } 8811590Srgrimes 88295060Sjmallett case Type::InjectedClassName: 8831590Srgrimes mangleSourceName(cast<InjectedClassNameType>(type)->getDecl() 8841590Srgrimes ->getIdentifier()); 88576822Sgshapiro break; 886228063Sbapt 8871590Srgrimes case Type::DependentName: 8881590Srgrimes mangleSourceName(cast<DependentNameType>(type)->getIdentifier()); 8891590Srgrimes break; 8901590Srgrimes 8911590Srgrimes case Type::DependentTemplateSpecialization: { 8921590Srgrimes const DependentTemplateSpecializationType *tst 8931590Srgrimes = cast<DependentTemplateSpecializationType>(type); 894228063Sbapt mangleSourceName(tst->getIdentifier()); 895228063Sbapt mangleUnresolvedTemplateArgs(tst->getArgs(), tst->getNumArgs()); 896228063Sbapt break; 897228063Sbapt } 898298879Spfg } 8991590Srgrimes break; 90095060Sjmallett } 90195887Sjmallett 9021590Srgrimes case NestedNameSpecifier::Identifier: 90395060Sjmallett // Member expressions can have these without prefixes. 90495060Sjmallett if (qualifier->getPrefix()) { 90595060Sjmallett mangleUnresolvedPrefix(qualifier->getPrefix(), firstQualifierLookup, 90695060Sjmallett /*recursive*/ true); 907228063Sbapt } else if (firstQualifierLookup) { 908228063Sbapt 90995060Sjmallett // Try to make a proper qualifier out of the lookup result, and 91095060Sjmallett // then just recurse on that. 91195060Sjmallett NestedNameSpecifier *newQualifier; 91295060Sjmallett if (TypeDecl *typeDecl = dyn_cast<TypeDecl>(firstQualifierLookup)) { 91395060Sjmallett QualType type = getASTContext().getTypeDeclType(typeDecl); 91495060Sjmallett 91595060Sjmallett // Pretend we had a different nested name specifier. 91695060Sjmallett newQualifier = NestedNameSpecifier::Create(getASTContext(), 91795060Sjmallett /*prefix*/ 0, 91895060Sjmallett /*template*/ false, 91995060Sjmallett type.getTypePtr()); 92095060Sjmallett } else if (NamespaceDecl *nspace = 92195060Sjmallett dyn_cast<NamespaceDecl>(firstQualifierLookup)) { 92295060Sjmallett newQualifier = NestedNameSpecifier::Create(getASTContext(), 92395060Sjmallett /*prefix*/ 0, 92495060Sjmallett nspace); 92595060Sjmallett } else if (NamespaceAliasDecl *alias = 92695060Sjmallett dyn_cast<NamespaceAliasDecl>(firstQualifierLookup)) { 92795060Sjmallett newQualifier = NestedNameSpecifier::Create(getASTContext(), 9281590Srgrimes /*prefix*/ 0, 9291590Srgrimes alias); 9301590Srgrimes } else { 93195060Sjmallett // No sensible mangling to do here. 93295060Sjmallett newQualifier = 0; 93395060Sjmallett } 93495060Sjmallett 93595060Sjmallett if (newQualifier) 93695060Sjmallett return mangleUnresolvedPrefix(newQualifier, /*lookup*/ 0, recursive); 93795060Sjmallett 9381590Srgrimes } else { 9391590Srgrimes Out << "sr"; 9401590Srgrimes } 9411590Srgrimes 9421590Srgrimes mangleSourceName(qualifier->getAsIdentifier()); 943228063Sbapt break; 944228063Sbapt } 945228063Sbapt 946228063Sbapt // If this was the innermost part of the NNS, and we fell out to 947228063Sbapt // here, append an 'E'. 948228063Sbapt if (!recursive) 949228063Sbapt Out << 'E'; 950228063Sbapt} 951228063Sbapt 952228063Sbapt/// Mangle an unresolved-name, which is generally used for names which 953228063Sbapt/// weren't resolved to specific entities. 9541590Srgrimesvoid CXXNameMangler::mangleUnresolvedName(NestedNameSpecifier *qualifier, 9551590Srgrimes NamedDecl *firstQualifierLookup, 95695060Sjmallett DeclarationName name, 9571590Srgrimes unsigned knownArity) { 95895060Sjmallett if (qualifier) mangleUnresolvedPrefix(qualifier, firstQualifierLookup); 9591590Srgrimes mangleUnqualifiedName(0, name, knownArity); 9601590Srgrimes} 9611590Srgrimes 9621590Srgrimesstatic const FieldDecl *FindFirstNamedDataMember(const RecordDecl *RD) { 9631590Srgrimes assert(RD->isAnonymousStructOrUnion() && 9641590Srgrimes "Expected anonymous struct or union!"); 96595060Sjmallett 9661590Srgrimes for (RecordDecl::field_iterator I = RD->field_begin(), E = RD->field_end(); 9671590Srgrimes I != E; ++I) { 9681590Srgrimes const FieldDecl *FD = *I; 96995060Sjmallett 9701590Srgrimes if (FD->getIdentifier()) 97195060Sjmallett return FD; 97295060Sjmallett 97395060Sjmallett if (const RecordType *RT = FD->getType()->getAs<RecordType>()) { 97495060Sjmallett if (const FieldDecl *NamedDataMember = 97595060Sjmallett FindFirstNamedDataMember(RT->getDecl())) 97695060Sjmallett return NamedDataMember; 97795060Sjmallett } 97895060Sjmallett } 97995887Sjmallett 98095060Sjmallett // We didn't find a named data member. 98195060Sjmallett return 0; 982100014Sjmallett} 98395060Sjmallett 98495060Sjmallettvoid CXXNameMangler::mangleUnqualifiedName(const NamedDecl *ND, 98595060Sjmallett DeclarationName Name, 98695060Sjmallett unsigned KnownArity) { 987228063Sbapt // <unqualified-name> ::= <operator-name> 988228063Sbapt // ::= <ctor-dtor-name> 989228063Sbapt // ::= <source-name> 990228063Sbapt switch (Name.getNameKind()) { 991228063Sbapt case DeclarationName::Identifier: { 992228063Sbapt if (const IdentifierInfo *II = Name.getAsIdentifierInfo()) { 993228063Sbapt // We must avoid conflicts between internally- and externally- 994228063Sbapt // linked variable and function declaration names in the same TU: 99595060Sjmallett // void test() { extern void foo(); } 996228063Sbapt // static void foo(); 997228063Sbapt // This naming convention is the same as that followed by GCC, 998228063Sbapt // though it shouldn't actually matter. 999228063Sbapt if (ND && ND->getLinkage() == InternalLinkage && 1000228063Sbapt ND->getDeclContext()->isFileContext()) 1001228063Sbapt Out << 'L'; 1002228063Sbapt 1003228063Sbapt mangleSourceName(II); 1004228063Sbapt break; 100595060Sjmallett } 100695060Sjmallett 100795060Sjmallett // Otherwise, an anonymous entity. We must have a declaration. 100895060Sjmallett assert(ND && "mangling empty name without declaration"); 100995060Sjmallett 101095060Sjmallett if (const NamespaceDecl *NS = dyn_cast<NamespaceDecl>(ND)) { 101195060Sjmallett if (NS->isAnonymousNamespace()) { 101295060Sjmallett // This is how gcc mangles these names. 101395060Sjmallett Out << "12_GLOBAL__N_1"; 101495060Sjmallett break; 1015 } 1016 } 1017 1018 if (const VarDecl *VD = dyn_cast<VarDecl>(ND)) { 1019 // We must have an anonymous union or struct declaration. 1020 const RecordDecl *RD = 1021 cast<RecordDecl>(VD->getType()->getAs<RecordType>()->getDecl()); 1022 1023 // Itanium C++ ABI 5.1.2: 1024 // 1025 // For the purposes of mangling, the name of an anonymous union is 1026 // considered to be the name of the first named data member found by a 1027 // pre-order, depth-first, declaration-order walk of the data members of 1028 // the anonymous union. If there is no such data member (i.e., if all of 1029 // the data members in the union are unnamed), then there is no way for 1030 // a program to refer to the anonymous union, and there is therefore no 1031 // need to mangle its name. 1032 const FieldDecl *FD = FindFirstNamedDataMember(RD); 1033 1034 // It's actually possible for various reasons for us to get here 1035 // with an empty anonymous struct / union. Fortunately, it 1036 // doesn't really matter what name we generate. 1037 if (!FD) break; 1038 assert(FD->getIdentifier() && "Data member name isn't an identifier!"); 1039 1040 mangleSourceName(FD->getIdentifier()); 1041 break; 1042 } 1043 1044 // We must have an anonymous struct. 1045 const TagDecl *TD = cast<TagDecl>(ND); 1046 if (const TypedefNameDecl *D = TD->getTypedefNameForAnonDecl()) { 1047 assert(TD->getDeclContext() == D->getDeclContext() && 1048 "Typedef should not be in another decl context!"); 1049 assert(D->getDeclName().getAsIdentifierInfo() && 1050 "Typedef was not named!"); 1051 mangleSourceName(D->getDeclName().getAsIdentifierInfo()); 1052 break; 1053 } 1054 1055 // Get a unique id for the anonymous struct. 1056 uint64_t AnonStructId = Context.getAnonymousStructId(TD); 1057 1058 // Mangle it as a source name in the form 1059 // [n] $_<id> 1060 // where n is the length of the string. 1061 llvm::SmallString<8> Str; 1062 Str += "$_"; 1063 Str += llvm::utostr(AnonStructId); 1064 1065 Out << Str.size(); 1066 Out << Str.str(); 1067 break; 1068 } 1069 1070 case DeclarationName::ObjCZeroArgSelector: 1071 case DeclarationName::ObjCOneArgSelector: 1072 case DeclarationName::ObjCMultiArgSelector: 1073 llvm_unreachable("Can't mangle Objective-C selector names here!"); 1074 1075 case DeclarationName::CXXConstructorName: 1076 if (ND == Structor) 1077 // If the named decl is the C++ constructor we're mangling, use the type 1078 // we were given. 1079 mangleCXXCtorType(static_cast<CXXCtorType>(StructorType)); 1080 else 1081 // Otherwise, use the complete constructor name. This is relevant if a 1082 // class with a constructor is declared within a constructor. 1083 mangleCXXCtorType(Ctor_Complete); 1084 break; 1085 1086 case DeclarationName::CXXDestructorName: 1087 if (ND == Structor) 1088 // If the named decl is the C++ destructor we're mangling, use the type we 1089 // were given. 1090 mangleCXXDtorType(static_cast<CXXDtorType>(StructorType)); 1091 else 1092 // Otherwise, use the complete destructor name. This is relevant if a 1093 // class with a destructor is declared within a destructor. 1094 mangleCXXDtorType(Dtor_Complete); 1095 break; 1096 1097 case DeclarationName::CXXConversionFunctionName: 1098 // <operator-name> ::= cv <type> # (cast) 1099 Out << "cv"; 1100 mangleType(Name.getCXXNameType()); 1101 break; 1102 1103 case DeclarationName::CXXOperatorName: { 1104 unsigned Arity; 1105 if (ND) { 1106 Arity = cast<FunctionDecl>(ND)->getNumParams(); 1107 1108 // If we have a C++ member function, we need to include the 'this' pointer. 1109 // FIXME: This does not make sense for operators that are static, but their 1110 // names stay the same regardless of the arity (operator new for instance). 1111 if (isa<CXXMethodDecl>(ND)) 1112 Arity++; 1113 } else 1114 Arity = KnownArity; 1115 1116 mangleOperatorName(Name.getCXXOverloadedOperator(), Arity); 1117 break; 1118 } 1119 1120 case DeclarationName::CXXLiteralOperatorName: 1121 // FIXME: This mangling is not yet official. 1122 Out << "li"; 1123 mangleSourceName(Name.getCXXLiteralIdentifier()); 1124 break; 1125 1126 case DeclarationName::CXXUsingDirective: 1127 llvm_unreachable("Can't mangle a using directive name!"); 1128 } 1129} 1130 1131void CXXNameMangler::mangleSourceName(const IdentifierInfo *II) { 1132 // <source-name> ::= <positive length number> <identifier> 1133 // <number> ::= [n] <non-negative decimal integer> 1134 // <identifier> ::= <unqualified source code identifier> 1135 Out << II->getLength() << II->getName(); 1136} 1137 1138void CXXNameMangler::mangleNestedName(const NamedDecl *ND, 1139 const DeclContext *DC, 1140 bool NoFunction) { 1141 // <nested-name> 1142 // ::= N [<CV-qualifiers>] [<ref-qualifier>] <prefix> <unqualified-name> E 1143 // ::= N [<CV-qualifiers>] [<ref-qualifier>] <template-prefix> 1144 // <template-args> E 1145 1146 Out << 'N'; 1147 if (const CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(ND)) { 1148 mangleQualifiers(Qualifiers::fromCVRMask(Method->getTypeQualifiers())); 1149 mangleRefQualifier(Method->getRefQualifier()); 1150 } 1151 1152 // Check if we have a template. 1153 const TemplateArgumentList *TemplateArgs = 0; 1154 if (const TemplateDecl *TD = isTemplate(ND, TemplateArgs)) { 1155 mangleTemplatePrefix(TD); 1156 TemplateParameterList *TemplateParameters = TD->getTemplateParameters(); 1157 mangleTemplateArgs(*TemplateParameters, *TemplateArgs); 1158 } 1159 else { 1160 manglePrefix(DC, NoFunction); 1161 mangleUnqualifiedName(ND); 1162 } 1163 1164 Out << 'E'; 1165} 1166void CXXNameMangler::mangleNestedName(const TemplateDecl *TD, 1167 const TemplateArgument *TemplateArgs, 1168 unsigned NumTemplateArgs) { 1169 // <nested-name> ::= N [<CV-qualifiers>] <template-prefix> <template-args> E 1170 1171 Out << 'N'; 1172 1173 mangleTemplatePrefix(TD); 1174 TemplateParameterList *TemplateParameters = TD->getTemplateParameters(); 1175 mangleTemplateArgs(*TemplateParameters, TemplateArgs, NumTemplateArgs); 1176 1177 Out << 'E'; 1178} 1179 1180void CXXNameMangler::mangleLocalName(const NamedDecl *ND) { 1181 // <local-name> := Z <function encoding> E <entity name> [<discriminator>] 1182 // := Z <function encoding> E s [<discriminator>] 1183 // <discriminator> := _ <non-negative number> 1184 const DeclContext *DC = ND->getDeclContext(); 1185 if (isa<ObjCMethodDecl>(DC) && isa<FunctionDecl>(ND)) { 1186 // Don't add objc method name mangling to locally declared function 1187 mangleUnqualifiedName(ND); 1188 return; 1189 } 1190 1191 Out << 'Z'; 1192 1193 if (const ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(DC)) { 1194 mangleObjCMethodName(MD); 1195 } else if (const CXXRecordDecl *RD = GetLocalClassDecl(ND)) { 1196 mangleFunctionEncoding(cast<FunctionDecl>(RD->getDeclContext())); 1197 Out << 'E'; 1198 1199 // Mangle the name relative to the closest enclosing function. 1200 if (ND == RD) // equality ok because RD derived from ND above 1201 mangleUnqualifiedName(ND); 1202 else 1203 mangleNestedName(ND, DC, true /*NoFunction*/); 1204 1205 unsigned disc; 1206 if (Context.getNextDiscriminator(RD, disc)) { 1207 if (disc < 10) 1208 Out << '_' << disc; 1209 else 1210 Out << "__" << disc << '_'; 1211 } 1212 1213 return; 1214 } 1215 else 1216 mangleFunctionEncoding(cast<FunctionDecl>(DC)); 1217 1218 Out << 'E'; 1219 mangleUnqualifiedName(ND); 1220} 1221 1222void CXXNameMangler::manglePrefix(NestedNameSpecifier *qualifier) { 1223 switch (qualifier->getKind()) { 1224 case NestedNameSpecifier::Global: 1225 // nothing 1226 return; 1227 1228 case NestedNameSpecifier::Namespace: 1229 mangleName(qualifier->getAsNamespace()); 1230 return; 1231 1232 case NestedNameSpecifier::NamespaceAlias: 1233 mangleName(qualifier->getAsNamespaceAlias()->getNamespace()); 1234 return; 1235 1236 case NestedNameSpecifier::TypeSpec: 1237 case NestedNameSpecifier::TypeSpecWithTemplate: 1238 manglePrefix(QualType(qualifier->getAsType(), 0)); 1239 return; 1240 1241 case NestedNameSpecifier::Identifier: 1242 // Member expressions can have these without prefixes, but that 1243 // should end up in mangleUnresolvedPrefix instead. 1244 assert(qualifier->getPrefix()); 1245 manglePrefix(qualifier->getPrefix()); 1246 1247 mangleSourceName(qualifier->getAsIdentifier()); 1248 return; 1249 } 1250 1251 llvm_unreachable("unexpected nested name specifier"); 1252} 1253 1254void CXXNameMangler::manglePrefix(const DeclContext *DC, bool NoFunction) { 1255 // <prefix> ::= <prefix> <unqualified-name> 1256 // ::= <template-prefix> <template-args> 1257 // ::= <template-param> 1258 // ::= # empty 1259 // ::= <substitution> 1260 1261 while (isa<LinkageSpecDecl>(DC)) 1262 DC = DC->getParent(); 1263 1264 if (DC->isTranslationUnit()) 1265 return; 1266 1267 if (const BlockDecl *Block = dyn_cast<BlockDecl>(DC)) { 1268 manglePrefix(DC->getParent(), NoFunction); 1269 llvm::SmallString<64> Name; 1270 llvm::raw_svector_ostream NameStream(Name); 1271 Context.mangleBlock(Block, NameStream); 1272 NameStream.flush(); 1273 Out << Name.size() << Name; 1274 return; 1275 } 1276 1277 if (mangleSubstitution(cast<NamedDecl>(DC))) 1278 return; 1279 1280 // Check if we have a template. 1281 const TemplateArgumentList *TemplateArgs = 0; 1282 if (const TemplateDecl *TD = isTemplate(cast<NamedDecl>(DC), TemplateArgs)) { 1283 mangleTemplatePrefix(TD); 1284 TemplateParameterList *TemplateParameters = TD->getTemplateParameters(); 1285 mangleTemplateArgs(*TemplateParameters, *TemplateArgs); 1286 } 1287 else if(NoFunction && (isa<FunctionDecl>(DC) || isa<ObjCMethodDecl>(DC))) 1288 return; 1289 else if (const ObjCMethodDecl *Method = dyn_cast<ObjCMethodDecl>(DC)) 1290 mangleObjCMethodName(Method); 1291 else { 1292 manglePrefix(DC->getParent(), NoFunction); 1293 mangleUnqualifiedName(cast<NamedDecl>(DC)); 1294 } 1295 1296 addSubstitution(cast<NamedDecl>(DC)); 1297} 1298 1299void CXXNameMangler::mangleTemplatePrefix(TemplateName Template) { 1300 // <template-prefix> ::= <prefix> <template unqualified-name> 1301 // ::= <template-param> 1302 // ::= <substitution> 1303 if (TemplateDecl *TD = Template.getAsTemplateDecl()) 1304 return mangleTemplatePrefix(TD); 1305 1306 if (QualifiedTemplateName *Qualified = Template.getAsQualifiedTemplateName()) 1307 manglePrefix(Qualified->getQualifier()); 1308 1309 if (OverloadedTemplateStorage *Overloaded 1310 = Template.getAsOverloadedTemplate()) { 1311 mangleUnqualifiedName(0, (*Overloaded->begin())->getDeclName(), 1312 UnknownArity); 1313 return; 1314 } 1315 1316 DependentTemplateName *Dependent = Template.getAsDependentTemplateName(); 1317 assert(Dependent && "Unknown template name kind?"); 1318 manglePrefix(Dependent->getQualifier()); 1319 mangleUnscopedTemplateName(Template); 1320} 1321 1322void CXXNameMangler::mangleTemplatePrefix(const TemplateDecl *ND) { 1323 // <template-prefix> ::= <prefix> <template unqualified-name> 1324 // ::= <template-param> 1325 // ::= <substitution> 1326 // <template-template-param> ::= <template-param> 1327 // <substitution> 1328 1329 if (mangleSubstitution(ND)) 1330 return; 1331 1332 // <template-template-param> ::= <template-param> 1333 if (const TemplateTemplateParmDecl *TTP 1334 = dyn_cast<TemplateTemplateParmDecl>(ND)) { 1335 mangleTemplateParameter(TTP->getIndex()); 1336 return; 1337 } 1338 1339 manglePrefix(ND->getDeclContext()); 1340 mangleUnqualifiedName(ND->getTemplatedDecl()); 1341 addSubstitution(ND); 1342} 1343 1344/// Mangles a template name under the production <type>. Required for 1345/// template template arguments. 1346/// <type> ::= <class-enum-type> 1347/// ::= <template-param> 1348/// ::= <substitution> 1349void CXXNameMangler::mangleType(TemplateName TN) { 1350 if (mangleSubstitution(TN)) 1351 return; 1352 1353 TemplateDecl *TD = 0; 1354 1355 switch (TN.getKind()) { 1356 case TemplateName::QualifiedTemplate: 1357 TD = TN.getAsQualifiedTemplateName()->getTemplateDecl(); 1358 goto HaveDecl; 1359 1360 case TemplateName::Template: 1361 TD = TN.getAsTemplateDecl(); 1362 goto HaveDecl; 1363 1364 HaveDecl: 1365 if (isa<TemplateTemplateParmDecl>(TD)) 1366 mangleTemplateParameter(cast<TemplateTemplateParmDecl>(TD)->getIndex()); 1367 else 1368 mangleName(TD); 1369 break; 1370 1371 case TemplateName::OverloadedTemplate: 1372 llvm_unreachable("can't mangle an overloaded template name as a <type>"); 1373 break; 1374 1375 case TemplateName::DependentTemplate: { 1376 const DependentTemplateName *Dependent = TN.getAsDependentTemplateName(); 1377 assert(Dependent->isIdentifier()); 1378 1379 // <class-enum-type> ::= <name> 1380 // <name> ::= <nested-name> 1381 mangleUnresolvedPrefix(Dependent->getQualifier(), 0); 1382 mangleSourceName(Dependent->getIdentifier()); 1383 break; 1384 } 1385 1386 case TemplateName::SubstTemplateTemplateParm: { 1387 // Substituted template parameters are mangled as the substituted 1388 // template. This will check for the substitution twice, which is 1389 // fine, but we have to return early so that we don't try to *add* 1390 // the substitution twice. 1391 SubstTemplateTemplateParmStorage *subst 1392 = TN.getAsSubstTemplateTemplateParm(); 1393 mangleType(subst->getReplacement()); 1394 return; 1395 } 1396 1397 case TemplateName::SubstTemplateTemplateParmPack: { 1398 // FIXME: not clear how to mangle this! 1399 // template <template <class> class T...> class A { 1400 // template <template <class> class U...> void foo(B<T,U> x...); 1401 // }; 1402 Out << "_SUBSTPACK_"; 1403 break; 1404 } 1405 } 1406 1407 addSubstitution(TN); 1408} 1409 1410void 1411CXXNameMangler::mangleOperatorName(OverloadedOperatorKind OO, unsigned Arity) { 1412 switch (OO) { 1413 // <operator-name> ::= nw # new 1414 case OO_New: Out << "nw"; break; 1415 // ::= na # new[] 1416 case OO_Array_New: Out << "na"; break; 1417 // ::= dl # delete 1418 case OO_Delete: Out << "dl"; break; 1419 // ::= da # delete[] 1420 case OO_Array_Delete: Out << "da"; break; 1421 // ::= ps # + (unary) 1422 // ::= pl # + (binary or unknown) 1423 case OO_Plus: 1424 Out << (Arity == 1? "ps" : "pl"); break; 1425 // ::= ng # - (unary) 1426 // ::= mi # - (binary or unknown) 1427 case OO_Minus: 1428 Out << (Arity == 1? "ng" : "mi"); break; 1429 // ::= ad # & (unary) 1430 // ::= an # & (binary or unknown) 1431 case OO_Amp: 1432 Out << (Arity == 1? "ad" : "an"); break; 1433 // ::= de # * (unary) 1434 // ::= ml # * (binary or unknown) 1435 case OO_Star: 1436 // Use binary when unknown. 1437 Out << (Arity == 1? "de" : "ml"); break; 1438 // ::= co # ~ 1439 case OO_Tilde: Out << "co"; break; 1440 // ::= dv # / 1441 case OO_Slash: Out << "dv"; break; 1442 // ::= rm # % 1443 case OO_Percent: Out << "rm"; break; 1444 // ::= or # | 1445 case OO_Pipe: Out << "or"; break; 1446 // ::= eo # ^ 1447 case OO_Caret: Out << "eo"; break; 1448 // ::= aS # = 1449 case OO_Equal: Out << "aS"; break; 1450 // ::= pL # += 1451 case OO_PlusEqual: Out << "pL"; break; 1452 // ::= mI # -= 1453 case OO_MinusEqual: Out << "mI"; break; 1454 // ::= mL # *= 1455 case OO_StarEqual: Out << "mL"; break; 1456 // ::= dV # /= 1457 case OO_SlashEqual: Out << "dV"; break; 1458 // ::= rM # %= 1459 case OO_PercentEqual: Out << "rM"; break; 1460 // ::= aN # &= 1461 case OO_AmpEqual: Out << "aN"; break; 1462 // ::= oR # |= 1463 case OO_PipeEqual: Out << "oR"; break; 1464 // ::= eO # ^= 1465 case OO_CaretEqual: Out << "eO"; break; 1466 // ::= ls # << 1467 case OO_LessLess: Out << "ls"; break; 1468 // ::= rs # >> 1469 case OO_GreaterGreater: Out << "rs"; break; 1470 // ::= lS # <<= 1471 case OO_LessLessEqual: Out << "lS"; break; 1472 // ::= rS # >>= 1473 case OO_GreaterGreaterEqual: Out << "rS"; break; 1474 // ::= eq # == 1475 case OO_EqualEqual: Out << "eq"; break; 1476 // ::= ne # != 1477 case OO_ExclaimEqual: Out << "ne"; break; 1478 // ::= lt # < 1479 case OO_Less: Out << "lt"; break; 1480 // ::= gt # > 1481 case OO_Greater: Out << "gt"; break; 1482 // ::= le # <= 1483 case OO_LessEqual: Out << "le"; break; 1484 // ::= ge # >= 1485 case OO_GreaterEqual: Out << "ge"; break; 1486 // ::= nt # ! 1487 case OO_Exclaim: Out << "nt"; break; 1488 // ::= aa # && 1489 case OO_AmpAmp: Out << "aa"; break; 1490 // ::= oo # || 1491 case OO_PipePipe: Out << "oo"; break; 1492 // ::= pp # ++ 1493 case OO_PlusPlus: Out << "pp"; break; 1494 // ::= mm # -- 1495 case OO_MinusMinus: Out << "mm"; break; 1496 // ::= cm # , 1497 case OO_Comma: Out << "cm"; break; 1498 // ::= pm # ->* 1499 case OO_ArrowStar: Out << "pm"; break; 1500 // ::= pt # -> 1501 case OO_Arrow: Out << "pt"; break; 1502 // ::= cl # () 1503 case OO_Call: Out << "cl"; break; 1504 // ::= ix # [] 1505 case OO_Subscript: Out << "ix"; break; 1506 1507 // ::= qu # ? 1508 // The conditional operator can't be overloaded, but we still handle it when 1509 // mangling expressions. 1510 case OO_Conditional: Out << "qu"; break; 1511 1512 case OO_None: 1513 case NUM_OVERLOADED_OPERATORS: 1514 llvm_unreachable("Not an overloaded operator"); 1515 } 1516} 1517 1518void CXXNameMangler::mangleQualifiers(Qualifiers Quals) { 1519 // <CV-qualifiers> ::= [r] [V] [K] # restrict (C99), volatile, const 1520 if (Quals.hasRestrict()) 1521 Out << 'r'; 1522 if (Quals.hasVolatile()) 1523 Out << 'V'; 1524 if (Quals.hasConst()) 1525 Out << 'K'; 1526 1527 if (Quals.hasAddressSpace()) { 1528 // Extension: 1529 // 1530 // <type> ::= U <address-space-number> 1531 // 1532 // where <address-space-number> is a source name consisting of 'AS' 1533 // followed by the address space <number>. 1534 llvm::SmallString<64> ASString; 1535 ASString = "AS" + llvm::utostr_32(Quals.getAddressSpace()); 1536 Out << 'U' << ASString.size() << ASString; 1537 } 1538 1539 StringRef LifetimeName; 1540 switch (Quals.getObjCLifetime()) { 1541 // Objective-C ARC Extension: 1542 // 1543 // <type> ::= U "__strong" 1544 // <type> ::= U "__weak" 1545 // <type> ::= U "__autoreleasing" 1546 case Qualifiers::OCL_None: 1547 break; 1548 1549 case Qualifiers::OCL_Weak: 1550 LifetimeName = "__weak"; 1551 break; 1552 1553 case Qualifiers::OCL_Strong: 1554 LifetimeName = "__strong"; 1555 break; 1556 1557 case Qualifiers::OCL_Autoreleasing: 1558 LifetimeName = "__autoreleasing"; 1559 break; 1560 1561 case Qualifiers::OCL_ExplicitNone: 1562 // The __unsafe_unretained qualifier is *not* mangled, so that 1563 // __unsafe_unretained types in ARC produce the same manglings as the 1564 // equivalent (but, naturally, unqualified) types in non-ARC, providing 1565 // better ABI compatibility. 1566 // 1567 // It's safe to do this because unqualified 'id' won't show up 1568 // in any type signatures that need to be mangled. 1569 break; 1570 } 1571 if (!LifetimeName.empty()) 1572 Out << 'U' << LifetimeName.size() << LifetimeName; 1573} 1574 1575void CXXNameMangler::mangleRefQualifier(RefQualifierKind RefQualifier) { 1576 // <ref-qualifier> ::= R # lvalue reference 1577 // ::= O # rvalue-reference 1578 // Proposal to Itanium C++ ABI list on 1/26/11 1579 switch (RefQualifier) { 1580 case RQ_None: 1581 break; 1582 1583 case RQ_LValue: 1584 Out << 'R'; 1585 break; 1586 1587 case RQ_RValue: 1588 Out << 'O'; 1589 break; 1590 } 1591} 1592 1593void CXXNameMangler::mangleObjCMethodName(const ObjCMethodDecl *MD) { 1594 Context.mangleObjCMethodName(MD, Out); 1595} 1596 1597void CXXNameMangler::mangleType(QualType T) { 1598 // If our type is instantiation-dependent but not dependent, we mangle 1599 // it as it was written in the source, removing any top-level sugar. 1600 // Otherwise, use the canonical type. 1601 // 1602 // FIXME: This is an approximation of the instantiation-dependent name 1603 // mangling rules, since we should really be using the type as written and 1604 // augmented via semantic analysis (i.e., with implicit conversions and 1605 // default template arguments) for any instantiation-dependent type. 1606 // Unfortunately, that requires several changes to our AST: 1607 // - Instantiation-dependent TemplateSpecializationTypes will need to be 1608 // uniqued, so that we can handle substitutions properly 1609 // - Default template arguments will need to be represented in the 1610 // TemplateSpecializationType, since they need to be mangled even though 1611 // they aren't written. 1612 // - Conversions on non-type template arguments need to be expressed, since 1613 // they can affect the mangling of sizeof/alignof. 1614 if (!T->isInstantiationDependentType() || T->isDependentType()) 1615 T = T.getCanonicalType(); 1616 else { 1617 // Desugar any types that are purely sugar. 1618 do { 1619 // Don't desugar through template specialization types that aren't 1620 // type aliases. We need to mangle the template arguments as written. 1621 if (const TemplateSpecializationType *TST 1622 = dyn_cast<TemplateSpecializationType>(T)) 1623 if (!TST->isTypeAlias()) 1624 break; 1625 1626 QualType Desugared 1627 = T.getSingleStepDesugaredType(Context.getASTContext()); 1628 if (Desugared == T) 1629 break; 1630 1631 T = Desugared; 1632 } while (true); 1633 } 1634 SplitQualType split = T.split(); 1635 Qualifiers quals = split.second; 1636 const Type *ty = split.first; 1637 1638 bool isSubstitutable = quals || !isa<BuiltinType>(T); 1639 if (isSubstitutable && mangleSubstitution(T)) 1640 return; 1641 1642 // If we're mangling a qualified array type, push the qualifiers to 1643 // the element type. 1644 if (quals && isa<ArrayType>(T)) { 1645 ty = Context.getASTContext().getAsArrayType(T); 1646 quals = Qualifiers(); 1647 1648 // Note that we don't update T: we want to add the 1649 // substitution at the original type. 1650 } 1651 1652 if (quals) { 1653 mangleQualifiers(quals); 1654 // Recurse: even if the qualified type isn't yet substitutable, 1655 // the unqualified type might be. 1656 mangleType(QualType(ty, 0)); 1657 } else { 1658 switch (ty->getTypeClass()) { 1659#define ABSTRACT_TYPE(CLASS, PARENT) 1660#define NON_CANONICAL_TYPE(CLASS, PARENT) \ 1661 case Type::CLASS: \ 1662 llvm_unreachable("can't mangle non-canonical type " #CLASS "Type"); \ 1663 return; 1664#define TYPE(CLASS, PARENT) \ 1665 case Type::CLASS: \ 1666 mangleType(static_cast<const CLASS##Type*>(ty)); \ 1667 break; 1668#include "clang/AST/TypeNodes.def" 1669 } 1670 } 1671 1672 // Add the substitution. 1673 if (isSubstitutable) 1674 addSubstitution(T); 1675} 1676 1677void CXXNameMangler::mangleNameOrStandardSubstitution(const NamedDecl *ND) { 1678 if (!mangleStandardSubstitution(ND)) 1679 mangleName(ND); 1680} 1681 1682void CXXNameMangler::mangleType(const BuiltinType *T) { 1683 // <type> ::= <builtin-type> 1684 // <builtin-type> ::= v # void 1685 // ::= w # wchar_t 1686 // ::= b # bool 1687 // ::= c # char 1688 // ::= a # signed char 1689 // ::= h # unsigned char 1690 // ::= s # short 1691 // ::= t # unsigned short 1692 // ::= i # int 1693 // ::= j # unsigned int 1694 // ::= l # long 1695 // ::= m # unsigned long 1696 // ::= x # long long, __int64 1697 // ::= y # unsigned long long, __int64 1698 // ::= n # __int128 1699 // UNSUPPORTED: ::= o # unsigned __int128 1700 // ::= f # float 1701 // ::= d # double 1702 // ::= e # long double, __float80 1703 // UNSUPPORTED: ::= g # __float128 1704 // UNSUPPORTED: ::= Dd # IEEE 754r decimal floating point (64 bits) 1705 // UNSUPPORTED: ::= De # IEEE 754r decimal floating point (128 bits) 1706 // UNSUPPORTED: ::= Df # IEEE 754r decimal floating point (32 bits) 1707 // ::= Dh # IEEE 754r half-precision floating point (16 bits) 1708 // ::= Di # char32_t 1709 // ::= Ds # char16_t 1710 // ::= Dn # std::nullptr_t (i.e., decltype(nullptr)) 1711 // ::= u <source-name> # vendor extended type 1712 switch (T->getKind()) { 1713 case BuiltinType::Void: Out << 'v'; break; 1714 case BuiltinType::Bool: Out << 'b'; break; 1715 case BuiltinType::Char_U: case BuiltinType::Char_S: Out << 'c'; break; 1716 case BuiltinType::UChar: Out << 'h'; break; 1717 case BuiltinType::UShort: Out << 't'; break; 1718 case BuiltinType::UInt: Out << 'j'; break; 1719 case BuiltinType::ULong: Out << 'm'; break; 1720 case BuiltinType::ULongLong: Out << 'y'; break; 1721 case BuiltinType::UInt128: Out << 'o'; break; 1722 case BuiltinType::SChar: Out << 'a'; break; 1723 case BuiltinType::WChar_S: 1724 case BuiltinType::WChar_U: Out << 'w'; break; 1725 case BuiltinType::Char16: Out << "Ds"; break; 1726 case BuiltinType::Char32: Out << "Di"; break; 1727 case BuiltinType::Short: Out << 's'; break; 1728 case BuiltinType::Int: Out << 'i'; break; 1729 case BuiltinType::Long: Out << 'l'; break; 1730 case BuiltinType::LongLong: Out << 'x'; break; 1731 case BuiltinType::Int128: Out << 'n'; break; 1732 case BuiltinType::Half: Out << "Dh"; break; 1733 case BuiltinType::Float: Out << 'f'; break; 1734 case BuiltinType::Double: Out << 'd'; break; 1735 case BuiltinType::LongDouble: Out << 'e'; break; 1736 case BuiltinType::NullPtr: Out << "Dn"; break; 1737 1738 case BuiltinType::Overload: 1739 case BuiltinType::Dependent: 1740 case BuiltinType::BoundMember: 1741 case BuiltinType::UnknownAny: 1742 llvm_unreachable("mangling a placeholder type"); 1743 break; 1744 case BuiltinType::ObjCId: Out << "11objc_object"; break; 1745 case BuiltinType::ObjCClass: Out << "10objc_class"; break; 1746 case BuiltinType::ObjCSel: Out << "13objc_selector"; break; 1747 } 1748} 1749 1750// <type> ::= <function-type> 1751// <function-type> ::= F [Y] <bare-function-type> E 1752void CXXNameMangler::mangleType(const FunctionProtoType *T) { 1753 Out << 'F'; 1754 // FIXME: We don't have enough information in the AST to produce the 'Y' 1755 // encoding for extern "C" function types. 1756 mangleBareFunctionType(T, /*MangleReturnType=*/true); 1757 Out << 'E'; 1758} 1759void CXXNameMangler::mangleType(const FunctionNoProtoType *T) { 1760 llvm_unreachable("Can't mangle K&R function prototypes"); 1761} 1762void CXXNameMangler::mangleBareFunctionType(const FunctionType *T, 1763 bool MangleReturnType) { 1764 // We should never be mangling something without a prototype. 1765 const FunctionProtoType *Proto = cast<FunctionProtoType>(T); 1766 1767 // Record that we're in a function type. See mangleFunctionParam 1768 // for details on what we're trying to achieve here. 1769 FunctionTypeDepthState saved = FunctionTypeDepth.push(); 1770 1771 // <bare-function-type> ::= <signature type>+ 1772 if (MangleReturnType) { 1773 FunctionTypeDepth.enterResultType(); 1774 mangleType(Proto->getResultType()); 1775 FunctionTypeDepth.leaveResultType(); 1776 } 1777 1778 if (Proto->getNumArgs() == 0 && !Proto->isVariadic()) { 1779 // <builtin-type> ::= v # void 1780 Out << 'v'; 1781 1782 FunctionTypeDepth.pop(saved); 1783 return; 1784 } 1785 1786 for (FunctionProtoType::arg_type_iterator Arg = Proto->arg_type_begin(), 1787 ArgEnd = Proto->arg_type_end(); 1788 Arg != ArgEnd; ++Arg) 1789 mangleType(Context.getASTContext().getSignatureParameterType(*Arg)); 1790 1791 FunctionTypeDepth.pop(saved); 1792 1793 // <builtin-type> ::= z # ellipsis 1794 if (Proto->isVariadic()) 1795 Out << 'z'; 1796} 1797 1798// <type> ::= <class-enum-type> 1799// <class-enum-type> ::= <name> 1800void CXXNameMangler::mangleType(const UnresolvedUsingType *T) { 1801 mangleName(T->getDecl()); 1802} 1803 1804// <type> ::= <class-enum-type> 1805// <class-enum-type> ::= <name> 1806void CXXNameMangler::mangleType(const EnumType *T) { 1807 mangleType(static_cast<const TagType*>(T)); 1808} 1809void CXXNameMangler::mangleType(const RecordType *T) { 1810 mangleType(static_cast<const TagType*>(T)); 1811} 1812void CXXNameMangler::mangleType(const TagType *T) { 1813 mangleName(T->getDecl()); 1814} 1815 1816// <type> ::= <array-type> 1817// <array-type> ::= A <positive dimension number> _ <element type> 1818// ::= A [<dimension expression>] _ <element type> 1819void CXXNameMangler::mangleType(const ConstantArrayType *T) { 1820 Out << 'A' << T->getSize() << '_'; 1821 mangleType(T->getElementType()); 1822} 1823void CXXNameMangler::mangleType(const VariableArrayType *T) { 1824 Out << 'A'; 1825 // decayed vla types (size 0) will just be skipped. 1826 if (T->getSizeExpr()) 1827 mangleExpression(T->getSizeExpr()); 1828 Out << '_'; 1829 mangleType(T->getElementType()); 1830} 1831void CXXNameMangler::mangleType(const DependentSizedArrayType *T) { 1832 Out << 'A'; 1833 mangleExpression(T->getSizeExpr()); 1834 Out << '_'; 1835 mangleType(T->getElementType()); 1836} 1837void CXXNameMangler::mangleType(const IncompleteArrayType *T) { 1838 Out << "A_"; 1839 mangleType(T->getElementType()); 1840} 1841 1842// <type> ::= <pointer-to-member-type> 1843// <pointer-to-member-type> ::= M <class type> <member type> 1844void CXXNameMangler::mangleType(const MemberPointerType *T) { 1845 Out << 'M'; 1846 mangleType(QualType(T->getClass(), 0)); 1847 QualType PointeeType = T->getPointeeType(); 1848 if (const FunctionProtoType *FPT = dyn_cast<FunctionProtoType>(PointeeType)) { 1849 mangleQualifiers(Qualifiers::fromCVRMask(FPT->getTypeQuals())); 1850 mangleRefQualifier(FPT->getRefQualifier()); 1851 mangleType(FPT); 1852 1853 // Itanium C++ ABI 5.1.8: 1854 // 1855 // The type of a non-static member function is considered to be different, 1856 // for the purposes of substitution, from the type of a namespace-scope or 1857 // static member function whose type appears similar. The types of two 1858 // non-static member functions are considered to be different, for the 1859 // purposes of substitution, if the functions are members of different 1860 // classes. In other words, for the purposes of substitution, the class of 1861 // which the function is a member is considered part of the type of 1862 // function. 1863 1864 // We increment the SeqID here to emulate adding an entry to the 1865 // substitution table. We can't actually add it because we don't want this 1866 // particular function type to be substituted. 1867 ++SeqID; 1868 } else 1869 mangleType(PointeeType); 1870} 1871 1872// <type> ::= <template-param> 1873void CXXNameMangler::mangleType(const TemplateTypeParmType *T) { 1874 mangleTemplateParameter(T->getIndex()); 1875} 1876 1877// <type> ::= <template-param> 1878void CXXNameMangler::mangleType(const SubstTemplateTypeParmPackType *T) { 1879 // FIXME: not clear how to mangle this! 1880 // template <class T...> class A { 1881 // template <class U...> void foo(T(*)(U) x...); 1882 // }; 1883 Out << "_SUBSTPACK_"; 1884} 1885 1886// <type> ::= P <type> # pointer-to 1887void CXXNameMangler::mangleType(const PointerType *T) { 1888 Out << 'P'; 1889 mangleType(T->getPointeeType()); 1890} 1891void CXXNameMangler::mangleType(const ObjCObjectPointerType *T) { 1892 Out << 'P'; 1893 mangleType(T->getPointeeType()); 1894} 1895 1896// <type> ::= R <type> # reference-to 1897void CXXNameMangler::mangleType(const LValueReferenceType *T) { 1898 Out << 'R'; 1899 mangleType(T->getPointeeType()); 1900} 1901 1902// <type> ::= O <type> # rvalue reference-to (C++0x) 1903void CXXNameMangler::mangleType(const RValueReferenceType *T) { 1904 Out << 'O'; 1905 mangleType(T->getPointeeType()); 1906} 1907 1908// <type> ::= C <type> # complex pair (C 2000) 1909void CXXNameMangler::mangleType(const ComplexType *T) { 1910 Out << 'C'; 1911 mangleType(T->getElementType()); 1912} 1913 1914// ARM's ABI for Neon vector types specifies that they should be mangled as 1915// if they are structs (to match ARM's initial implementation). The 1916// vector type must be one of the special types predefined by ARM. 1917void CXXNameMangler::mangleNeonVectorType(const VectorType *T) { 1918 QualType EltType = T->getElementType(); 1919 assert(EltType->isBuiltinType() && "Neon vector element not a BuiltinType"); 1920 const char *EltName = 0; 1921 if (T->getVectorKind() == VectorType::NeonPolyVector) { 1922 switch (cast<BuiltinType>(EltType)->getKind()) { 1923 case BuiltinType::SChar: EltName = "poly8_t"; break; 1924 case BuiltinType::Short: EltName = "poly16_t"; break; 1925 default: llvm_unreachable("unexpected Neon polynomial vector element type"); 1926 } 1927 } else { 1928 switch (cast<BuiltinType>(EltType)->getKind()) { 1929 case BuiltinType::SChar: EltName = "int8_t"; break; 1930 case BuiltinType::UChar: EltName = "uint8_t"; break; 1931 case BuiltinType::Short: EltName = "int16_t"; break; 1932 case BuiltinType::UShort: EltName = "uint16_t"; break; 1933 case BuiltinType::Int: EltName = "int32_t"; break; 1934 case BuiltinType::UInt: EltName = "uint32_t"; break; 1935 case BuiltinType::LongLong: EltName = "int64_t"; break; 1936 case BuiltinType::ULongLong: EltName = "uint64_t"; break; 1937 case BuiltinType::Float: EltName = "float32_t"; break; 1938 default: llvm_unreachable("unexpected Neon vector element type"); 1939 } 1940 } 1941 const char *BaseName = 0; 1942 unsigned BitSize = (T->getNumElements() * 1943 getASTContext().getTypeSize(EltType)); 1944 if (BitSize == 64) 1945 BaseName = "__simd64_"; 1946 else { 1947 assert(BitSize == 128 && "Neon vector type not 64 or 128 bits"); 1948 BaseName = "__simd128_"; 1949 } 1950 Out << strlen(BaseName) + strlen(EltName); 1951 Out << BaseName << EltName; 1952} 1953 1954// GNU extension: vector types 1955// <type> ::= <vector-type> 1956// <vector-type> ::= Dv <positive dimension number> _ 1957// <extended element type> 1958// ::= Dv [<dimension expression>] _ <element type> 1959// <extended element type> ::= <element type> 1960// ::= p # AltiVec vector pixel 1961void CXXNameMangler::mangleType(const VectorType *T) { 1962 if ((T->getVectorKind() == VectorType::NeonVector || 1963 T->getVectorKind() == VectorType::NeonPolyVector)) { 1964 mangleNeonVectorType(T); 1965 return; 1966 } 1967 Out << "Dv" << T->getNumElements() << '_'; 1968 if (T->getVectorKind() == VectorType::AltiVecPixel) 1969 Out << 'p'; 1970 else if (T->getVectorKind() == VectorType::AltiVecBool) 1971 Out << 'b'; 1972 else 1973 mangleType(T->getElementType()); 1974} 1975void CXXNameMangler::mangleType(const ExtVectorType *T) { 1976 mangleType(static_cast<const VectorType*>(T)); 1977} 1978void CXXNameMangler::mangleType(const DependentSizedExtVectorType *T) { 1979 Out << "Dv"; 1980 mangleExpression(T->getSizeExpr()); 1981 Out << '_'; 1982 mangleType(T->getElementType()); 1983} 1984 1985void CXXNameMangler::mangleType(const PackExpansionType *T) { 1986 // <type> ::= Dp <type> # pack expansion (C++0x) 1987 Out << "Dp"; 1988 mangleType(T->getPattern()); 1989} 1990 1991void CXXNameMangler::mangleType(const ObjCInterfaceType *T) { 1992 mangleSourceName(T->getDecl()->getIdentifier()); 1993} 1994 1995void CXXNameMangler::mangleType(const ObjCObjectType *T) { 1996 // We don't allow overloading by different protocol qualification, 1997 // so mangling them isn't necessary. 1998 mangleType(T->getBaseType()); 1999} 2000 2001void CXXNameMangler::mangleType(const BlockPointerType *T) { 2002 Out << "U13block_pointer"; 2003 mangleType(T->getPointeeType()); 2004} 2005 2006void CXXNameMangler::mangleType(const InjectedClassNameType *T) { 2007 // Mangle injected class name types as if the user had written the 2008 // specialization out fully. It may not actually be possible to see 2009 // this mangling, though. 2010 mangleType(T->getInjectedSpecializationType()); 2011} 2012 2013void CXXNameMangler::mangleType(const TemplateSpecializationType *T) { 2014 if (TemplateDecl *TD = T->getTemplateName().getAsTemplateDecl()) { 2015 mangleName(TD, T->getArgs(), T->getNumArgs()); 2016 } else { 2017 if (mangleSubstitution(QualType(T, 0))) 2018 return; 2019 2020 mangleTemplatePrefix(T->getTemplateName()); 2021 2022 // FIXME: GCC does not appear to mangle the template arguments when 2023 // the template in question is a dependent template name. Should we 2024 // emulate that badness? 2025 mangleTemplateArgs(T->getTemplateName(), T->getArgs(), T->getNumArgs()); 2026 addSubstitution(QualType(T, 0)); 2027 } 2028} 2029 2030void CXXNameMangler::mangleType(const DependentNameType *T) { 2031 // Typename types are always nested 2032 Out << 'N'; 2033 manglePrefix(T->getQualifier()); 2034 mangleSourceName(T->getIdentifier()); 2035 Out << 'E'; 2036} 2037 2038void CXXNameMangler::mangleType(const DependentTemplateSpecializationType *T) { 2039 // Dependently-scoped template types are nested if they have a prefix. 2040 Out << 'N'; 2041 2042 // TODO: avoid making this TemplateName. 2043 TemplateName Prefix = 2044 getASTContext().getDependentTemplateName(T->getQualifier(), 2045 T->getIdentifier()); 2046 mangleTemplatePrefix(Prefix); 2047 2048 // FIXME: GCC does not appear to mangle the template arguments when 2049 // the template in question is a dependent template name. Should we 2050 // emulate that badness? 2051 mangleTemplateArgs(Prefix, T->getArgs(), T->getNumArgs()); 2052 Out << 'E'; 2053} 2054 2055void CXXNameMangler::mangleType(const TypeOfType *T) { 2056 // FIXME: this is pretty unsatisfactory, but there isn't an obvious 2057 // "extension with parameters" mangling. 2058 Out << "u6typeof"; 2059} 2060 2061void CXXNameMangler::mangleType(const TypeOfExprType *T) { 2062 // FIXME: this is pretty unsatisfactory, but there isn't an obvious 2063 // "extension with parameters" mangling. 2064 Out << "u6typeof"; 2065} 2066 2067void CXXNameMangler::mangleType(const DecltypeType *T) { 2068 Expr *E = T->getUnderlyingExpr(); 2069 2070 // type ::= Dt <expression> E # decltype of an id-expression 2071 // # or class member access 2072 // ::= DT <expression> E # decltype of an expression 2073 2074 // This purports to be an exhaustive list of id-expressions and 2075 // class member accesses. Note that we do not ignore parentheses; 2076 // parentheses change the semantics of decltype for these 2077 // expressions (and cause the mangler to use the other form). 2078 if (isa<DeclRefExpr>(E) || 2079 isa<MemberExpr>(E) || 2080 isa<UnresolvedLookupExpr>(E) || 2081 isa<DependentScopeDeclRefExpr>(E) || 2082 isa<CXXDependentScopeMemberExpr>(E) || 2083 isa<UnresolvedMemberExpr>(E)) 2084 Out << "Dt"; 2085 else 2086 Out << "DT"; 2087 mangleExpression(E); 2088 Out << 'E'; 2089} 2090 2091void CXXNameMangler::mangleType(const UnaryTransformType *T) { 2092 // If this is dependent, we need to record that. If not, we simply 2093 // mangle it as the underlying type since they are equivalent. 2094 if (T->isDependentType()) { 2095 Out << 'U'; 2096 2097 switch (T->getUTTKind()) { 2098 case UnaryTransformType::EnumUnderlyingType: 2099 Out << "3eut"; 2100 break; 2101 } 2102 } 2103 2104 mangleType(T->getUnderlyingType()); 2105} 2106 2107void CXXNameMangler::mangleType(const AutoType *T) { 2108 QualType D = T->getDeducedType(); 2109 // <builtin-type> ::= Da # dependent auto 2110 if (D.isNull()) 2111 Out << "Da"; 2112 else 2113 mangleType(D); 2114} 2115 2116void CXXNameMangler::mangleType(const AtomicType *T) { 2117 // <type> ::= U <source-name> <type> # vendor extended type qualifier 2118 // (Until there's a standardized mangling...) 2119 Out << "U7_Atomic"; 2120 mangleType(T->getValueType()); 2121} 2122 2123void CXXNameMangler::mangleIntegerLiteral(QualType T, 2124 const llvm::APSInt &Value) { 2125 // <expr-primary> ::= L <type> <value number> E # integer literal 2126 Out << 'L'; 2127 2128 mangleType(T); 2129 if (T->isBooleanType()) { 2130 // Boolean values are encoded as 0/1. 2131 Out << (Value.getBoolValue() ? '1' : '0'); 2132 } else { 2133 mangleNumber(Value); 2134 } 2135 Out << 'E'; 2136 2137} 2138 2139/// Mangles a member expression. Implicit accesses are not handled, 2140/// but that should be okay, because you shouldn't be able to 2141/// make an implicit access in a function template declaration. 2142void CXXNameMangler::mangleMemberExpr(const Expr *base, 2143 bool isArrow, 2144 NestedNameSpecifier *qualifier, 2145 NamedDecl *firstQualifierLookup, 2146 DeclarationName member, 2147 unsigned arity) { 2148 // <expression> ::= dt <expression> <unresolved-name> 2149 // ::= pt <expression> <unresolved-name> 2150 Out << (isArrow ? "pt" : "dt"); 2151 mangleExpression(base); 2152 mangleUnresolvedName(qualifier, firstQualifierLookup, member, arity); 2153} 2154 2155/// Look at the callee of the given call expression and determine if 2156/// it's a parenthesized id-expression which would have triggered ADL 2157/// otherwise. 2158static bool isParenthesizedADLCallee(const CallExpr *call) { 2159 const Expr *callee = call->getCallee(); 2160 const Expr *fn = callee->IgnoreParens(); 2161 2162 // Must be parenthesized. IgnoreParens() skips __extension__ nodes, 2163 // too, but for those to appear in the callee, it would have to be 2164 // parenthesized. 2165 if (callee == fn) return false; 2166 2167 // Must be an unresolved lookup. 2168 const UnresolvedLookupExpr *lookup = dyn_cast<UnresolvedLookupExpr>(fn); 2169 if (!lookup) return false; 2170 2171 assert(!lookup->requiresADL()); 2172 2173 // Must be an unqualified lookup. 2174 if (lookup->getQualifier()) return false; 2175 2176 // Must not have found a class member. Note that if one is a class 2177 // member, they're all class members. 2178 if (lookup->getNumDecls() > 0 && 2179 (*lookup->decls_begin())->isCXXClassMember()) 2180 return false; 2181 2182 // Otherwise, ADL would have been triggered. 2183 return true; 2184} 2185 2186void CXXNameMangler::mangleExpression(const Expr *E, unsigned Arity) { 2187 // <expression> ::= <unary operator-name> <expression> 2188 // ::= <binary operator-name> <expression> <expression> 2189 // ::= <trinary operator-name> <expression> <expression> <expression> 2190 // ::= cv <type> expression # conversion with one argument 2191 // ::= cv <type> _ <expression>* E # conversion with a different number of arguments 2192 // ::= st <type> # sizeof (a type) 2193 // ::= at <type> # alignof (a type) 2194 // ::= <template-param> 2195 // ::= <function-param> 2196 // ::= sr <type> <unqualified-name> # dependent name 2197 // ::= sr <type> <unqualified-name> <template-args> # dependent template-id 2198 // ::= ds <expression> <expression> # expr.*expr 2199 // ::= sZ <template-param> # size of a parameter pack 2200 // ::= sZ <function-param> # size of a function parameter pack 2201 // ::= <expr-primary> 2202 // <expr-primary> ::= L <type> <value number> E # integer literal 2203 // ::= L <type <value float> E # floating literal 2204 // ::= L <mangled-name> E # external name 2205 QualType ImplicitlyConvertedToType; 2206 2207recurse: 2208 switch (E->getStmtClass()) { 2209 case Expr::NoStmtClass: 2210#define ABSTRACT_STMT(Type) 2211#define EXPR(Type, Base) 2212#define STMT(Type, Base) \ 2213 case Expr::Type##Class: 2214#include "clang/AST/StmtNodes.inc" 2215 // fallthrough 2216 2217 // These all can only appear in local or variable-initialization 2218 // contexts and so should never appear in a mangling. 2219 case Expr::AddrLabelExprClass: 2220 case Expr::BlockDeclRefExprClass: 2221 case Expr::CXXThisExprClass: 2222 case Expr::DesignatedInitExprClass: 2223 case Expr::ImplicitValueInitExprClass: 2224 case Expr::InitListExprClass: 2225 case Expr::ParenListExprClass: 2226 case Expr::CXXScalarValueInitExprClass: 2227 llvm_unreachable("unexpected statement kind"); 2228 break; 2229 2230 // FIXME: invent manglings for all these. 2231 case Expr::BlockExprClass: 2232 case Expr::CXXPseudoDestructorExprClass: 2233 case Expr::ChooseExprClass: 2234 case Expr::CompoundLiteralExprClass: 2235 case Expr::ExtVectorElementExprClass: 2236 case Expr::GenericSelectionExprClass: 2237 case Expr::ObjCEncodeExprClass: 2238 case Expr::ObjCIsaExprClass: 2239 case Expr::ObjCIvarRefExprClass: 2240 case Expr::ObjCMessageExprClass: 2241 case Expr::ObjCPropertyRefExprClass: 2242 case Expr::ObjCProtocolExprClass: 2243 case Expr::ObjCSelectorExprClass: 2244 case Expr::ObjCStringLiteralClass: 2245 case Expr::ObjCIndirectCopyRestoreExprClass: 2246 case Expr::OffsetOfExprClass: 2247 case Expr::PredefinedExprClass: 2248 case Expr::ShuffleVectorExprClass: 2249 case Expr::StmtExprClass: 2250 case Expr::UnaryTypeTraitExprClass: 2251 case Expr::BinaryTypeTraitExprClass: 2252 case Expr::ArrayTypeTraitExprClass: 2253 case Expr::ExpressionTraitExprClass: 2254 case Expr::VAArgExprClass: 2255 case Expr::CXXUuidofExprClass: 2256 case Expr::CXXNoexceptExprClass: 2257 case Expr::CUDAKernelCallExprClass: 2258 case Expr::AsTypeExprClass: 2259 case Expr::AtomicExprClass: 2260 { 2261 // As bad as this diagnostic is, it's better than crashing. 2262 DiagnosticsEngine &Diags = Context.getDiags(); 2263 unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error, 2264 "cannot yet mangle expression type %0"); 2265 Diags.Report(E->getExprLoc(), DiagID) 2266 << E->getStmtClassName() << E->getSourceRange(); 2267 break; 2268 } 2269 2270 // Even gcc-4.5 doesn't mangle this. 2271 case Expr::BinaryConditionalOperatorClass: { 2272 DiagnosticsEngine &Diags = Context.getDiags(); 2273 unsigned DiagID = 2274 Diags.getCustomDiagID(DiagnosticsEngine::Error, 2275 "?: operator with omitted middle operand cannot be mangled"); 2276 Diags.Report(E->getExprLoc(), DiagID) 2277 << E->getStmtClassName() << E->getSourceRange(); 2278 break; 2279 } 2280 2281 // These are used for internal purposes and cannot be meaningfully mangled. 2282 case Expr::OpaqueValueExprClass: 2283 llvm_unreachable("cannot mangle opaque value; mangling wrong thing?"); 2284 2285 case Expr::CXXDefaultArgExprClass: 2286 mangleExpression(cast<CXXDefaultArgExpr>(E)->getExpr(), Arity); 2287 break; 2288 2289 case Expr::SubstNonTypeTemplateParmExprClass: 2290 mangleExpression(cast<SubstNonTypeTemplateParmExpr>(E)->getReplacement(), 2291 Arity); 2292 break; 2293 2294 case Expr::CXXMemberCallExprClass: // fallthrough 2295 case Expr::CallExprClass: { 2296 const CallExpr *CE = cast<CallExpr>(E); 2297 2298 // <expression> ::= cp <simple-id> <expression>* E 2299 // We use this mangling only when the call would use ADL except 2300 // for being parenthesized. Per discussion with David 2301 // Vandervoorde, 2011.04.25. 2302 if (isParenthesizedADLCallee(CE)) { 2303 Out << "cp"; 2304 // The callee here is a parenthesized UnresolvedLookupExpr with 2305 // no qualifier and should always get mangled as a <simple-id> 2306 // anyway. 2307 2308 // <expression> ::= cl <expression>* E 2309 } else { 2310 Out << "cl"; 2311 } 2312 2313 mangleExpression(CE->getCallee(), CE->getNumArgs()); 2314 for (unsigned I = 0, N = CE->getNumArgs(); I != N; ++I) 2315 mangleExpression(CE->getArg(I)); 2316 Out << 'E'; 2317 break; 2318 } 2319 2320 case Expr::CXXNewExprClass: { 2321 // Proposal from David Vandervoorde, 2010.06.30 2322 const CXXNewExpr *New = cast<CXXNewExpr>(E); 2323 if (New->isGlobalNew()) Out << "gs"; 2324 Out << (New->isArray() ? "na" : "nw"); 2325 for (CXXNewExpr::const_arg_iterator I = New->placement_arg_begin(), 2326 E = New->placement_arg_end(); I != E; ++I) 2327 mangleExpression(*I); 2328 Out << '_'; 2329 mangleType(New->getAllocatedType()); 2330 if (New->hasInitializer()) { 2331 Out << "pi"; 2332 for (CXXNewExpr::const_arg_iterator I = New->constructor_arg_begin(), 2333 E = New->constructor_arg_end(); I != E; ++I) 2334 mangleExpression(*I); 2335 } 2336 Out << 'E'; 2337 break; 2338 } 2339 2340 case Expr::MemberExprClass: { 2341 const MemberExpr *ME = cast<MemberExpr>(E); 2342 mangleMemberExpr(ME->getBase(), ME->isArrow(), 2343 ME->getQualifier(), 0, ME->getMemberDecl()->getDeclName(), 2344 Arity); 2345 break; 2346 } 2347 2348 case Expr::UnresolvedMemberExprClass: { 2349 const UnresolvedMemberExpr *ME = cast<UnresolvedMemberExpr>(E); 2350 mangleMemberExpr(ME->getBase(), ME->isArrow(), 2351 ME->getQualifier(), 0, ME->getMemberName(), 2352 Arity); 2353 if (ME->hasExplicitTemplateArgs()) 2354 mangleTemplateArgs(ME->getExplicitTemplateArgs()); 2355 break; 2356 } 2357 2358 case Expr::CXXDependentScopeMemberExprClass: { 2359 const CXXDependentScopeMemberExpr *ME 2360 = cast<CXXDependentScopeMemberExpr>(E); 2361 mangleMemberExpr(ME->getBase(), ME->isArrow(), 2362 ME->getQualifier(), ME->getFirstQualifierFoundInScope(), 2363 ME->getMember(), Arity); 2364 if (ME->hasExplicitTemplateArgs()) 2365 mangleTemplateArgs(ME->getExplicitTemplateArgs()); 2366 break; 2367 } 2368 2369 case Expr::UnresolvedLookupExprClass: { 2370 const UnresolvedLookupExpr *ULE = cast<UnresolvedLookupExpr>(E); 2371 mangleUnresolvedName(ULE->getQualifier(), 0, ULE->getName(), Arity); 2372 2373 // All the <unresolved-name> productions end in a 2374 // base-unresolved-name, where <template-args> are just tacked 2375 // onto the end. 2376 if (ULE->hasExplicitTemplateArgs()) 2377 mangleTemplateArgs(ULE->getExplicitTemplateArgs()); 2378 break; 2379 } 2380 2381 case Expr::CXXUnresolvedConstructExprClass: { 2382 const CXXUnresolvedConstructExpr *CE = cast<CXXUnresolvedConstructExpr>(E); 2383 unsigned N = CE->arg_size(); 2384 2385 Out << "cv"; 2386 mangleType(CE->getType()); 2387 if (N != 1) Out << '_'; 2388 for (unsigned I = 0; I != N; ++I) mangleExpression(CE->getArg(I)); 2389 if (N != 1) Out << 'E'; 2390 break; 2391 } 2392 2393 case Expr::CXXTemporaryObjectExprClass: 2394 case Expr::CXXConstructExprClass: { 2395 const CXXConstructExpr *CE = cast<CXXConstructExpr>(E); 2396 unsigned N = CE->getNumArgs(); 2397 2398 Out << "cv"; 2399 mangleType(CE->getType()); 2400 if (N != 1) Out << '_'; 2401 for (unsigned I = 0; I != N; ++I) mangleExpression(CE->getArg(I)); 2402 if (N != 1) Out << 'E'; 2403 break; 2404 } 2405 2406 case Expr::UnaryExprOrTypeTraitExprClass: { 2407 const UnaryExprOrTypeTraitExpr *SAE = cast<UnaryExprOrTypeTraitExpr>(E); 2408 2409 if (!SAE->isInstantiationDependent()) { 2410 // Itanium C++ ABI: 2411 // If the operand of a sizeof or alignof operator is not 2412 // instantiation-dependent it is encoded as an integer literal 2413 // reflecting the result of the operator. 2414 // 2415 // If the result of the operator is implicitly converted to a known 2416 // integer type, that type is used for the literal; otherwise, the type 2417 // of std::size_t or std::ptrdiff_t is used. 2418 QualType T = (ImplicitlyConvertedToType.isNull() || 2419 !ImplicitlyConvertedToType->isIntegerType())? SAE->getType() 2420 : ImplicitlyConvertedToType; 2421 llvm::APSInt V = SAE->EvaluateKnownConstInt(Context.getASTContext()); 2422 mangleIntegerLiteral(T, V); 2423 break; 2424 } 2425 2426 switch(SAE->getKind()) { 2427 case UETT_SizeOf: 2428 Out << 's'; 2429 break; 2430 case UETT_AlignOf: 2431 Out << 'a'; 2432 break; 2433 case UETT_VecStep: 2434 DiagnosticsEngine &Diags = Context.getDiags(); 2435 unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error, 2436 "cannot yet mangle vec_step expression"); 2437 Diags.Report(DiagID); 2438 return; 2439 } 2440 if (SAE->isArgumentType()) { 2441 Out << 't'; 2442 mangleType(SAE->getArgumentType()); 2443 } else { 2444 Out << 'z'; 2445 mangleExpression(SAE->getArgumentExpr()); 2446 } 2447 break; 2448 } 2449 2450 case Expr::CXXThrowExprClass: { 2451 const CXXThrowExpr *TE = cast<CXXThrowExpr>(E); 2452 2453 // Proposal from David Vandervoorde, 2010.06.30 2454 if (TE->getSubExpr()) { 2455 Out << "tw"; 2456 mangleExpression(TE->getSubExpr()); 2457 } else { 2458 Out << "tr"; 2459 } 2460 break; 2461 } 2462 2463 case Expr::CXXTypeidExprClass: { 2464 const CXXTypeidExpr *TIE = cast<CXXTypeidExpr>(E); 2465 2466 // Proposal from David Vandervoorde, 2010.06.30 2467 if (TIE->isTypeOperand()) { 2468 Out << "ti"; 2469 mangleType(TIE->getTypeOperand()); 2470 } else { 2471 Out << "te"; 2472 mangleExpression(TIE->getExprOperand()); 2473 } 2474 break; 2475 } 2476 2477 case Expr::CXXDeleteExprClass: { 2478 const CXXDeleteExpr *DE = cast<CXXDeleteExpr>(E); 2479 2480 // Proposal from David Vandervoorde, 2010.06.30 2481 if (DE->isGlobalDelete()) Out << "gs"; 2482 Out << (DE->isArrayForm() ? "da" : "dl"); 2483 mangleExpression(DE->getArgument()); 2484 break; 2485 } 2486 2487 case Expr::UnaryOperatorClass: { 2488 const UnaryOperator *UO = cast<UnaryOperator>(E); 2489 mangleOperatorName(UnaryOperator::getOverloadedOperator(UO->getOpcode()), 2490 /*Arity=*/1); 2491 mangleExpression(UO->getSubExpr()); 2492 break; 2493 } 2494 2495 case Expr::ArraySubscriptExprClass: { 2496 const ArraySubscriptExpr *AE = cast<ArraySubscriptExpr>(E); 2497 2498 // Array subscript is treated as a syntactically weird form of 2499 // binary operator. 2500 Out << "ix"; 2501 mangleExpression(AE->getLHS()); 2502 mangleExpression(AE->getRHS()); 2503 break; 2504 } 2505 2506 case Expr::CompoundAssignOperatorClass: // fallthrough 2507 case Expr::BinaryOperatorClass: { 2508 const BinaryOperator *BO = cast<BinaryOperator>(E); 2509 if (BO->getOpcode() == BO_PtrMemD) 2510 Out << "ds"; 2511 else 2512 mangleOperatorName(BinaryOperator::getOverloadedOperator(BO->getOpcode()), 2513 /*Arity=*/2); 2514 mangleExpression(BO->getLHS()); 2515 mangleExpression(BO->getRHS()); 2516 break; 2517 } 2518 2519 case Expr::ConditionalOperatorClass: { 2520 const ConditionalOperator *CO = cast<ConditionalOperator>(E); 2521 mangleOperatorName(OO_Conditional, /*Arity=*/3); 2522 mangleExpression(CO->getCond()); 2523 mangleExpression(CO->getLHS(), Arity); 2524 mangleExpression(CO->getRHS(), Arity); 2525 break; 2526 } 2527 2528 case Expr::ImplicitCastExprClass: { 2529 ImplicitlyConvertedToType = E->getType(); 2530 E = cast<ImplicitCastExpr>(E)->getSubExpr(); 2531 goto recurse; 2532 } 2533 2534 case Expr::ObjCBridgedCastExprClass: { 2535 // Mangle ownership casts as a vendor extended operator __bridge, 2536 // __bridge_transfer, or __bridge_retain. 2537 StringRef Kind = cast<ObjCBridgedCastExpr>(E)->getBridgeKindName(); 2538 Out << "v1U" << Kind.size() << Kind; 2539 } 2540 // Fall through to mangle the cast itself. 2541 2542 case Expr::CStyleCastExprClass: 2543 case Expr::CXXStaticCastExprClass: 2544 case Expr::CXXDynamicCastExprClass: 2545 case Expr::CXXReinterpretCastExprClass: 2546 case Expr::CXXConstCastExprClass: 2547 case Expr::CXXFunctionalCastExprClass: { 2548 const ExplicitCastExpr *ECE = cast<ExplicitCastExpr>(E); 2549 Out << "cv"; 2550 mangleType(ECE->getType()); 2551 mangleExpression(ECE->getSubExpr()); 2552 break; 2553 } 2554 2555 case Expr::CXXOperatorCallExprClass: { 2556 const CXXOperatorCallExpr *CE = cast<CXXOperatorCallExpr>(E); 2557 unsigned NumArgs = CE->getNumArgs(); 2558 mangleOperatorName(CE->getOperator(), /*Arity=*/NumArgs); 2559 // Mangle the arguments. 2560 for (unsigned i = 0; i != NumArgs; ++i) 2561 mangleExpression(CE->getArg(i)); 2562 break; 2563 } 2564 2565 case Expr::ParenExprClass: 2566 mangleExpression(cast<ParenExpr>(E)->getSubExpr(), Arity); 2567 break; 2568 2569 case Expr::DeclRefExprClass: { 2570 const NamedDecl *D = cast<DeclRefExpr>(E)->getDecl(); 2571 2572 switch (D->getKind()) { 2573 default: 2574 // <expr-primary> ::= L <mangled-name> E # external name 2575 Out << 'L'; 2576 mangle(D, "_Z"); 2577 Out << 'E'; 2578 break; 2579 2580 case Decl::ParmVar: 2581 mangleFunctionParam(cast<ParmVarDecl>(D)); 2582 break; 2583 2584 case Decl::EnumConstant: { 2585 const EnumConstantDecl *ED = cast<EnumConstantDecl>(D); 2586 mangleIntegerLiteral(ED->getType(), ED->getInitVal()); 2587 break; 2588 } 2589 2590 case Decl::NonTypeTemplateParm: { 2591 const NonTypeTemplateParmDecl *PD = cast<NonTypeTemplateParmDecl>(D); 2592 mangleTemplateParameter(PD->getIndex()); 2593 break; 2594 } 2595 2596 } 2597 2598 break; 2599 } 2600 2601 case Expr::SubstNonTypeTemplateParmPackExprClass: 2602 // FIXME: not clear how to mangle this! 2603 // template <unsigned N...> class A { 2604 // template <class U...> void foo(U (&x)[N]...); 2605 // }; 2606 Out << "_SUBSTPACK_"; 2607 break; 2608 2609 case Expr::DependentScopeDeclRefExprClass: { 2610 const DependentScopeDeclRefExpr *DRE = cast<DependentScopeDeclRefExpr>(E); 2611 mangleUnresolvedName(DRE->getQualifier(), 0, DRE->getDeclName(), Arity); 2612 2613 // All the <unresolved-name> productions end in a 2614 // base-unresolved-name, where <template-args> are just tacked 2615 // onto the end. 2616 if (DRE->hasExplicitTemplateArgs()) 2617 mangleTemplateArgs(DRE->getExplicitTemplateArgs()); 2618 break; 2619 } 2620 2621 case Expr::CXXBindTemporaryExprClass: 2622 mangleExpression(cast<CXXBindTemporaryExpr>(E)->getSubExpr()); 2623 break; 2624 2625 case Expr::ExprWithCleanupsClass: 2626 mangleExpression(cast<ExprWithCleanups>(E)->getSubExpr(), Arity); 2627 break; 2628 2629 case Expr::FloatingLiteralClass: { 2630 const FloatingLiteral *FL = cast<FloatingLiteral>(E); 2631 Out << 'L'; 2632 mangleType(FL->getType()); 2633 mangleFloat(FL->getValue()); 2634 Out << 'E'; 2635 break; 2636 } 2637 2638 case Expr::CharacterLiteralClass: 2639 Out << 'L'; 2640 mangleType(E->getType()); 2641 Out << cast<CharacterLiteral>(E)->getValue(); 2642 Out << 'E'; 2643 break; 2644 2645 case Expr::CXXBoolLiteralExprClass: 2646 Out << "Lb"; 2647 Out << (cast<CXXBoolLiteralExpr>(E)->getValue() ? '1' : '0'); 2648 Out << 'E'; 2649 break; 2650 2651 case Expr::IntegerLiteralClass: { 2652 llvm::APSInt Value(cast<IntegerLiteral>(E)->getValue()); 2653 if (E->getType()->isSignedIntegerType()) 2654 Value.setIsSigned(true); 2655 mangleIntegerLiteral(E->getType(), Value); 2656 break; 2657 } 2658 2659 case Expr::ImaginaryLiteralClass: { 2660 const ImaginaryLiteral *IE = cast<ImaginaryLiteral>(E); 2661 // Mangle as if a complex literal. 2662 // Proposal from David Vandevoorde, 2010.06.30. 2663 Out << 'L'; 2664 mangleType(E->getType()); 2665 if (const FloatingLiteral *Imag = 2666 dyn_cast<FloatingLiteral>(IE->getSubExpr())) { 2667 // Mangle a floating-point zero of the appropriate type. 2668 mangleFloat(llvm::APFloat(Imag->getValue().getSemantics())); 2669 Out << '_'; 2670 mangleFloat(Imag->getValue()); 2671 } else { 2672 Out << "0_"; 2673 llvm::APSInt Value(cast<IntegerLiteral>(IE->getSubExpr())->getValue()); 2674 if (IE->getSubExpr()->getType()->isSignedIntegerType()) 2675 Value.setIsSigned(true); 2676 mangleNumber(Value); 2677 } 2678 Out << 'E'; 2679 break; 2680 } 2681 2682 case Expr::StringLiteralClass: { 2683 // Revised proposal from David Vandervoorde, 2010.07.15. 2684 Out << 'L'; 2685 assert(isa<ConstantArrayType>(E->getType())); 2686 mangleType(E->getType()); 2687 Out << 'E'; 2688 break; 2689 } 2690 2691 case Expr::GNUNullExprClass: 2692 // FIXME: should this really be mangled the same as nullptr? 2693 // fallthrough 2694 2695 case Expr::CXXNullPtrLiteralExprClass: { 2696 // Proposal from David Vandervoorde, 2010.06.30, as 2697 // modified by ABI list discussion. 2698 Out << "LDnE"; 2699 break; 2700 } 2701 2702 case Expr::PackExpansionExprClass: 2703 Out << "sp"; 2704 mangleExpression(cast<PackExpansionExpr>(E)->getPattern()); 2705 break; 2706 2707 case Expr::SizeOfPackExprClass: { 2708 Out << "sZ"; 2709 const NamedDecl *Pack = cast<SizeOfPackExpr>(E)->getPack(); 2710 if (const TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(Pack)) 2711 mangleTemplateParameter(TTP->getIndex()); 2712 else if (const NonTypeTemplateParmDecl *NTTP 2713 = dyn_cast<NonTypeTemplateParmDecl>(Pack)) 2714 mangleTemplateParameter(NTTP->getIndex()); 2715 else if (const TemplateTemplateParmDecl *TempTP 2716 = dyn_cast<TemplateTemplateParmDecl>(Pack)) 2717 mangleTemplateParameter(TempTP->getIndex()); 2718 else 2719 mangleFunctionParam(cast<ParmVarDecl>(Pack)); 2720 break; 2721 } 2722 2723 case Expr::MaterializeTemporaryExprClass: { 2724 mangleExpression(cast<MaterializeTemporaryExpr>(E)->GetTemporaryExpr()); 2725 break; 2726 } 2727 } 2728} 2729 2730/// Mangle an expression which refers to a parameter variable. 2731/// 2732/// <expression> ::= <function-param> 2733/// <function-param> ::= fp <top-level CV-qualifiers> _ # L == 0, I == 0 2734/// <function-param> ::= fp <top-level CV-qualifiers> 2735/// <parameter-2 non-negative number> _ # L == 0, I > 0 2736/// <function-param> ::= fL <L-1 non-negative number> 2737/// p <top-level CV-qualifiers> _ # L > 0, I == 0 2738/// <function-param> ::= fL <L-1 non-negative number> 2739/// p <top-level CV-qualifiers> 2740/// <I-1 non-negative number> _ # L > 0, I > 0 2741/// 2742/// L is the nesting depth of the parameter, defined as 1 if the 2743/// parameter comes from the innermost function prototype scope 2744/// enclosing the current context, 2 if from the next enclosing 2745/// function prototype scope, and so on, with one special case: if 2746/// we've processed the full parameter clause for the innermost 2747/// function type, then L is one less. This definition conveniently 2748/// makes it irrelevant whether a function's result type was written 2749/// trailing or leading, but is otherwise overly complicated; the 2750/// numbering was first designed without considering references to 2751/// parameter in locations other than return types, and then the 2752/// mangling had to be generalized without changing the existing 2753/// manglings. 2754/// 2755/// I is the zero-based index of the parameter within its parameter 2756/// declaration clause. Note that the original ABI document describes 2757/// this using 1-based ordinals. 2758void CXXNameMangler::mangleFunctionParam(const ParmVarDecl *parm) { 2759 unsigned parmDepth = parm->getFunctionScopeDepth(); 2760 unsigned parmIndex = parm->getFunctionScopeIndex(); 2761 2762 // Compute 'L'. 2763 // parmDepth does not include the declaring function prototype. 2764 // FunctionTypeDepth does account for that. 2765 assert(parmDepth < FunctionTypeDepth.getDepth()); 2766 unsigned nestingDepth = FunctionTypeDepth.getDepth() - parmDepth; 2767 if (FunctionTypeDepth.isInResultType()) 2768 nestingDepth--; 2769 2770 if (nestingDepth == 0) { 2771 Out << "fp"; 2772 } else { 2773 Out << "fL" << (nestingDepth - 1) << 'p'; 2774 } 2775 2776 // Top-level qualifiers. We don't have to worry about arrays here, 2777 // because parameters declared as arrays should already have been 2778 // tranformed to have pointer type. FIXME: apparently these don't 2779 // get mangled if used as an rvalue of a known non-class type? 2780 assert(!parm->getType()->isArrayType() 2781 && "parameter's type is still an array type?"); 2782 mangleQualifiers(parm->getType().getQualifiers()); 2783 2784 // Parameter index. 2785 if (parmIndex != 0) { 2786 Out << (parmIndex - 1); 2787 } 2788 Out << '_'; 2789} 2790 2791void CXXNameMangler::mangleCXXCtorType(CXXCtorType T) { 2792 // <ctor-dtor-name> ::= C1 # complete object constructor 2793 // ::= C2 # base object constructor 2794 // ::= C3 # complete object allocating constructor 2795 // 2796 switch (T) { 2797 case Ctor_Complete: 2798 Out << "C1"; 2799 break; 2800 case Ctor_Base: 2801 Out << "C2"; 2802 break; 2803 case Ctor_CompleteAllocating: 2804 Out << "C3"; 2805 break; 2806 } 2807} 2808 2809void CXXNameMangler::mangleCXXDtorType(CXXDtorType T) { 2810 // <ctor-dtor-name> ::= D0 # deleting destructor 2811 // ::= D1 # complete object destructor 2812 // ::= D2 # base object destructor 2813 // 2814 switch (T) { 2815 case Dtor_Deleting: 2816 Out << "D0"; 2817 break; 2818 case Dtor_Complete: 2819 Out << "D1"; 2820 break; 2821 case Dtor_Base: 2822 Out << "D2"; 2823 break; 2824 } 2825} 2826 2827void CXXNameMangler::mangleTemplateArgs( 2828 const ASTTemplateArgumentListInfo &TemplateArgs) { 2829 // <template-args> ::= I <template-arg>+ E 2830 Out << 'I'; 2831 for (unsigned i = 0, e = TemplateArgs.NumTemplateArgs; i != e; ++i) 2832 mangleTemplateArg(0, TemplateArgs.getTemplateArgs()[i].getArgument()); 2833 Out << 'E'; 2834} 2835 2836void CXXNameMangler::mangleTemplateArgs(TemplateName Template, 2837 const TemplateArgument *TemplateArgs, 2838 unsigned NumTemplateArgs) { 2839 if (TemplateDecl *TD = Template.getAsTemplateDecl()) 2840 return mangleTemplateArgs(*TD->getTemplateParameters(), TemplateArgs, 2841 NumTemplateArgs); 2842 2843 mangleUnresolvedTemplateArgs(TemplateArgs, NumTemplateArgs); 2844} 2845 2846void CXXNameMangler::mangleUnresolvedTemplateArgs(const TemplateArgument *args, 2847 unsigned numArgs) { 2848 // <template-args> ::= I <template-arg>+ E 2849 Out << 'I'; 2850 for (unsigned i = 0; i != numArgs; ++i) 2851 mangleTemplateArg(0, args[i]); 2852 Out << 'E'; 2853} 2854 2855void CXXNameMangler::mangleTemplateArgs(const TemplateParameterList &PL, 2856 const TemplateArgumentList &AL) { 2857 // <template-args> ::= I <template-arg>+ E 2858 Out << 'I'; 2859 for (unsigned i = 0, e = AL.size(); i != e; ++i) 2860 mangleTemplateArg(PL.getParam(i), AL[i]); 2861 Out << 'E'; 2862} 2863 2864void CXXNameMangler::mangleTemplateArgs(const TemplateParameterList &PL, 2865 const TemplateArgument *TemplateArgs, 2866 unsigned NumTemplateArgs) { 2867 // <template-args> ::= I <template-arg>+ E 2868 Out << 'I'; 2869 for (unsigned i = 0; i != NumTemplateArgs; ++i) 2870 mangleTemplateArg(PL.getParam(i), TemplateArgs[i]); 2871 Out << 'E'; 2872} 2873 2874void CXXNameMangler::mangleTemplateArg(const NamedDecl *P, 2875 TemplateArgument A) { 2876 // <template-arg> ::= <type> # type or template 2877 // ::= X <expression> E # expression 2878 // ::= <expr-primary> # simple expressions 2879 // ::= J <template-arg>* E # argument pack 2880 // ::= sp <expression> # pack expansion of (C++0x) 2881 if (!A.isInstantiationDependent() || A.isDependent()) 2882 A = Context.getASTContext().getCanonicalTemplateArgument(A); 2883 2884 switch (A.getKind()) { 2885 case TemplateArgument::Null: 2886 llvm_unreachable("Cannot mangle NULL template argument"); 2887 2888 case TemplateArgument::Type: 2889 mangleType(A.getAsType()); 2890 break; 2891 case TemplateArgument::Template: 2892 // This is mangled as <type>. 2893 mangleType(A.getAsTemplate()); 2894 break; 2895 case TemplateArgument::TemplateExpansion: 2896 // <type> ::= Dp <type> # pack expansion (C++0x) 2897 Out << "Dp"; 2898 mangleType(A.getAsTemplateOrTemplatePattern()); 2899 break; 2900 case TemplateArgument::Expression: 2901 Out << 'X'; 2902 mangleExpression(A.getAsExpr()); 2903 Out << 'E'; 2904 break; 2905 case TemplateArgument::Integral: 2906 mangleIntegerLiteral(A.getIntegralType(), *A.getAsIntegral()); 2907 break; 2908 case TemplateArgument::Declaration: { 2909 assert(P && "Missing template parameter for declaration argument"); 2910 // <expr-primary> ::= L <mangled-name> E # external name 2911 2912 // Clang produces AST's where pointer-to-member-function expressions 2913 // and pointer-to-function expressions are represented as a declaration not 2914 // an expression. We compensate for it here to produce the correct mangling. 2915 NamedDecl *D = cast<NamedDecl>(A.getAsDecl()); 2916 const NonTypeTemplateParmDecl *Parameter = cast<NonTypeTemplateParmDecl>(P); 2917 bool compensateMangling = !Parameter->getType()->isReferenceType(); 2918 if (compensateMangling) { 2919 Out << 'X'; 2920 mangleOperatorName(OO_Amp, 1); 2921 } 2922 2923 Out << 'L'; 2924 // References to external entities use the mangled name; if the name would 2925 // not normally be manged then mangle it as unqualified. 2926 // 2927 // FIXME: The ABI specifies that external names here should have _Z, but 2928 // gcc leaves this off. 2929 if (compensateMangling) 2930 mangle(D, "_Z"); 2931 else 2932 mangle(D, "Z"); 2933 Out << 'E'; 2934 2935 if (compensateMangling) 2936 Out << 'E'; 2937 2938 break; 2939 } 2940 2941 case TemplateArgument::Pack: { 2942 // Note: proposal by Mike Herrick on 12/20/10 2943 Out << 'J'; 2944 for (TemplateArgument::pack_iterator PA = A.pack_begin(), 2945 PAEnd = A.pack_end(); 2946 PA != PAEnd; ++PA) 2947 mangleTemplateArg(P, *PA); 2948 Out << 'E'; 2949 } 2950 } 2951} 2952 2953void CXXNameMangler::mangleTemplateParameter(unsigned Index) { 2954 // <template-param> ::= T_ # first template parameter 2955 // ::= T <parameter-2 non-negative number> _ 2956 if (Index == 0) 2957 Out << "T_"; 2958 else 2959 Out << 'T' << (Index - 1) << '_'; 2960} 2961 2962void CXXNameMangler::mangleExistingSubstitution(QualType type) { 2963 bool result = mangleSubstitution(type); 2964 assert(result && "no existing substitution for type"); 2965 (void) result; 2966} 2967 2968void CXXNameMangler::mangleExistingSubstitution(TemplateName tname) { 2969 bool result = mangleSubstitution(tname); 2970 assert(result && "no existing substitution for template name"); 2971 (void) result; 2972} 2973 2974// <substitution> ::= S <seq-id> _ 2975// ::= S_ 2976bool CXXNameMangler::mangleSubstitution(const NamedDecl *ND) { 2977 // Try one of the standard substitutions first. 2978 if (mangleStandardSubstitution(ND)) 2979 return true; 2980 2981 ND = cast<NamedDecl>(ND->getCanonicalDecl()); 2982 return mangleSubstitution(reinterpret_cast<uintptr_t>(ND)); 2983} 2984 2985bool CXXNameMangler::mangleSubstitution(QualType T) { 2986 if (!T.getCVRQualifiers()) { 2987 if (const RecordType *RT = T->getAs<RecordType>()) 2988 return mangleSubstitution(RT->getDecl()); 2989 } 2990 2991 uintptr_t TypePtr = reinterpret_cast<uintptr_t>(T.getAsOpaquePtr()); 2992 2993 return mangleSubstitution(TypePtr); 2994} 2995 2996bool CXXNameMangler::mangleSubstitution(TemplateName Template) { 2997 if (TemplateDecl *TD = Template.getAsTemplateDecl()) 2998 return mangleSubstitution(TD); 2999 3000 Template = Context.getASTContext().getCanonicalTemplateName(Template); 3001 return mangleSubstitution( 3002 reinterpret_cast<uintptr_t>(Template.getAsVoidPointer())); 3003} 3004 3005bool CXXNameMangler::mangleSubstitution(uintptr_t Ptr) { 3006 llvm::DenseMap<uintptr_t, unsigned>::iterator I = Substitutions.find(Ptr); 3007 if (I == Substitutions.end()) 3008 return false; 3009 3010 unsigned SeqID = I->second; 3011 if (SeqID == 0) 3012 Out << "S_"; 3013 else { 3014 SeqID--; 3015 3016 // <seq-id> is encoded in base-36, using digits and upper case letters. 3017 char Buffer[10]; 3018 char *BufferPtr = llvm::array_endof(Buffer); 3019 3020 if (SeqID == 0) *--BufferPtr = '0'; 3021 3022 while (SeqID) { 3023 assert(BufferPtr > Buffer && "Buffer overflow!"); 3024 3025 char c = static_cast<char>(SeqID % 36); 3026 3027 *--BufferPtr = (c < 10 ? '0' + c : 'A' + c - 10); 3028 SeqID /= 36; 3029 } 3030 3031 Out << 'S' 3032 << StringRef(BufferPtr, llvm::array_endof(Buffer)-BufferPtr) 3033 << '_'; 3034 } 3035 3036 return true; 3037} 3038 3039static bool isCharType(QualType T) { 3040 if (T.isNull()) 3041 return false; 3042 3043 return T->isSpecificBuiltinType(BuiltinType::Char_S) || 3044 T->isSpecificBuiltinType(BuiltinType::Char_U); 3045} 3046 3047/// isCharSpecialization - Returns whether a given type is a template 3048/// specialization of a given name with a single argument of type char. 3049static bool isCharSpecialization(QualType T, const char *Name) { 3050 if (T.isNull()) 3051 return false; 3052 3053 const RecordType *RT = T->getAs<RecordType>(); 3054 if (!RT) 3055 return false; 3056 3057 const ClassTemplateSpecializationDecl *SD = 3058 dyn_cast<ClassTemplateSpecializationDecl>(RT->getDecl()); 3059 if (!SD) 3060 return false; 3061 3062 if (!isStdNamespace(SD->getDeclContext())) 3063 return false; 3064 3065 const TemplateArgumentList &TemplateArgs = SD->getTemplateArgs(); 3066 if (TemplateArgs.size() != 1) 3067 return false; 3068 3069 if (!isCharType(TemplateArgs[0].getAsType())) 3070 return false; 3071 3072 return SD->getIdentifier()->getName() == Name; 3073} 3074 3075template <std::size_t StrLen> 3076static bool isStreamCharSpecialization(const ClassTemplateSpecializationDecl*SD, 3077 const char (&Str)[StrLen]) { 3078 if (!SD->getIdentifier()->isStr(Str)) 3079 return false; 3080 3081 const TemplateArgumentList &TemplateArgs = SD->getTemplateArgs(); 3082 if (TemplateArgs.size() != 2) 3083 return false; 3084 3085 if (!isCharType(TemplateArgs[0].getAsType())) 3086 return false; 3087 3088 if (!isCharSpecialization(TemplateArgs[1].getAsType(), "char_traits")) 3089 return false; 3090 3091 return true; 3092} 3093 3094bool CXXNameMangler::mangleStandardSubstitution(const NamedDecl *ND) { 3095 // <substitution> ::= St # ::std:: 3096 if (const NamespaceDecl *NS = dyn_cast<NamespaceDecl>(ND)) { 3097 if (isStd(NS)) { 3098 Out << "St"; 3099 return true; 3100 } 3101 } 3102 3103 if (const ClassTemplateDecl *TD = dyn_cast<ClassTemplateDecl>(ND)) { 3104 if (!isStdNamespace(TD->getDeclContext())) 3105 return false; 3106 3107 // <substitution> ::= Sa # ::std::allocator 3108 if (TD->getIdentifier()->isStr("allocator")) { 3109 Out << "Sa"; 3110 return true; 3111 } 3112 3113 // <<substitution> ::= Sb # ::std::basic_string 3114 if (TD->getIdentifier()->isStr("basic_string")) { 3115 Out << "Sb"; 3116 return true; 3117 } 3118 } 3119 3120 if (const ClassTemplateSpecializationDecl *SD = 3121 dyn_cast<ClassTemplateSpecializationDecl>(ND)) { 3122 if (!isStdNamespace(SD->getDeclContext())) 3123 return false; 3124 3125 // <substitution> ::= Ss # ::std::basic_string<char, 3126 // ::std::char_traits<char>, 3127 // ::std::allocator<char> > 3128 if (SD->getIdentifier()->isStr("basic_string")) { 3129 const TemplateArgumentList &TemplateArgs = SD->getTemplateArgs(); 3130 3131 if (TemplateArgs.size() != 3) 3132 return false; 3133 3134 if (!isCharType(TemplateArgs[0].getAsType())) 3135 return false; 3136 3137 if (!isCharSpecialization(TemplateArgs[1].getAsType(), "char_traits")) 3138 return false; 3139 3140 if (!isCharSpecialization(TemplateArgs[2].getAsType(), "allocator")) 3141 return false; 3142 3143 Out << "Ss"; 3144 return true; 3145 } 3146 3147 // <substitution> ::= Si # ::std::basic_istream<char, 3148 // ::std::char_traits<char> > 3149 if (isStreamCharSpecialization(SD, "basic_istream")) { 3150 Out << "Si"; 3151 return true; 3152 } 3153 3154 // <substitution> ::= So # ::std::basic_ostream<char, 3155 // ::std::char_traits<char> > 3156 if (isStreamCharSpecialization(SD, "basic_ostream")) { 3157 Out << "So"; 3158 return true; 3159 } 3160 3161 // <substitution> ::= Sd # ::std::basic_iostream<char, 3162 // ::std::char_traits<char> > 3163 if (isStreamCharSpecialization(SD, "basic_iostream")) { 3164 Out << "Sd"; 3165 return true; 3166 } 3167 } 3168 return false; 3169} 3170 3171void CXXNameMangler::addSubstitution(QualType T) { 3172 if (!T.getCVRQualifiers()) { 3173 if (const RecordType *RT = T->getAs<RecordType>()) { 3174 addSubstitution(RT->getDecl()); 3175 return; 3176 } 3177 } 3178 3179 uintptr_t TypePtr = reinterpret_cast<uintptr_t>(T.getAsOpaquePtr()); 3180 addSubstitution(TypePtr); 3181} 3182 3183void CXXNameMangler::addSubstitution(TemplateName Template) { 3184 if (TemplateDecl *TD = Template.getAsTemplateDecl()) 3185 return addSubstitution(TD); 3186 3187 Template = Context.getASTContext().getCanonicalTemplateName(Template); 3188 addSubstitution(reinterpret_cast<uintptr_t>(Template.getAsVoidPointer())); 3189} 3190 3191void CXXNameMangler::addSubstitution(uintptr_t Ptr) { 3192 assert(!Substitutions.count(Ptr) && "Substitution already exists!"); 3193 Substitutions[Ptr] = SeqID++; 3194} 3195 3196// 3197 3198/// \brief Mangles the name of the declaration D and emits that name to the 3199/// given output stream. 3200/// 3201/// If the declaration D requires a mangled name, this routine will emit that 3202/// mangled name to \p os and return true. Otherwise, \p os will be unchanged 3203/// and this routine will return false. In this case, the caller should just 3204/// emit the identifier of the declaration (\c D->getIdentifier()) as its 3205/// name. 3206void ItaniumMangleContext::mangleName(const NamedDecl *D, 3207 raw_ostream &Out) { 3208 assert((isa<FunctionDecl>(D) || isa<VarDecl>(D)) && 3209 "Invalid mangleName() call, argument is not a variable or function!"); 3210 assert(!isa<CXXConstructorDecl>(D) && !isa<CXXDestructorDecl>(D) && 3211 "Invalid mangleName() call on 'structor decl!"); 3212 3213 PrettyStackTraceDecl CrashInfo(D, SourceLocation(), 3214 getASTContext().getSourceManager(), 3215 "Mangling declaration"); 3216 3217 CXXNameMangler Mangler(*this, Out, D); 3218 return Mangler.mangle(D); 3219} 3220 3221void ItaniumMangleContext::mangleCXXCtor(const CXXConstructorDecl *D, 3222 CXXCtorType Type, 3223 raw_ostream &Out) { 3224 CXXNameMangler Mangler(*this, Out, D, Type); 3225 Mangler.mangle(D); 3226} 3227 3228void ItaniumMangleContext::mangleCXXDtor(const CXXDestructorDecl *D, 3229 CXXDtorType Type, 3230 raw_ostream &Out) { 3231 CXXNameMangler Mangler(*this, Out, D, Type); 3232 Mangler.mangle(D); 3233} 3234 3235void ItaniumMangleContext::mangleThunk(const CXXMethodDecl *MD, 3236 const ThunkInfo &Thunk, 3237 raw_ostream &Out) { 3238 // <special-name> ::= T <call-offset> <base encoding> 3239 // # base is the nominal target function of thunk 3240 // <special-name> ::= Tc <call-offset> <call-offset> <base encoding> 3241 // # base is the nominal target function of thunk 3242 // # first call-offset is 'this' adjustment 3243 // # second call-offset is result adjustment 3244 3245 assert(!isa<CXXDestructorDecl>(MD) && 3246 "Use mangleCXXDtor for destructor decls!"); 3247 CXXNameMangler Mangler(*this, Out); 3248 Mangler.getStream() << "_ZT"; 3249 if (!Thunk.Return.isEmpty()) 3250 Mangler.getStream() << 'c'; 3251 3252 // Mangle the 'this' pointer adjustment. 3253 Mangler.mangleCallOffset(Thunk.This.NonVirtual, Thunk.This.VCallOffsetOffset); 3254 3255 // Mangle the return pointer adjustment if there is one. 3256 if (!Thunk.Return.isEmpty()) 3257 Mangler.mangleCallOffset(Thunk.Return.NonVirtual, 3258 Thunk.Return.VBaseOffsetOffset); 3259 3260 Mangler.mangleFunctionEncoding(MD); 3261} 3262 3263void 3264ItaniumMangleContext::mangleCXXDtorThunk(const CXXDestructorDecl *DD, 3265 CXXDtorType Type, 3266 const ThisAdjustment &ThisAdjustment, 3267 raw_ostream &Out) { 3268 // <special-name> ::= T <call-offset> <base encoding> 3269 // # base is the nominal target function of thunk 3270 CXXNameMangler Mangler(*this, Out, DD, Type); 3271 Mangler.getStream() << "_ZT"; 3272 3273 // Mangle the 'this' pointer adjustment. 3274 Mangler.mangleCallOffset(ThisAdjustment.NonVirtual, 3275 ThisAdjustment.VCallOffsetOffset); 3276 3277 Mangler.mangleFunctionEncoding(DD); 3278} 3279 3280/// mangleGuardVariable - Returns the mangled name for a guard variable 3281/// for the passed in VarDecl. 3282void ItaniumMangleContext::mangleItaniumGuardVariable(const VarDecl *D, 3283 raw_ostream &Out) { 3284 // <special-name> ::= GV <object name> # Guard variable for one-time 3285 // # initialization 3286 CXXNameMangler Mangler(*this, Out); 3287 Mangler.getStream() << "_ZGV"; 3288 Mangler.mangleName(D); 3289} 3290 3291void ItaniumMangleContext::mangleReferenceTemporary(const VarDecl *D, 3292 raw_ostream &Out) { 3293 // We match the GCC mangling here. 3294 // <special-name> ::= GR <object name> 3295 CXXNameMangler Mangler(*this, Out); 3296 Mangler.getStream() << "_ZGR"; 3297 Mangler.mangleName(D); 3298} 3299 3300void ItaniumMangleContext::mangleCXXVTable(const CXXRecordDecl *RD, 3301 raw_ostream &Out) { 3302 // <special-name> ::= TV <type> # virtual table 3303 CXXNameMangler Mangler(*this, Out); 3304 Mangler.getStream() << "_ZTV"; 3305 Mangler.mangleNameOrStandardSubstitution(RD); 3306} 3307 3308void ItaniumMangleContext::mangleCXXVTT(const CXXRecordDecl *RD, 3309 raw_ostream &Out) { 3310 // <special-name> ::= TT <type> # VTT structure 3311 CXXNameMangler Mangler(*this, Out); 3312 Mangler.getStream() << "_ZTT"; 3313 Mangler.mangleNameOrStandardSubstitution(RD); 3314} 3315 3316void ItaniumMangleContext::mangleCXXCtorVTable(const CXXRecordDecl *RD, 3317 int64_t Offset, 3318 const CXXRecordDecl *Type, 3319 raw_ostream &Out) { 3320 // <special-name> ::= TC <type> <offset number> _ <base type> 3321 CXXNameMangler Mangler(*this, Out); 3322 Mangler.getStream() << "_ZTC"; 3323 Mangler.mangleNameOrStandardSubstitution(RD); 3324 Mangler.getStream() << Offset; 3325 Mangler.getStream() << '_'; 3326 Mangler.mangleNameOrStandardSubstitution(Type); 3327} 3328 3329void ItaniumMangleContext::mangleCXXRTTI(QualType Ty, 3330 raw_ostream &Out) { 3331 // <special-name> ::= TI <type> # typeinfo structure 3332 assert(!Ty.hasQualifiers() && "RTTI info cannot have top-level qualifiers"); 3333 CXXNameMangler Mangler(*this, Out); 3334 Mangler.getStream() << "_ZTI"; 3335 Mangler.mangleType(Ty); 3336} 3337 3338void ItaniumMangleContext::mangleCXXRTTIName(QualType Ty, 3339 raw_ostream &Out) { 3340 // <special-name> ::= TS <type> # typeinfo name (null terminated byte string) 3341 CXXNameMangler Mangler(*this, Out); 3342 Mangler.getStream() << "_ZTS"; 3343 Mangler.mangleType(Ty); 3344} 3345 3346MangleContext *clang::createItaniumMangleContext(ASTContext &Context, 3347 DiagnosticsEngine &Diags) { 3348 return new ItaniumMangleContext(Context, Diags); 3349} 3350